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

Merge branch 'development'

Browse Source 
# Conflicts:
#	test/main.cpp
This commit is contained in:
John Wellbelove 2026-04-04 10:02:24 +01:00
commit 22ee76914d
867 changed files with 109831 additions and 73571 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

211
.clang-format
View File

@ -1,57 +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
BasedOnStyle: Chromium
# =============================================================================
# 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
SortIncludes: true
IncludeBlocks: Preserve
# =============================================================================
# Short statements
# =============================================================================
AllowShortBlocksOnASingleLine: Empty
AllowShortFunctionsOnASingleLine: Empty # only empty bodies: void f() {}
AllowShortCaseLabelsOnASingleLine: true # case X: stmt; break; on one line
AllowShortLoopsOnASingleLine: true
AllowShortLambdasOnASingleLine: Inline
# =============================================================================
# Empty lines
# =============================================================================
KeepEmptyLinesAtTheStartOfBlocks: false
EmptyLineBeforeAccessModifier: Always # blank line before public:/private:/protected:
EmptyLineAfterAccessModifier: Always # blank line after public:/private:/protected:
InsertNewlineAtEOF: true
# =============================================================================
# Spacing
# =============================================================================
SpacesInAngles: Leave # preserve C++03 "> >" vs C++11 ">>"
SpacesInContainerLiterals: false
# =============================================================================
# Alignment
# =============================================================================
PointerAlignment: Left # T* ptr, const T& ref
ReferenceAlignment: Left
AlignConsecutiveAssignments: true
AlignConsecutiveDeclarations: true
AlignConsecutiveBitFields: true
AlignConsecutiveMacros: true # align macro bodies
# =============================================================================
# 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: 2
Priority: 0
BinPackParameters: false
BitFieldColonSpacing: Both
# =============================================================================
# Arguments, parameters and constructor initialisers
# =============================================================================
PackConstructorInitializers: Never # each initialiser on its own line
BreakBeforeBraces: Allman
BreakConstructorInitializers: BeforeComma
# =============================================================================
# Namespaces and using declarations
# =============================================================================
SortUsingDeclarations: Lexicographic
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: true
AllowShortFunctionsOnASingleLine: None
AllowShortIfStatementsOnASingleLine: false
# =============================================================================
# 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
AllowAllArgumentsOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
# 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
ConstructorInitializerAllOnOneLineOrOnePerLine: 'true'
ConstructorInitializerIndentWidth: '2'
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
NamespaceIndentation: All
IndentPPDirectives: BeforeHash
PointerAlignment: Left
ColumnLimit: '0'
ContinuationIndentWidth: '2'
UseTab: Never
TabWidth: '2'
IndentWidth: '2'
AccessModifierOffset : '-2'
IndentCaseLabels: false
Cpp11BracedListStyle: 'true'
AlignAfterOpenBracket: Align
AlignConsecutiveDeclarations: true
# Macros that behave like type names
TypenameMacros:
- ETL_OR_STD
#------------------------------------
# Configurations not supported by clang-format v12
#------------------------------------
# BreakInheritanceList: AfterComma
# EmptyLineBeforeAccessModifier: Always
# EmptyLineAfterAccessModifier: Always
# ReferenceAlignment: Left
...
# 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

63
.devcontainer/Dockerfile
View File

@ -1,20 +1,61 @@
ARG BASE_IMAGE_NAME="clang:latest"
ARG BASE_IMAGE_NAME="mcr.microsoft.com/devcontainers/cpp:2@sha256:a5eb5a1e9109af88bf82ebb0f71903608a68144851ed1e4b852e31b251ac59c6"
FROM ${BASE_IMAGE_NAME}
ARG REINSTALL_CMAKE_VERSION_FROM_SOURCE="3.31.7"
ARG DEBIAN_SNAPSHOT="20260223T000000Z"
# Optionally install the cmake for vcpkg
COPY ./reinstall-cmake.sh /tmp/
SHELL ["/bin/bash", "-o", "pipefail", "-c"]
RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
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 \
python3-cogapp \
&& rm -rf /var/lib/apt/lists/*
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 if [ "${REINSTALL_CMAKE_VERSION_FROM_SOURCE}" != "none" ]; then \
chmod +x /tmp/reinstall-cmake.sh && /tmp/reinstall-cmake.sh ${REINSTALL_CMAKE_VERSION_FROM_SOURCE}; \
fi \
&& rm -f /tmp/reinstall-cmake.sh
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

3
.devcontainer/clang10/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "silkeh/clang:10"
"BASE_IMAGE_NAME": "silkeh/clang:10",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

3
.devcontainer/clang11/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "silkeh/clang:11"
"BASE_IMAGE_NAME": "silkeh/clang:11",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

3
.devcontainer/clang12/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "silkeh/clang:12"
"BASE_IMAGE_NAME": "silkeh/clang:12",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

3
.devcontainer/clang13/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "silkeh/clang:13"
"BASE_IMAGE_NAME": "silkeh/clang:13",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

3
.devcontainer/clang14/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "silkeh/clang:14"
"BASE_IMAGE_NAME": "silkeh/clang:14",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

3
.devcontainer/clang15/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "silkeh/clang:15"
"BASE_IMAGE_NAME": "silkeh/clang:15",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

3
.devcontainer/clang16/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "silkeh/clang:16"
"BASE_IMAGE_NAME": "silkeh/clang:16",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

3
.devcontainer/clang17/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "silkeh/clang:17"
"BASE_IMAGE_NAME": "silkeh/clang:17",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

3
.devcontainer/clang18/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "silkeh/clang:18-bullseye"
"BASE_IMAGE_NAME": "silkeh/clang:18-bullseye",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

3
.devcontainer/clang19/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "silkeh/clang:19-bullseye"
"BASE_IMAGE_NAME": "silkeh/clang:19-bullseye",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

3
.devcontainer/clang20/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "silkeh/clang:20-bullseye"
"BASE_IMAGE_NAME": "silkeh/clang:20-bullseye",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

13
.devcontainer/clang21/devcontainer.json Normal file
View File

@ -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"
}
}

3
.devcontainer/clang7/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "silkeh/clang:7"
"BASE_IMAGE_NAME": "silkeh/clang:7",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

3
.devcontainer/clang8/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "silkeh/clang:8"
"BASE_IMAGE_NAME": "silkeh/clang:8",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

3
.devcontainer/clang9/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "silkeh/clang:9"
"BASE_IMAGE_NAME": "silkeh/clang:9",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

3
.devcontainer/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "./Dockerfile",
"args": {
"BASE_IMAGE_NAME": "mcr.microsoft.com/devcontainers/cpp:debian-12"
"BASE_IMAGE_NAME": "mcr.microsoft.com/devcontainers/cpp:2@sha256:a5eb5a1e9109af88bf82ebb0f71903608a68144851ed1e4b852e31b251ac59c6",
"DEBIAN_SNAPSHOT": "20260223T000000Z"
},
"context": "./context"
}

3
.devcontainer/gcc09/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "gcc:9"
"BASE_IMAGE_NAME": "gcc:9",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

3
.devcontainer/gcc10/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "gcc:10"
"BASE_IMAGE_NAME": "gcc:10",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

3
.devcontainer/gcc11/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "gcc:11"
"BASE_IMAGE_NAME": "gcc:11",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

3
.devcontainer/gcc12/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "gcc:12"
"BASE_IMAGE_NAME": "gcc:12",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

3
.devcontainer/gcc13/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "gcc:13"
"BASE_IMAGE_NAME": "gcc:13",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

3
.devcontainer/gcc14/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "gcc:14"
"BASE_IMAGE_NAME": "gcc:14",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

3
.devcontainer/gcc15/devcontainer.json
View File

@ -5,7 +5,8 @@
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "gcc:15"
"BASE_IMAGE_NAME": "gcc:15",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}

40
.devcontainer/s390x/Dockerfile Normal file
View File

@ -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"]

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

@ -0,0 +1,29 @@
// For format details, see https://aka.ms/devcontainer.json. For config options, see the
// README at: https://github.com/devcontainers/templates/tree/main/src/cpp
{
"name": "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"
}

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

@ -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")

43
.github/workflows/clang-format.yaml vendored Normal file
View File

@ -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

21
.github/workflows/clang-format_update.yaml vendored Normal file
View File

@ -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

72
.github/workflows/coverage.yml vendored Normal file
View File

@ -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

2
.gitignore vendored
View File

@ -3,6 +3,8 @@
## Personal
#################
docs/html
hugo/public
hugo/.hugo_build.lock
include/etl/html/
include/etl/latex/
test/vs2013/Debug

45
.treefmt.toml Normal file
View File

@ -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" ]

1
CONTRIBUTING.md
View File

@ -6,6 +6,7 @@ Thanks for considering a contribution! Here’s what you need to know before ope
- 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.

138
arduino/Embedded_Template_Library.h
View File

@ -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

2
arduino/library-arduino.json
View File

@ -1,6 +1,6 @@
{
"name": "Embedded Template Library ETL",
"version": "20.46.2",
"version": "20.47.0",
"authors": {
"name": "John Wellbelove",
"email": "john.wellbelove@etlcpp.com"

2
arduino/library-arduino.properties
View File

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

6
docs/_config.yml Normal file
View File

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

7
docs/index.md Normal file
View File

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

259
docs/manchester.md Normal file
View File

@ -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)

328
docs/ranges.md Normal file
View File

@ -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.

100
docs/source-formatting.md Normal file
View File

@ -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.

959
examples/ArmTimerCallbacks - C++/RTE/Device/STM32F401RETx/system_stm32f4xx.c
View File

File diff suppressed because it is too large Load Diff

2
examples/ArmTimerCallbacks - C++/etl_profile.h
View File

@ -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

80
examples/ArmTimerCallbacks - C++/main.cpp
View File

@ -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))

11
examples/FunctionInterruptSimulation-Delegates/FunctionInterruptSimulation.cpp
View File

@ -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 everything 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.

13
examples/FunctionInterruptSimulation/FunctionInterruptSimulation.cpp
View File

@ -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 everything 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.

16
examples/MutexMessageRouter/MutexMessageRouter.cpp
View File

@ -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;
}

7
examples/QueuedFSM/QueuedFSM.cpp
View File

@ -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;
}

5
examples/QueuedMessageRouter/QueuedMessageRouter.cpp
View File

@ -1,6 +1,6 @@
#include "etl/queue.h"
#include "etl/message_router.h"
#include "etl/queue.h"
#include <iostream>
#include <string>
@ -81,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.
@ -146,4 +146,3 @@ int main()
return 0;
}

12
examples/Scheduler/Scheduler.cpp
View File

@ -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;
}

51
examples/SharedMessage/SharedMessage.cpp
View File

@ -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.

13
examples/UniquePtrWithPool/Main.cpp
View File

@ -6,7 +6,8 @@
struct S
{
S(int a_, double b_)
: a(a_), b(b_)
: a(a_)
, b(b_)
{
}
@ -17,11 +18,11 @@ struct S
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);
};
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);

12
examples/platformio/src/main.cpp
View File

@ -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;
}

53
include/etl/absolute.h
View File

@ -32,19 +32,40 @@ SOFTWARE.
#define ETL_ABSOLUTE_INCLUDED
#include "platform.h"
#include "type_traits.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_NODISCARD
ETL_CONSTEXPR
typename etl::enable_if<etl::is_signed<T>::value, T>::type
absolute(T value) ETL_NOEXCEPT
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;
}
@ -53,10 +74,7 @@ namespace etl
// For unsigned types.
//***************************************************************************
template <typename T>
ETL_NODISCARD
ETL_CONSTEXPR
typename etl::enable_if<etl::is_unsigned<T>::value, T>::type
absolute(T value) ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR typename etl::enable_if<etl::is_unsigned<T>::value, T>::type absolute(T value) ETL_NOEXCEPT
{
return value;
}
@ -66,15 +84,14 @@ namespace etl
// Returns the result as the unsigned type.
//***************************************************************************
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
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);
}
//***************************************************************************
@ -82,14 +99,10 @@ namespace etl
// Returns the result as the unsigned type.
//***************************************************************************
template <typename T>
ETL_NODISCARD
ETL_CONSTEXPR
typename etl::enable_if<etl::is_unsigned<T>::value, T>::type
absolute_unsigned(T value) ETL_NOEXCEPT
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

5487
include/etl/algorithm.h
View File

File diff suppressed because it is too large Load Diff

180
include/etl/alignment.h
View File

@ -32,12 +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 "algorithm.h"
#include <stdint.h>
@ -125,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;
};
@ -154,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:
@ -179,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:
@ -198,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.
@ -219,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
@ -248,35 +253,35 @@ namespace etl
{
/// 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);
}
@ -284,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;
}
@ -293,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;
}
@ -302,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);
}
@ -310,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);
}
@ -319,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
};
@ -374,7 +380,8 @@ namespace etl
#if ETL_USING_CPP11
//***************************************************************************
/// Constructs the instance of T forwarding the given \p args to its constructor.
/// 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)
@ -425,8 +432,8 @@ namespace etl
#endif
//***************************************************************************
/// Default destructor which will NOT call the destructor of the object which
/// was created by calling create().
/// Default destructor which will NOT call the destructor of the object
/// which was created by calling create().
//***************************************************************************
~typed_storage() ETL_NOEXCEPT
{
@ -444,67 +451,72 @@ namespace etl
#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.
/// 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;
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.
/// \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;
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.
/// \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;
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.
/// \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;
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.
/// \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;
valid = true;
return *p;
}
#endif
@ -537,7 +549,7 @@ namespace etl
const_pointer operator->() const ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
{
ETL_ASSERT(has_value(), ETL_ERROR(etl::typed_storage_error));
return &storage.value;
}
@ -560,11 +572,13 @@ namespace etl
private:
typed_storage(etl::typed_storage<T>&) ETL_DELETE;
typed_storage& operator =(etl::typed_storage<T>&) ETL_DELETE;
typed_storage& operator=(etl::typed_storage<T>&) ETL_DELETE;
struct dummy_t {};
struct dummy_t
{
};
//*******************************
//*******************************
union union_type
{
ETL_CONSTEXPR union_type() ETL_NOEXCEPT
@ -572,9 +586,7 @@ namespace etl
{
}
~union_type() ETL_NOEXCEPT
{
}
~union_type() ETL_NOEXCEPT {}
dummy_t dummy;
value_type value;
@ -601,7 +613,7 @@ namespace etl
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;
@ -609,15 +621,16 @@ namespace etl
/// Constructor.
//***************************************************************************
typed_storage_ext(void* pbuffer_) ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
: pbuffer(reinterpret_cast<T*>(pbuffer_)),
valid(false)
: 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.
/// 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)
@ -690,8 +703,8 @@ namespace etl
#endif
//***************************************************************************
/// Default destructor which will NOT call the destructor of the object which
/// was created by calling create().
/// Default destructor which will NOT call the destructor of the object
/// which was created by calling create().
//***************************************************************************
~typed_storage_ext() ETL_NOEXCEPT
{
@ -709,67 +722,72 @@ namespace etl
#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.
/// 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;
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.
/// \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;
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.
/// \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;
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.
/// \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;
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.
/// \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;
valid = true;
return *p;
}
#endif
@ -825,10 +843,10 @@ namespace etl
private:
typed_storage_ext(etl::typed_storage_ext<T>&) ETL_DELETE;
typed_storage_ext& operator =(etl::typed_storage_ext<T>&) ETL_DELETE;
typed_storage_ext& operator=(etl::typed_storage_ext<T>&) ETL_DELETE;
pointer pbuffer;
bool valid;
bool valid;
};
//***************************************************************************
@ -840,8 +858,8 @@ namespace etl
using ETL_OR_STD::swap;
swap(lhs.pbuffer, rhs.pbuffer);
swap(lhs.valid, rhs.valid);
swap(lhs.valid, rhs.valid);
}
}
} // namespace etl
#endif

305
include/etl/array.h
View File

@ -33,20 +33,20 @@ SOFTWARE.
#include "platform.h"
#include "algorithm.h"
#include "iterator.h"
#include "functional.h"
#include "error_handler.h"
#include "exception.h"
#include "type_traits.h"
#include "functional.h"
#include "initializer_list.h"
#include "iterator.h"
#include "nth_type.h"
#include "parameter_type.h"
#include "static_assert.h"
#include "error_handler.h"
#include "nth_type.h"
#include "initializer_list.h"
#include "type_traits.h"
#include <stddef.h>
///\defgroup array array
/// A replacement for std::array if you haven't got C++0x11.
/// A replacement for std::array if you haven't got C++11.
///\ingroup containers
namespace etl
@ -81,7 +81,7 @@ namespace etl
//***************************************************************************
///\ingroup array
/// A replacement for std::array if you haven't got C++0x11.
/// A replacement for std::array if you haven't got C++11.
//***************************************************************************
template <typename T, size_t SIZE_>
class array
@ -94,15 +94,15 @@ namespace etl
static ETL_CONSTANT size_t SIZE = SIZE_;
typedef T value_type;
typedef size_t size_type;
typedef ptrdiff_t difference_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 ptrdiff_t difference_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;
@ -114,9 +114,7 @@ namespace etl
/// Returns a reference to the value at index 'i'.
///\param i The index of the element to access.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
reference at(size_t i) ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
ETL_NODISCARD ETL_CONSTEXPR14 reference at(size_t i) ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
{
ETL_ASSERT(i < SIZE, ETL_ERROR(array_out_of_range));
@ -127,9 +125,7 @@ namespace etl
/// Returns a const reference to the value at index 'i'.
///\param i The index of the element to access.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
const_reference at(size_t i) const ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
ETL_NODISCARD ETL_CONSTEXPR14 const_reference at(size_t i) const ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
{
ETL_ASSERT(i < SIZE, ETL_ERROR(array_out_of_range));
@ -141,9 +137,7 @@ namespace etl
/// Returns a reference to the value at index 'i'.
///\param i The index of the element to access.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
reference operator[](size_t i) ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS || ETL_NOT_CHECKING_INDEX_OPERATOR)
ETL_NODISCARD ETL_CONSTEXPR14 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(array_out_of_range));
@ -155,8 +149,7 @@ namespace etl
/// Returns a const reference to the value at index 'i'.
///\param i The index of the element to access.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_reference operator[](size_t i) const ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS || ETL_NOT_CHECKING_INDEX_OPERATOR)
ETL_NODISCARD 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
@ -171,9 +164,7 @@ namespace etl
//*************************************************************************
/// Returns a reference to the first element.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
reference front() ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 reference front() ETL_NOEXCEPT
{
ETL_STATIC_ASSERT(SIZE > 0, "Array is empty.");
@ -183,8 +174,7 @@ namespace etl
//*************************************************************************
/// Returns a const reference to the first element.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_reference front() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_reference front() const ETL_NOEXCEPT
{
ETL_STATIC_ASSERT(SIZE > 0, "Array is empty.");
@ -194,9 +184,7 @@ namespace etl
//*************************************************************************
/// Returns a reference to the last element.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
reference back() ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 reference back() ETL_NOEXCEPT
{
ETL_STATIC_ASSERT(SIZE > 0, "Array is empty.");
@ -206,8 +194,7 @@ namespace etl
//*************************************************************************
/// Returns a const reference to the last element.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_reference back() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_reference back() const ETL_NOEXCEPT
{
ETL_STATIC_ASSERT(SIZE > 0, "Array is empty.");
@ -217,9 +204,7 @@ namespace etl
//*************************************************************************
/// Returns a pointer to the first element of the internal buffer.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
pointer data() ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 pointer data() ETL_NOEXCEPT
{
return _buffer;
}
@ -227,8 +212,7 @@ namespace etl
//*************************************************************************
/// Returns a const pointer to the first element of the internal buffer.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_pointer data() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_pointer data() const ETL_NOEXCEPT
{
return _buffer;
}
@ -240,9 +224,7 @@ namespace etl
//*************************************************************************
/// Returns an iterator to the beginning of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
iterator begin() ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 iterator begin() ETL_NOEXCEPT
{
return _buffer;
}
@ -250,8 +232,7 @@ namespace etl
//*************************************************************************
/// Returns a const iterator to the beginning of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_iterator begin() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_iterator begin() const ETL_NOEXCEPT
{
return _buffer;
}
@ -259,8 +240,7 @@ namespace etl
//*************************************************************************
/// Returns a const iterator to the beginning of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_iterator cbegin() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_iterator cbegin() const ETL_NOEXCEPT
{
return begin();
}
@ -268,9 +248,7 @@ namespace etl
//*************************************************************************
/// Returns an iterator to the end of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
iterator end() ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 iterator end() ETL_NOEXCEPT
{
return _buffer + SIZE;
}
@ -278,8 +256,7 @@ namespace etl
//*************************************************************************
/// Returns a const iterator to the end of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_iterator end() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_iterator end() const ETL_NOEXCEPT
{
return _buffer + SIZE;
}
@ -287,8 +264,7 @@ namespace etl
//*************************************************************************
// Returns a const iterator to the end of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_iterator cend() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_iterator cend() const ETL_NOEXCEPT
{
return _buffer + SIZE;
}
@ -296,9 +272,7 @@ namespace etl
//*************************************************************************
// Returns an reverse iterator to the reverse beginning of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
reverse_iterator rbegin() ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 reverse_iterator rbegin() ETL_NOEXCEPT
{
return reverse_iterator(end());
}
@ -306,8 +280,7 @@ namespace etl
//*************************************************************************
/// Returns a const reverse iterator to the reverse beginning of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_reverse_iterator rbegin() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_reverse_iterator rbegin() const ETL_NOEXCEPT
{
return const_reverse_iterator(end());
}
@ -315,8 +288,7 @@ namespace etl
//*************************************************************************
/// Returns a const reverse iterator to the reverse beginning of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_reverse_iterator crbegin() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_reverse_iterator crbegin() const ETL_NOEXCEPT
{
return const_reverse_iterator(end());
}
@ -324,9 +296,7 @@ namespace etl
//*************************************************************************
/// Returns a reverse iterator to the end of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
reverse_iterator rend() ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 reverse_iterator rend() ETL_NOEXCEPT
{
return reverse_iterator(begin());
}
@ -334,8 +304,7 @@ namespace etl
//*************************************************************************
/// Returns a const reverse iterator to the end of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_reverse_iterator rend() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_reverse_iterator rend() const ETL_NOEXCEPT
{
return const_reverse_iterator(begin());
}
@ -343,8 +312,7 @@ namespace etl
//*************************************************************************
/// Returns a const reverse iterator to the end of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_reverse_iterator crend() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_reverse_iterator crend() const ETL_NOEXCEPT
{
return const_reverse_iterator(begin());
}
@ -356,8 +324,7 @@ namespace etl
//*************************************************************************
/// Returns <b>true</b> if the array size is zero.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR bool empty() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR bool empty() const ETL_NOEXCEPT
{
return (SIZE == 0);
}
@ -365,8 +332,7 @@ namespace etl
//*************************************************************************
/// Returns the size of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR size_t size() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR size_t size() const ETL_NOEXCEPT
{
return SIZE;
}
@ -374,8 +340,7 @@ namespace etl
//*************************************************************************
/// Returns the maximum possible size of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR size_t max_size() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR size_t max_size() const ETL_NOEXCEPT
{
return SIZE;
}
@ -409,7 +374,8 @@ namespace etl
//*************************************************************************
/// Fills the array from the range.
/// If the range is smaller than the array then the unused array elements are left unmodified.
/// If the range is smaller than the array then the unused array elements
/// are left unmodified.
///\param first The iterator to the first item in the range.
///\param last The iterator to one past the final item in the range.
///\return An iterator to the first unassigned array element, or end().
@ -422,7 +388,8 @@ namespace etl
//*************************************************************************
/// Fills the array from the range.
/// If the range is smaller than the array then the unused array elements are initialised with the supplied value.
/// If the range is smaller than the array then the unused array elements
/// are initialised with the supplied value.
///\param first The iterator to the first item in the range.
///\param last The iterator to one past the final item in the range.
///\return An iterator to the first array element set to 'value', or end().
@ -496,13 +463,13 @@ namespace etl
iterator p = to_iterator(position);
iterator result(p);
size_t source_size = etl::distance(first, last);
size_t destination_space = etl::distance(position, cend());
size_t source_size = static_cast<size_t>(etl::distance(first, last));
size_t destination_space = static_cast<size_t>(etl::distance(position, cend()));
// Do we need to move anything?
if (source_size < destination_space)
{
size_t length = SIZE - (etl::distance(begin(), p) + source_size);
size_t length = SIZE - (static_cast<size_t>(etl::distance(begin(), p)) + source_size);
etl::move_backward(p, p + length, end());
}
@ -570,7 +537,8 @@ namespace etl
//*************************************************************************
/// Erases a value from the array.
///\param position The index of the position to erase at.
///\param value The value to use to overwrite the last element in the array.
///\param value The value to use to overwrite the last element in the
/// array.
//*************************************************************************
inline iterator erase_at(size_t position, parameter_t value)
{
@ -582,7 +550,8 @@ namespace etl
//*************************************************************************
/// Erases a value from the array.
///\param position The iterator to the position to erase at.
///\param value The value to use to overwrite the last element in the array.
///\param value The value to use to overwrite the last element in the
/// array.
//*************************************************************************
iterator erase(const_iterator position, parameter_t value)
{
@ -600,7 +569,8 @@ namespace etl
/// Erases a range of values from the array.
///\param first The first item to erase.
///\param last The one past the last item to erase.
///\param value The value to use to overwrite the last elements in the array.
///\param value The value to use to overwrite the last elements in the
/// array.
//*************************************************************************
iterator erase_range(size_t first, size_t last, parameter_t value)
{
@ -613,7 +583,8 @@ namespace etl
/// Erases a range of values from the array.
///\param first The first item to erase.
///\param last The one past the last item to erase.
///\param value The value to use to overwrite the last elements in the array.
///\param value The value to use to overwrite the last elements in the
/// array.
//*************************************************************************
iterator erase(const_iterator first, const_iterator last, parameter_t value)
{
@ -646,7 +617,7 @@ namespace etl
//***************************************************************************
///\ingroup array
/// A replacement for std::array if you haven't got C++0x11.
/// A replacement for std::array if you haven't got C++11.
/// Specialisation for zero sized array.
//***************************************************************************
template <typename T>
@ -660,15 +631,15 @@ namespace etl
static ETL_CONSTANT size_t SIZE = 0;
typedef T value_type;
typedef size_t size_type;
typedef ptrdiff_t difference_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 ptrdiff_t difference_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;
@ -680,9 +651,7 @@ namespace etl
/// Returns a reference to the value at index 'i'.
///\param i The index of the element to access.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
reference at(size_t) ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 reference at(size_t) ETL_NOEXCEPT
{
return *data();
}
@ -691,9 +660,7 @@ namespace etl
/// Returns a const reference to the value at index 'i'.
///\param i The index of the element to access.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
const_reference at(size_t) const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 const_reference at(size_t) const ETL_NOEXCEPT
{
return *data();
}
@ -703,9 +670,7 @@ namespace etl
/// Returns a reference to the value at index 'i'.
///\param i The index of the element to access.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
reference operator[](size_t) ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 reference operator[](size_t) ETL_NOEXCEPT
{
return *data();
}
@ -715,8 +680,7 @@ namespace etl
/// Returns a const reference to the value at index 'i'.
///\param i The index of the element to access.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_reference operator[](size_t) const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_reference operator[](size_t) const ETL_NOEXCEPT
{
return *data();
}
@ -724,9 +688,7 @@ namespace etl
//*************************************************************************
/// Returns a reference to the first element.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
reference front() ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 reference front() ETL_NOEXCEPT
{
return *data();
}
@ -734,8 +696,7 @@ namespace etl
//*************************************************************************
/// Returns a const reference to the first element.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_reference front() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_reference front() const ETL_NOEXCEPT
{
return *data();
}
@ -743,9 +704,7 @@ namespace etl
//*************************************************************************
/// Returns a reference to the last element.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
reference back() ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 reference back() ETL_NOEXCEPT
{
return *data();
}
@ -753,8 +712,7 @@ namespace etl
//*************************************************************************
/// Returns a const reference to the last element.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_reference back() const
ETL_NODISCARD ETL_CONSTEXPR const_reference back() const
{
return *data();
}
@ -762,9 +720,7 @@ namespace etl
//*************************************************************************
/// Returns a pointer to the first element of the internal buffer.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
pointer data() ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 pointer data() ETL_NOEXCEPT
{
return (T*)0;
}
@ -772,8 +728,7 @@ namespace etl
//*************************************************************************
/// Returns a const pointer to the first element of the internal buffer.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_pointer data() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_pointer data() const ETL_NOEXCEPT
{
return (const T*)0;
}
@ -785,9 +740,7 @@ namespace etl
//*************************************************************************
/// Returns an iterator to the beginning of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
iterator begin() ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 iterator begin() ETL_NOEXCEPT
{
return iterator();
}
@ -795,8 +748,7 @@ namespace etl
//*************************************************************************
/// Returns a const iterator to the beginning of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_iterator begin() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_iterator begin() const ETL_NOEXCEPT
{
return const_iterator();
}
@ -804,8 +756,7 @@ namespace etl
//*************************************************************************
/// Returns a const iterator to the beginning of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_iterator cbegin() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_iterator cbegin() const ETL_NOEXCEPT
{
return const_iterator();
}
@ -813,9 +764,7 @@ namespace etl
//*************************************************************************
/// Returns an iterator to the end of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
iterator end() ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 iterator end() ETL_NOEXCEPT
{
return iterator();
}
@ -823,8 +772,7 @@ namespace etl
//*************************************************************************
/// Returns a const iterator to the end of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_iterator end() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_iterator end() const ETL_NOEXCEPT
{
return const_iterator();
}
@ -832,8 +780,7 @@ namespace etl
//*************************************************************************
// Returns a const iterator to the end of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_iterator cend() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_iterator cend() const ETL_NOEXCEPT
{
return const_iterator();
}
@ -841,9 +788,7 @@ namespace etl
//*************************************************************************
// Returns an reverse iterator to the reverse beginning of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
reverse_iterator rbegin() ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 reverse_iterator rbegin() ETL_NOEXCEPT
{
return reverse_iterator(end());
}
@ -851,8 +796,7 @@ namespace etl
//*************************************************************************
/// Returns a const reverse iterator to the reverse beginning of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_reverse_iterator rbegin() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_reverse_iterator rbegin() const ETL_NOEXCEPT
{
return const_reverse_iterator(end());
}
@ -860,8 +804,7 @@ namespace etl
//*************************************************************************
/// Returns a const reverse iterator to the reverse beginning of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_reverse_iterator crbegin() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_reverse_iterator crbegin() const ETL_NOEXCEPT
{
return const_reverse_iterator(end());
}
@ -869,9 +812,7 @@ namespace etl
//*************************************************************************
/// Returns a reverse iterator to the end of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
reverse_iterator rend() ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 reverse_iterator rend() ETL_NOEXCEPT
{
return reverse_iterator(begin());
}
@ -879,8 +820,7 @@ namespace etl
//*************************************************************************
/// Returns a const reverse iterator to the end of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_reverse_iterator rend() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_reverse_iterator rend() const ETL_NOEXCEPT
{
return const_reverse_iterator(begin());
}
@ -888,8 +828,7 @@ namespace etl
//*************************************************************************
/// Returns a const reverse iterator to the end of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR const_reverse_iterator crend() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR const_reverse_iterator crend() const ETL_NOEXCEPT
{
return const_reverse_iterator(begin());
}
@ -901,8 +840,7 @@ namespace etl
//*************************************************************************
/// Returns <b>true</b> if the array size is zero.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR bool empty() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR bool empty() const ETL_NOEXCEPT
{
return true;
}
@ -910,8 +848,7 @@ namespace etl
//*************************************************************************
/// Returns the size of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR size_t size() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR size_t size() const ETL_NOEXCEPT
{
return 0;
}
@ -919,8 +856,7 @@ namespace etl
//*************************************************************************
/// Returns the maximum possible size of the array.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR size_t max_size() const ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR size_t max_size() const ETL_NOEXCEPT
{
return 0;
}
@ -947,7 +883,8 @@ namespace etl
//*************************************************************************
/// Fills the array from the range.
/// If the range is smaller than the array then the unused array elements are left unmodified.
/// If the range is smaller than the array then the unused array elements
/// are left unmodified.
///\param first The iterator to the first item in the range.
///\param last The iterator to one past the final item in the range.
///\return An iterator to the first unassigned array element, or end().
@ -960,7 +897,8 @@ namespace etl
//*************************************************************************
/// Fills the array from the range.
/// If the range is smaller than the array then the unused array elements are initialised with the supplied value.
/// If the range is smaller than the array then the unused array elements
/// are initialised with the supplied value.
///\param first The iterator to the first item in the range.
///\param last The iterator to one past the final item in the range.
///\return An iterator to the first array element set to 'value', or end().
@ -1060,7 +998,8 @@ namespace etl
//*************************************************************************
/// Erases a value from the array.
///\param position The index of the position to erase at.
///\param value The value to use to overwrite the last element in the array.
///\param value The value to use to overwrite the last element in the
/// array.
//*************************************************************************
inline iterator erase_at(size_t, parameter_t) ETL_NOEXCEPT
{
@ -1070,7 +1009,8 @@ namespace etl
//*************************************************************************
/// Erases a value from the array.
///\param position The iterator to the position to erase at.
///\param value The value to use to overwrite the last element in the array.
///\param value The value to use to overwrite the last element in the
/// array.
//*************************************************************************
iterator erase(const_iterator, parameter_t) ETL_NOEXCEPT
{
@ -1081,7 +1021,8 @@ namespace etl
/// Erases a range of values from the array.
///\param first The first item to erase.
///\param last The one past the last item to erase.
///\param value The value to use to overwrite the last elements in the array.
///\param value The value to use to overwrite the last elements in the
/// array.
//*************************************************************************
iterator erase_range(size_t, size_t, parameter_t) ETL_NOEXCEPT
{
@ -1091,7 +1032,8 @@ namespace etl
//*************************************************************************
/// Erases a range of values from the array.
///\param position The iterator to the position to erase at.
///\param value The value to use to overwrite the last elements in the array.
///\param value The value to use to overwrite the last elements in the
/// array.
//*************************************************************************
iterator erase(const_iterator, const_iterator, parameter_t) ETL_NOEXCEPT
{
@ -1105,7 +1047,7 @@ namespace etl
#if ETL_USING_CPP17
template <typename... T>
array(T...) -> array<typename etl::common_type<T...>::type, sizeof...(T)>;
#endif
#endif
//*************************************************************************
/// Make
@ -1114,7 +1056,7 @@ namespace etl
template <typename T, typename... TValues>
constexpr auto make_array(TValues&&... values) ETL_NOEXCEPT -> etl::array<T, sizeof...(TValues)>
{
return { etl::forward<T>(values)... };
return {etl::forward<T>(values)...};
}
#endif
@ -1124,7 +1066,7 @@ namespace etl
///\param rhs The second array.
//*************************************************************************
template <typename T, const size_t SIZE>
void swap(etl::array<T, SIZE> &lhs, etl::array<T, SIZE> &rhs)
void swap(etl::array<T, SIZE>& lhs, etl::array<T, SIZE>& rhs)
{
lhs.swap(rhs);
}
@ -1136,7 +1078,7 @@ namespace etl
///\return <b>true</b> if the arrays are equal, otherwise <b>false</b>
//*************************************************************************
template <typename T, size_t SIZE>
ETL_CONSTEXPR14 bool operator ==(const etl::array<T, SIZE>& lhs, const etl::array<T, SIZE>& rhs)
ETL_CONSTEXPR14 bool operator==(const etl::array<T, SIZE>& lhs, const etl::array<T, SIZE>& rhs)
{
return etl::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin());
}
@ -1148,7 +1090,7 @@ namespace etl
///\return <b>true</b> if the arrays are not equal, otherwise <b>false</b>
//*************************************************************************
template <typename T, size_t SIZE>
ETL_CONSTEXPR14 bool operator !=(const etl::array<T, SIZE>& lhs, const etl::array<T, SIZE>& rhs)
ETL_CONSTEXPR14 bool operator!=(const etl::array<T, SIZE>& lhs, const etl::array<T, SIZE>& rhs)
{
return !(lhs == rhs);
}
@ -1157,25 +1099,25 @@ namespace etl
/// Less than operator.
///\param lhs The first array.
///\param rhs The second array.
///\return <b>true</b> if the first array is lexicographically less than the second, otherwise <b>false</b>
///\return <b>true</b> if the first array is lexicographically less than the
/// second, otherwise <b>false</b>
//*************************************************************************
template <typename T, size_t SIZE>
bool operator <(const etl::array<T, SIZE>& lhs, const etl::array<T, SIZE>& rhs)
bool operator<(const etl::array<T, SIZE>& lhs, const etl::array<T, SIZE>& rhs)
{
return etl::lexicographical_compare(lhs.cbegin(),
lhs.cend(),
rhs.cbegin(),
rhs.cend());
return etl::lexicographical_compare(lhs.cbegin(), lhs.cend(), rhs.cbegin(), rhs.cend());
}
//*************************************************************************
/// Less than or equal operator.
///\param lhs The first array.
///\param rhs The second array.
///\return <b>true</b> if the first array is lexicographically less than or equal to the second, otherwise <b>false</b>
///\return <b>true</b> if the first array is lexicographically less than or
/// equal to the second, otherwise
///< b>false</b>
//*************************************************************************
template <typename T, size_t SIZE>
bool operator <=(const etl::array<T, SIZE>& lhs, const etl::array<T, SIZE>& rhs)
bool operator<=(const etl::array<T, SIZE>& lhs, const etl::array<T, SIZE>& rhs)
{
return !(lhs > rhs);
}
@ -1184,10 +1126,11 @@ namespace etl
/// Greater than operator.
///\param lhs The first array.
///\param rhs The second array.
///\return <b>true</b> if the first array is lexicographically greater than the second, otherwise <b>false</b>
///\return <b>true</b> if the first array is lexicographically greater than
/// the second, otherwise <b>false</b>
template <typename T, size_t SIZE>
//*************************************************************************
bool operator >(const etl::array<T, SIZE>& lhs, const etl::array<T, SIZE>& rhs)
bool operator>(const etl::array<T, SIZE>& lhs, const etl::array<T, SIZE>& rhs)
{
return (rhs < lhs);
}
@ -1196,10 +1139,12 @@ namespace etl
/// Greater than or equal operator.
///\param lhs The first array.
///\param rhs The second array.
///\return <b>true</b> if the first array is lexicographically greater than or equal to the second, otherwise <b>false</b>
///\return <b>true</b> if the first array is lexicographically greater than or
/// equal to the second, otherwise
///< b>false</b>
//*************************************************************************
template <typename T, size_t SIZE>
bool operator >=(const etl::array<T, SIZE>& lhs, const etl::array<T, SIZE>& rhs)
bool operator>=(const etl::array<T, SIZE>& lhs, const etl::array<T, SIZE>& rhs)
{
return !(lhs < rhs);
}
@ -1233,6 +1178,6 @@ namespace etl
ETL_STATIC_ASSERT(Index < Size, "Index out of bounds");
return a[Index];
}
}
} // namespace etl
#endif

194
include/etl/array_view.h
View File

@ -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,22 +114,22 @@ 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
@ -124,8 +137,8 @@ namespace etl
/// Default constructor.
//*************************************************************************
ETL_CONSTEXPR array_view() ETL_NOEXCEPT
: mbegin(ETL_NULLPTR),
mend(ETL_NULLPTR)
: mbegin(ETL_NULLPTR)
, mend(ETL_NULLPTR)
{
}
@ -133,7 +146,8 @@ namespace etl
//*************************************************************************
/// Construct from etl::array.
//*************************************************************************
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>
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,7 +157,8 @@ namespace etl
//*************************************************************************
/// Construct from etl::array.
//*************************************************************************
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>
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())
@ -154,7 +169,9 @@ namespace etl
/// Construct from etl::array.
//*************************************************************************
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
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())
{
@ -164,7 +181,9 @@ namespace etl
/// Construct from etl::array.
//*************************************************************************
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
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,7 +194,8 @@ namespace etl
//*************************************************************************
/// Construct from std::array.
//*************************************************************************
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>
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,7 +205,8 @@ namespace etl
//*************************************************************************
/// Construct from std::array.
//*************************************************************************
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>
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())
{
@ -239,29 +268,28 @@ namespace etl
//*************************************************************************
template <typename TIterator>
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_))
: mbegin(etl::to_address(begin_))
, mend(etl::to_address(begin_) + etl::distance(begin_, end_))
{
}
//*************************************************************************
/// Construct from iterator and size
//*************************************************************************
template <typename TIterator,
typename TSize>
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_)
: mbegin(etl::to_address(begin_))
, mend(etl::to_address(begin_) + size_)
{
}
//*************************************************************************
/// Construct from C array
//*************************************************************************
template<size_t Array_Size>
ETL_CONSTEXPR array_view(T(&begin_)[Array_Size]) ETL_NOEXCEPT
: 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)
{
}
@ -269,40 +297,52 @@ namespace etl
/// Copy constructor
//*************************************************************************
ETL_CONSTEXPR array_view(const array_view& other) ETL_NOEXCEPT
: mbegin(other.mbegin),
mend(other.mend)
: 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);
}
@ -465,8 +505,7 @@ namespace etl
//*************************************************************************
/// 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::to_address(begin_);
@ -476,18 +515,26 @@ namespace etl
#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) ETL_NOEXCEPT
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 ETL_NOEXCEPT
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];
}
@ -529,10 +576,10 @@ namespace etl
//*************************************************************************
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;
}
//*************************************************************************
@ -540,10 +587,10 @@ namespace etl
//*************************************************************************
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,7 +683,7 @@ namespace etl
}
};
#endif
}
} // namespace etl
//*************************************************************************
/// Swaps the values.

84
include/etl/array_wrapper.h
View File

@ -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;
@ -268,18 +268,29 @@ namespace etl
//*************************************************************************
/// 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) ETL_NOEXCEPT
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_NOEXCEPT
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

2
include/etl/atomic.h
View File

@ -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"

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

File diff suppressed because it is too large Load Diff

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

@ -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

60
include/etl/base64.h
View File

@ -27,27 +27,29 @@ SOFTWARE.
#define ETL_BASE64_INCLUDED
#include "platform.h"
#include "static_assert.h"
#include "exception.h"
#include "error_handler.h"
#include "type_traits.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>
/**************************************************************************************************************************************************************************
* 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
**************************************************************************************************************************************************************************/
* 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
{
@ -114,8 +116,8 @@ namespace etl
{
enum enum_type
{
//RFC_1421, // Not implemented
//RFC_2045, // Not implemented
// RFC_1421, // Not implemented
// RFC_2045, // Not implemented
RFC_2152,
RFC_3501,
RFC_4648,
@ -125,8 +127,8 @@ namespace etl
};
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_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")
@ -166,16 +168,14 @@ namespace etl
enum
{
Invalid_Data = etl::integral_limits<int>::max,
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_)
ETL_CONSTEXPR14 base64(const char* encoder_table_, bool use_padding_)
: encoder_table(encoder_table_)
, use_padding(use_padding_)
{
@ -184,9 +184,7 @@ namespace etl
//*************************************************************************
// Character set for RFC-1421, RFC-2045, RFC-2152 and RFC-4648
//*************************************************************************
static
ETL_CONSTEXPR14
const char* character_set_1()
static ETL_CONSTEXPR14 const char* character_set_1()
{
return "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
}
@ -194,9 +192,7 @@ namespace etl
//*************************************************************************
// Character set for RFC-4648-URL
//*************************************************************************
static
ETL_CONSTEXPR14
const char* character_set_2()
static ETL_CONSTEXPR14 const char* character_set_2()
{
return "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
}
@ -204,9 +200,7 @@ namespace etl
//*************************************************************************
// Character set for RFC-3501-URL
//*************************************************************************
static
ETL_CONSTEXPR14
const char* character_set_3()
static ETL_CONSTEXPR14 const char* character_set_3()
{
return "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,";
}
@ -214,5 +208,5 @@ namespace etl
const char* encoder_table;
const bool use_padding;
};
}
} // namespace etl
#endif

346
include/etl/base64_decoder.h
View File

@ -1,5 +1,5 @@
//*************************************************************************
///Decode from Base64 from and to pointer/length
/// Decode from Base64 from and to pointer/length
//*************************************************************************///\file
/******************************************************************************
@ -29,16 +29,16 @@ SOFTWARE.
#define ETL_BASE64_DECODER_INCLUDED
#include "platform.h"
#include "static_assert.h"
#include "error_handler.h"
#include "type_traits.h"
#include "binary.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 "enum_type.h"
#include "delegate.h"
#include "span.h"
#include "static_assert.h"
#include "type_traits.h"
#include "base64.h"
@ -48,11 +48,12 @@ SOFTWARE.
#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_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))
#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
{
@ -70,8 +71,7 @@ namespace etl
/// Decode to Base64
//*************************************************************************
template <typename T>
ETL_CONSTEXPR14
bool decode(T value)
ETL_CONSTEXPR14 bool decode(T value)
{
ETL_STATIC_ASSERT(ETL_IS_8_BIT_INTEGRAL(T), "Input type must be an 8 bit integral");
@ -101,8 +101,7 @@ namespace etl
/// Decode from Base64
//*************************************************************************
template <typename TInputIterator>
ETL_CONSTEXPR14
bool decode(TInputIterator input_begin, TInputIterator input_end)
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");
@ -121,8 +120,7 @@ namespace etl
/// Decode from Base64
//*************************************************************************
template <typename TInputIterator>
ETL_CONSTEXPR14
bool decode(TInputIterator input_begin, size_t input_length)
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");
@ -141,8 +139,7 @@ namespace etl
/// Decode from Base64
//*************************************************************************
template <typename TInputIterator>
ETL_CONSTEXPR14
bool decode_final(TInputIterator input_begin, TInputIterator input_end)
ETL_CONSTEXPR14 bool decode_final(TInputIterator input_begin, TInputIterator input_end)
{
return decode(input_begin, input_end) && flush();
}
@ -151,8 +148,7 @@ namespace etl
/// Decode from Base64
//*************************************************************************
template <typename TInputIterator>
ETL_CONSTEXPR14
bool decode_final(TInputIterator input_begin, size_t input_length)
ETL_CONSTEXPR14 bool decode_final(TInputIterator input_begin, size_t input_length)
{
return decode(input_begin, input_length) && flush();
}
@ -160,8 +156,7 @@ namespace etl
//*************************************************************************
/// Flush any remaining data to the output.
//*************************************************************************
ETL_CONSTEXPR14
bool flush()
ETL_CONSTEXPR14 bool flush()
{
// Encode any remaining input data.
bool success = decode_block();
@ -193,32 +188,28 @@ namespace etl
//*************************************************************************
/// Reset the encoder.
//*************************************************************************
ETL_CONSTEXPR14
void restart()
ETL_CONSTEXPR14 void restart()
{
reset_input_buffer();
reset_output_buffer();
overflow_detected = false;
overflow_detected = false;
invalid_data_detected = false;
padding_received = false;
padding_received = false;
}
//*************************************************************************
/// Returns the beginning of the output buffer.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
const unsigned char* begin() const
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.
/// This only returns a useful value if a callback has not been set or
/// called.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
const unsigned char* end() const
ETL_NODISCARD ETL_CONSTEXPR14 const unsigned char* end() const
{
return p_output_buffer + output_buffer_length;
}
@ -226,30 +217,26 @@ namespace etl
//*************************************************************************
/// Returns the beginning of the output buffer.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
const unsigned char* cbegin() const
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.
/// This only returns a useful value if a callback has not been set or
/// called.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
const unsigned char* cend() const
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.
/// This only returns a useful value if a callback has not been set or
/// called.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
size_t size() const
ETL_NODISCARD ETL_CONSTEXPR14 size_t size() const
{
return output_buffer_length;
}
@ -257,20 +244,17 @@ namespace etl
//*************************************************************************
/// Returns the maximum size of the output buffer.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
size_t buffer_size() const
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.
/// This only returns a useful span if a callback has not been set or
/// called.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
span_type span() const
ETL_NODISCARD ETL_CONSTEXPR14 span_type span() const
{
return span_type(begin(), end());
}
@ -278,9 +262,7 @@ namespace etl
//*************************************************************************
/// Returns true if the output buffer has overflowed
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
bool overflow() const
ETL_NODISCARD ETL_CONSTEXPR14 bool overflow() const
{
return overflow_detected;
}
@ -288,9 +270,7 @@ namespace etl
//*************************************************************************
/// Returns true if an invalid character was detected.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
bool invalid_data() const
ETL_NODISCARD ETL_CONSTEXPR14 bool invalid_data() const
{
return invalid_data_detected;
}
@ -298,9 +278,7 @@ namespace etl
//*************************************************************************
/// Returns true if an error was detected.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
bool error() const
ETL_NODISCARD ETL_CONSTEXPR14 bool error() const
{
return overflow() || invalid_data();
}
@ -310,12 +288,8 @@ namespace etl
//*************************************************************************
/// 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_)
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)
@ -333,9 +307,7 @@ namespace etl
/// 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)
static ETL_CONSTEXPR14 size_t decoded_size_from_valid_input_length(size_t input_length)
{
return input_length - (input_length / 4U);
}
@ -343,14 +315,13 @@ namespace etl
private:
//*************************************************************************
// Translates a sextet into an index
// Translates a sextet into an index
//*************************************************************************
template <typename T>
ETL_CONSTEXPR14
uint32_t get_index_from_sextet(T sextet)
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));
const char* p_sextet = etl::find(encoder_table, encoder_table_end, static_cast<char>(sextet));
if (p_sextet != encoder_table_end)
{
@ -369,8 +340,7 @@ namespace etl
template <typename T>
ETL_NODISCARD
static
ETL_CONSTEXPR14
T padding()
ETL_CONSTEXPR14 T padding()
{
return static_cast<T>('=');
}
@ -378,51 +348,50 @@ namespace etl
//*************************************************************************
/// Decode one block of data.
//*************************************************************************
ETL_CONSTEXPR14
bool decode_block()
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;
}
{
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;
}
{
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]));
{
// 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;
}
// 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;
}
{
break;
}
}
ETL_ASSERT(!invalid_data_detected, ETL_ERROR(etl::base64_invalid_data));
@ -434,8 +403,7 @@ namespace etl
//*************************************************************************
// Push to the output buffer.
//*************************************************************************
ETL_CONSTEXPR14
void push_to_output_buffer(unsigned char c)
ETL_CONSTEXPR14 void push_to_output_buffer(unsigned char c)
{
if (output_buffer_length < output_buffer_max_size)
{
@ -448,28 +416,25 @@ namespace etl
}
//*************************************************************************
//
//
//*************************************************************************
ETL_CONSTEXPR14
bool output_buffer_is_full() const
ETL_CONSTEXPR14 bool output_buffer_is_full() const
{
return output_buffer_length == output_buffer_max_size;
}
//*************************************************************************
//
//
//*************************************************************************
ETL_CONSTEXPR14
bool output_buffer_is_empty() const
ETL_CONSTEXPR14 bool output_buffer_is_empty() const
{
return output_buffer_length == 0;
}
//*************************************************************************
//
//
//*************************************************************************
ETL_CONSTEXPR14
void reset_output_buffer()
ETL_CONSTEXPR14 void reset_output_buffer()
{
output_buffer_length = 0;
}
@ -478,8 +443,7 @@ namespace etl
// Push to the input buffer.
//*************************************************************************
template <typename T>
ETL_CONSTEXPR14
void push_to_input_buffer(T value)
ETL_CONSTEXPR14 void push_to_input_buffer(T value)
{
if (value == padding<T>())
{
@ -494,25 +458,23 @@ namespace etl
}
else
{
input_buffer[input_buffer_length++] = static_cast<uint8_t>(value);
input_buffer[input_buffer_length++] = static_cast<char>(value);
}
}
}
//*************************************************************************
//
//
//*************************************************************************
ETL_CONSTEXPR14
bool input_buffer_is_full() const
ETL_CONSTEXPR14 bool input_buffer_is_full() const
{
return input_buffer_length == 4U;
}
//*************************************************************************
//
//
//*************************************************************************
ETL_CONSTEXPR14
void reset_input_buffer()
ETL_CONSTEXPR14 void reset_input_buffer()
{
input_buffer_length = 0;
}
@ -544,13 +506,8 @@ namespace etl
//*************************************************************************
/// 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())
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()
{
}
@ -558,13 +515,8 @@ namespace etl
//*************************************************************************
/// 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_)
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()
{
}
@ -574,8 +526,7 @@ namespace etl
//*************************************************************************
ETL_NODISCARD
static
ETL_CONSTEXPR14
size_t safe_output_buffer_size(size_t input_length)
ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
{
return ibase64_decoder::decoded_size_from_valid_input_length(input_length);
}
@ -599,13 +550,8 @@ namespace etl
//*************************************************************************
/// 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())
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()
{
}
@ -613,13 +559,8 @@ namespace etl
//*************************************************************************
/// 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_)
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()
{
}
@ -629,8 +570,7 @@ namespace etl
//*************************************************************************
ETL_NODISCARD
static
ETL_CONSTEXPR14
size_t safe_output_buffer_size(size_t input_length)
ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
{
return ibase64_decoder::decoded_size_from_valid_input_length(input_length);
}
@ -654,13 +594,8 @@ namespace etl
//*************************************************************************
/// 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())
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()
{
}
@ -668,13 +603,8 @@ namespace etl
//*************************************************************************
/// 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_)
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()
{
}
@ -683,9 +613,8 @@ namespace etl
/// Calculate the required output encode buffer size.
//*************************************************************************
ETL_NODISCARD
static
ETL_CONSTEXPR14
size_t safe_output_buffer_size(size_t input_length)
static
ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
{
return ibase64_decoder::decoded_size_from_valid_input_length(input_length);
}
@ -709,13 +638,8 @@ namespace etl
//*************************************************************************
/// 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())
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()
{
}
@ -723,13 +647,8 @@ namespace etl
//*************************************************************************
/// 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_)
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()
{
}
@ -739,8 +658,7 @@ namespace etl
//*************************************************************************
ETL_NODISCARD
static
ETL_CONSTEXPR14
size_t safe_output_buffer_size(size_t input_length)
ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
{
return ibase64_decoder::decoded_size_from_valid_input_length(input_length);
}
@ -764,13 +682,8 @@ namespace etl
//*************************************************************************
/// 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())
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()
{
}
@ -778,13 +691,8 @@ namespace etl
//*************************************************************************
/// 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_)
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()
{
}
@ -794,8 +702,7 @@ namespace etl
//*************************************************************************
ETL_NODISCARD
static
ETL_CONSTEXPR14
size_t safe_output_buffer_size(size_t input_length)
ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
{
return ibase64_decoder::decoded_size_from_valid_input_length(input_length);
}
@ -819,13 +726,8 @@ namespace etl
//*************************************************************************
/// 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())
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()
{
}
@ -833,13 +735,8 @@ namespace etl
//*************************************************************************
/// 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_)
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()
{
}
@ -849,8 +746,7 @@ namespace etl
//*************************************************************************
ETL_NODISCARD
static
ETL_CONSTEXPR14
size_t safe_output_buffer_size(size_t input_length)
ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
{
return ibase64_decoder::decoded_size_from_valid_input_length(input_length);
}
@ -860,7 +756,7 @@ namespace etl
/// 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

377
include/etl/base64_encoder.h
View File

@ -1,5 +1,5 @@
//*************************************************************************
///Decode from Base64 from and to pointer/length
/// Decode from Base64 from and to pointer/length
//*************************************************************************///\file
/******************************************************************************
@ -29,16 +29,16 @@ SOFTWARE.
#define ETL_BASE64_ENCODER_INCLUDED
#include "platform.h"
#include "static_assert.h"
#include "error_handler.h"
#include "type_traits.h"
#include "binary.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 "enum_type.h"
#include "delegate.h"
#include "span.h"
#include "static_assert.h"
#include "type_traits.h"
#include "base64.h"
@ -48,11 +48,12 @@ SOFTWARE.
#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_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))
#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
{
@ -70,8 +71,7 @@ namespace etl
/// Encode to Base64
//*************************************************************************
template <typename T>
ETL_CONSTEXPR14
bool encode(T value)
ETL_CONSTEXPR14 bool encode(T value)
{
ETL_STATIC_ASSERT(ETL_IS_8_BIT_INTEGRAL(T), "Input type must be an 8 bit integral");
@ -99,8 +99,7 @@ namespace etl
/// Encode to Base64
//*************************************************************************
template <typename TInputIterator>
ETL_CONSTEXPR14
bool encode(TInputIterator input_begin, size_t input_length)
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");
@ -119,8 +118,7 @@ namespace etl
/// Encode to Base64
//*************************************************************************
template <typename TInputIterator>
ETL_CONSTEXPR14
bool encode(TInputIterator input_begin, TInputIterator input_end)
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");
@ -139,8 +137,7 @@ namespace etl
/// Encode to Base64
//*************************************************************************
template <typename TInputIterator>
ETL_CONSTEXPR14
bool encode_final(TInputIterator input_begin, size_t input_length)
ETL_CONSTEXPR14 bool encode_final(TInputIterator input_begin, size_t input_length)
{
return encode(input_begin, input_length) && flush();
}
@ -149,8 +146,7 @@ namespace etl
/// Encode to Base64
//*************************************************************************
template <typename TInputIterator>
ETL_CONSTEXPR14
bool encode_final(TInputIterator input_begin, TInputIterator input_end)
ETL_CONSTEXPR14 bool encode_final(TInputIterator input_begin, TInputIterator input_end)
{
return encode(input_begin, input_end) && flush();
}
@ -158,8 +154,7 @@ namespace etl
//*************************************************************************
/// Flush any remaining data to the output.
//*************************************************************************
ETL_CONSTEXPR14
bool flush()
ETL_CONSTEXPR14 bool flush()
{
// Encode any remaining input data.
bool success = encode_block();
@ -189,8 +184,7 @@ namespace etl
//*************************************************************************
/// Reset the encoder.
//*************************************************************************
ETL_CONSTEXPR14
void restart()
ETL_CONSTEXPR14 void restart()
{
reset_input_buffer();
reset_output_buffer();
@ -199,19 +193,16 @@ namespace etl
//*************************************************************************
/// Returns the beginning of the output buffer.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
const char* begin() const
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.
/// This only returns a useful value if a callback has not been set or
/// called.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
const char* end() const
ETL_NODISCARD ETL_CONSTEXPR14 const char* end() const
{
return p_output_buffer + output_buffer_length;
}
@ -219,30 +210,26 @@ namespace etl
//*************************************************************************
/// Returns the beginning of the output buffer.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
const char* cbegin() const
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.
/// This only returns a useful value if a callback has not been set or
/// called.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
const char* cend() const
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.
/// This only returns a useful value if a callback has not been set or
/// called.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
size_t size() const
ETL_NODISCARD ETL_CONSTEXPR14 size_t size() const
{
return output_buffer_length;
}
@ -250,20 +237,17 @@ namespace etl
//*************************************************************************
/// Returns the maximum size of the output buffer.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
size_t max_size() const
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.
/// This only returns a useful span if a callback has not been set or
/// called.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
span_type span() const
ETL_NODISCARD ETL_CONSTEXPR14 span_type span() const
{
return span_type(begin(), end());
}
@ -271,9 +255,7 @@ namespace etl
//*************************************************************************
/// Returns true if the output buffer has overflowed
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
bool overflow() const
ETL_NODISCARD ETL_CONSTEXPR14 bool overflow() const
{
return overflowed;
}
@ -281,9 +263,7 @@ namespace etl
//*************************************************************************
/// Returns true if an error was detected.
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
bool error() const
ETL_NODISCARD ETL_CONSTEXPR14 bool error() const
{
return overflow();
}
@ -293,12 +273,8 @@ namespace etl
//*************************************************************************
/// 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_)
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)
@ -313,64 +289,65 @@ namespace etl
//*************************************************************************
/// Encode one block of data.
//*************************************************************************
ETL_CONSTEXPR14
bool encode_block()
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;
}
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 = (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('=');
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;
}
break;
}
// Only triggered on call to encode().
case 3:
{
uint32_t octets = (input_buffer[0] << 16) | (input_buffer[1] << 8) | input_buffer[2];
{
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;
}
// 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;
}
{
break;
}
}
ETL_ASSERT(!overflowed, ETL_ERROR(etl::base64_overflow));
@ -383,8 +360,7 @@ namespace etl
//*************************************************************************
ETL_NODISCARD
static
ETL_CONSTEXPR14
size_t encoded_size(size_t input_length, bool use_padding)
ETL_CONSTEXPR14 size_t encoded_size(size_t input_length, bool use_padding)
{
size_t required_output_length = 0;
@ -420,8 +396,7 @@ namespace etl
//*************************************************************************
// Push to the output buffer.
//*************************************************************************
ETL_CONSTEXPR14
void push_to_output_buffer(char c)
ETL_CONSTEXPR14 void push_to_output_buffer(char c)
{
if (output_buffer_length < output_buffer_max_size)
{
@ -434,28 +409,25 @@ namespace etl
}
//*************************************************************************
//
//
//*************************************************************************
ETL_CONSTEXPR14
bool output_buffer_is_full() const
ETL_CONSTEXPR14 bool output_buffer_is_full() const
{
return output_buffer_length == output_buffer_max_size;
}
//*************************************************************************
//
//
//*************************************************************************
ETL_CONSTEXPR14
bool output_buffer_is_empty() const
ETL_CONSTEXPR14 bool output_buffer_is_empty() const
{
return output_buffer_length == 0;
}
//*************************************************************************
//
//
//*************************************************************************
ETL_CONSTEXPR14
void reset_output_buffer()
ETL_CONSTEXPR14 void reset_output_buffer()
{
output_buffer_length = 0;
}
@ -464,26 +436,23 @@ namespace etl
// Push to the input buffer.
//*************************************************************************
template <typename T>
ETL_CONSTEXPR14
void push_to_input_buffer(T value)
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
ETL_CONSTEXPR14 bool input_buffer_is_full() const
{
return input_buffer_length == 3U;
}
//*************************************************************************
//
//
//*************************************************************************
ETL_CONSTEXPR14
void reset_input_buffer()
ETL_CONSTEXPR14 void reset_input_buffer()
{
input_buffer_length = 0;
}
@ -496,7 +465,7 @@ namespace etl
const size_t output_buffer_max_size;
callback_type callback;
bool overflowed;
};
@ -508,19 +477,15 @@ namespace etl
{
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");
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())
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()
{
}
@ -528,13 +493,8 @@ namespace etl
//*************************************************************************
/// 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_)
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()
{
}
@ -544,8 +504,7 @@ namespace etl
//*************************************************************************
ETL_NODISCARD
static
ETL_CONSTEXPR14
size_t safe_output_buffer_size(size_t input_length)
ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
{
return ibase64_encoder::encoded_size(input_length, etl::base64::Padding::No_Padding);
}
@ -564,19 +523,15 @@ namespace etl
{
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");
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())
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()
{
}
@ -584,13 +539,8 @@ namespace etl
//*************************************************************************
/// 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_)
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()
{
}
@ -600,8 +550,7 @@ namespace etl
//*************************************************************************
ETL_NODISCARD
static
ETL_CONSTEXPR14
size_t safe_output_buffer_size(size_t input_length)
ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
{
return ibase64_encoder::encoded_size(input_length, etl::base64::Padding::No_Padding);
}
@ -620,19 +569,15 @@ namespace etl
{
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");
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())
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()
{
}
@ -640,13 +585,8 @@ namespace etl
//*************************************************************************
/// 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_)
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()
{
}
@ -656,8 +596,7 @@ namespace etl
//*************************************************************************
ETL_NODISCARD
static
ETL_CONSTEXPR14
size_t safe_output_buffer_size(size_t input_length)
ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
{
return ibase64_encoder::encoded_size(input_length, etl::base64::Padding::No_Padding);
}
@ -676,19 +615,15 @@ namespace etl
{
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");
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())
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()
{
}
@ -696,13 +631,8 @@ namespace etl
//*************************************************************************
/// 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_)
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()
{
}
@ -712,8 +642,7 @@ namespace etl
//*************************************************************************
ETL_NODISCARD
static
ETL_CONSTEXPR14
size_t safe_output_buffer_size(size_t input_length)
ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
{
return ibase64_encoder::encoded_size(input_length, etl::base64::Padding::Use_Padding);
}
@ -732,19 +661,15 @@ namespace etl
{
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");
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())
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()
{
}
@ -752,13 +677,8 @@ namespace etl
//*************************************************************************
/// 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_)
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()
{
}
@ -768,8 +688,7 @@ namespace etl
//*************************************************************************
ETL_NODISCARD
static
ETL_CONSTEXPR14
size_t safe_output_buffer_size(size_t input_length)
ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
{
return ibase64_encoder::encoded_size(input_length, etl::base64::Padding::No_Padding);
}
@ -788,19 +707,15 @@ namespace etl
{
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");
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())
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()
{
}
@ -808,13 +723,8 @@ namespace etl
//*************************************************************************
/// 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_)
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()
{
}
@ -824,8 +734,7 @@ namespace etl
//*************************************************************************
ETL_NODISCARD
static
ETL_CONSTEXPR14
size_t safe_output_buffer_size(size_t input_length)
ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
{
return ibase64_encoder::encoded_size(input_length, etl::base64::Padding::Use_Padding);
}
@ -835,7 +744,7 @@ namespace etl
/// 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

48
include/etl/basic_format_spec.h
View File

@ -34,8 +34,8 @@ SOFTWARE.
///\ingroup string
#include "platform.h"
#include "type_traits.h"
#include "static_assert.h"
#include "type_traits.h"
#include "utility.h"
namespace etl
@ -131,7 +131,7 @@ namespace etl
struct right_spec
{
};
}
} // namespace private_basic_format_spec
//***************************************************************************
// Stream formatting manipulators.
@ -222,14 +222,8 @@ namespace etl
//***************************************************************************
/// Constructor.
//***************************************************************************
ETL_CONSTEXPR basic_format_spec(uint_least8_t base__,
uint_least8_t width__,
uint_least8_t precision__,
bool upper_case__,
bool left_justified__,
bool boolalpha__,
bool show_base__,
typename TString::value_type fill__) ETL_NOEXCEPT
ETL_CONSTEXPR basic_format_spec(uint_least8_t base__, uint_least8_t width__, uint_least8_t precision__, bool upper_case__, bool left_justified__,
bool boolalpha__, bool show_base__, typename TString::value_type fill__) ETL_NOEXCEPT
: base_(base__)
, width_(width__)
, precision_(precision__)
@ -400,7 +394,7 @@ namespace etl
//***************************************************************************
/// Gets the width.
//***************************************************************************
ETL_CONSTEXPR uint32_t get_width() const ETL_NOEXCEPT
ETL_CONSTEXPR uint32_t get_width() const ETL_NOEXCEPT
{
return width_;
}
@ -570,36 +564,32 @@ namespace etl
//***************************************************************************
/// Equality operator.
//***************************************************************************
ETL_CONSTEXPR friend bool operator ==(const basic_format_spec& lhs, const basic_format_spec& rhs)
ETL_CONSTEXPR friend bool operator==(const basic_format_spec& lhs, const basic_format_spec& rhs)
{
return (lhs.base_ == rhs.base_) &&
(lhs.width_ == rhs.width_) &&
(lhs.precision_ == rhs.precision_) &&
(lhs.upper_case_ == rhs.upper_case_) &&
(lhs.left_justified_ == rhs.left_justified_) &&
(lhs.boolalpha_ == rhs.boolalpha_) &&
(lhs.show_base_ == rhs.show_base_) &&
(lhs.fill_ == rhs.fill_);
return (lhs.base_ == rhs.base_) && (lhs.width_ == rhs.width_) && (lhs.precision_ == rhs.precision_) && (lhs.upper_case_ == rhs.upper_case_)
&& (lhs.left_justified_ == rhs.left_justified_) && (lhs.boolalpha_ == rhs.boolalpha_) && (lhs.show_base_ == rhs.show_base_)
&& (lhs.fill_ == rhs.fill_);
}
//***************************************************************************
/// Inequality operator.
//***************************************************************************
ETL_CONSTEXPR friend bool operator !=(const basic_format_spec& lhs, const basic_format_spec& rhs)
ETL_CONSTEXPR friend bool operator!=(const basic_format_spec& lhs, const basic_format_spec& rhs)
{
return !(lhs == rhs);
}
private:
uint_least8_t base_;
uint_least8_t width_;
uint_least8_t precision_;
bool upper_case_;
bool left_justified_;
bool boolalpha_;
bool show_base_;
uint_least8_t base_;
uint_least8_t width_;
uint_least8_t precision_;
bool upper_case_;
bool left_justified_;
bool boolalpha_;
bool show_base_;
typename TString::value_type fill_;
};
}
} // namespace etl
#endif

514
include/etl/basic_string.h
View File

File diff suppressed because it is too large Load Diff

50
include/etl/basic_string_stream.h
View File

@ -35,9 +35,9 @@ SOFTWARE.
#include "platform.h"
#include "to_string.h"
#include "to_u8string.h"
#include "to_u16string.h"
#include "to_u32string.h"
#include "to_u8string.h"
#include "to_wstring.h"
namespace etl
@ -125,16 +125,17 @@ namespace etl
//*********************************
/// TFormat
//*********************************
friend basic_string_stream& operator <<(basic_string_stream& ss, const TFormat& fmt)
friend basic_string_stream& operator<<(basic_string_stream& ss, const TFormat& fmt)
{
ss.format = fmt;
return ss;
}
//*********************************
/// etl::base_spec from etl::setbase, etl::bin, etl::oct, etl::dec & etl::hex stream manipulators
/// etl::base_spec from etl::setbase, etl::bin, etl::oct, etl::dec &
/// etl::hex stream manipulators
//*********************************
friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::base_spec fmt)
friend basic_string_stream& operator<<(basic_string_stream& ss, etl::private_basic_format_spec::base_spec fmt)
{
ss.format.base(fmt.base);
return ss;
@ -143,7 +144,7 @@ namespace etl
//*********************************
/// etl::width_spec from etl::setw stream manipulator
//*********************************
friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::width_spec fmt)
friend basic_string_stream& operator<<(basic_string_stream& ss, etl::private_basic_format_spec::width_spec fmt)
{
ss.format.width(fmt.width);
return ss;
@ -153,7 +154,7 @@ namespace etl
/// etl::fill_spec from etl::setfill stream manipulator
//*********************************
template <typename TChar>
friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::fill_spec<TChar> fmt)
friend basic_string_stream& operator<<(basic_string_stream& ss, etl::private_basic_format_spec::fill_spec<TChar> fmt)
{
ss.format.fill(fmt.fill);
return ss;
@ -162,34 +163,37 @@ namespace etl
//*********************************
/// etl::precision_spec from etl::setprecision stream manipulator
//*********************************
friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::precision_spec fmt)
friend basic_string_stream& operator<<(basic_string_stream& ss, etl::private_basic_format_spec::precision_spec fmt)
{
ss.format.precision(fmt.precision);
return ss;
}
//*********************************
/// etl::boolalpha_spec from etl::boolalpha & etl::noboolalpha stream manipulators
/// etl::boolalpha_spec from etl::boolalpha & etl::noboolalpha stream
/// manipulators
//*********************************
friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::boolalpha_spec fmt)
friend basic_string_stream& operator<<(basic_string_stream& ss, etl::private_basic_format_spec::boolalpha_spec fmt)
{
ss.format.boolalpha(fmt.boolalpha);
return ss;
}
//*********************************
/// etl::uppercase_spec from etl::uppercase & etl::nouppercase stream manipulators
/// etl::uppercase_spec from etl::uppercase & etl::nouppercase stream
/// manipulators
//*********************************
friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::uppercase_spec fmt)
friend basic_string_stream& operator<<(basic_string_stream& ss, etl::private_basic_format_spec::uppercase_spec fmt)
{
ss.format.upper_case(fmt.upper_case);
return ss;
}
//*********************************
/// etl::showbase_spec from etl::showbase & etl::noshowbase stream manipulators
/// etl::showbase_spec from etl::showbase & etl::noshowbase stream
/// manipulators
//*********************************
friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::showbase_spec fmt)
friend basic_string_stream& operator<<(basic_string_stream& ss, etl::private_basic_format_spec::showbase_spec fmt)
{
ss.format.show_base(fmt.show_base);
return ss;
@ -198,7 +202,7 @@ namespace etl
//*********************************
/// etl::left_spec from etl::left stream manipulator
//*********************************
friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::left_spec /*fmt*/)
friend basic_string_stream& operator<<(basic_string_stream& ss, etl::private_basic_format_spec::left_spec /*fmt*/)
{
ss.format.left();
return ss;
@ -207,7 +211,7 @@ namespace etl
//*********************************
/// etl::right_spec from etl::left stream manipulator
//*********************************
friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::right_spec /*fmt*/)
friend basic_string_stream& operator<<(basic_string_stream& ss, etl::private_basic_format_spec::right_spec /*fmt*/)
{
ss.format.right();
return ss;
@ -216,7 +220,7 @@ namespace etl
//*********************************
/// From a string view
//*********************************
friend basic_string_stream& operator <<(basic_string_stream& ss, TStringView view)
friend basic_string_stream& operator<<(basic_string_stream& ss, TStringView view)
{
etl::to_string(view, ss.text, ss.format, true);
return ss;
@ -225,7 +229,7 @@ namespace etl
//*********************************
/// From a character pointer to a string
//*********************************
friend basic_string_stream& operator <<(basic_string_stream& ss, pointer p)
friend basic_string_stream& operator<<(basic_string_stream& ss, pointer p)
{
TStringView view(p);
ss << view;
@ -235,7 +239,7 @@ namespace etl
//*********************************
/// From a const character pointer to a string
//*********************************
friend basic_string_stream& operator <<(basic_string_stream& ss, const_pointer p)
friend basic_string_stream& operator<<(basic_string_stream& ss, const_pointer p)
{
TStringView view(p);
ss << view;
@ -245,7 +249,7 @@ namespace etl
//*********************************
/// From a string interface
//*********************************
friend basic_string_stream& operator <<(basic_string_stream& ss, const TIString& t)
friend basic_string_stream& operator<<(basic_string_stream& ss, const TIString& t)
{
etl::to_string(t, ss.text, ss.format, true);
return ss;
@ -255,7 +259,7 @@ namespace etl
/// From a string
//*********************************
template <template <size_t> class TString, size_t SIZE>
friend basic_string_stream& operator <<(basic_string_stream& ss, const TString<SIZE>& t)
friend basic_string_stream& operator<<(basic_string_stream& ss, const TString<SIZE>& t)
{
const TIString& itext = t;
etl::to_string(itext, ss.str(), ss.get_format(), true);
@ -266,7 +270,7 @@ namespace etl
/// From anything else
//*********************************
template <typename T>
friend basic_string_stream& operator <<(basic_string_stream& ss, const T& value)
friend basic_string_stream& operator<<(basic_string_stream& ss, const T& value)
{
etl::to_string(value, ss.text, ss.format, true);
return ss;
@ -278,8 +282,8 @@ namespace etl
TFormat format;
basic_string_stream(const basic_string_stream&) ETL_DELETE;
basic_string_stream& operator =(const basic_string_stream&) ETL_DELETE;
basic_string_stream& operator=(const basic_string_stream&) ETL_DELETE;
};
}
} // namespace etl
#endif

496
include/etl/binary.h
View File

File diff suppressed because it is too large Load Diff

111
include/etl/bip_buffer_spsc_atomic.h
View File

@ -40,15 +40,15 @@ SOFTWARE.
#include "platform.h"
#include "alignment.h"
#include "parameter_type.h"
#include "atomic.h"
#include "error_handler.h"
#include "file_error_numbers.h"
#include "integral_limits.h"
#include "memory.h"
#include "memory_model.h"
#include "integral_limits.h"
#include "utility.h"
#include "error_handler.h"
#include "parameter_type.h"
#include "span.h"
#include "file_error_numbers.h"
#include "utility.h"
#include <stddef.h>
#include <stdint.h>
@ -60,12 +60,12 @@ namespace etl
//***************************************************************************
/// Base exception for a bip buffer.
//***************************************************************************
class bip_buffer_exception: public exception
class bip_buffer_exception : public exception
{
public:
bip_buffer_exception(string_type reason_, string_type file_name_, numeric_type line_number_)
: exception(reason_, file_name_, line_number_)
: exception(reason_, file_name_, line_number_)
{
}
};
@ -73,7 +73,7 @@ namespace etl
//***************************************************************************
/// Exception for an invalid reserve.
//***************************************************************************
class bip_buffer_reserve_invalid: public bip_buffer_exception
class bip_buffer_reserve_invalid : public bip_buffer_exception
{
public:
@ -117,7 +117,7 @@ namespace etl
size_type size() const
{
size_type write_index = write.load(etl::memory_order_acquire);
size_type read_index = read.load(etl::memory_order_acquire);
size_type read_index = read.load(etl::memory_order_acquire);
// no wraparound
if (write_index >= read_index)
@ -140,7 +140,7 @@ namespace etl
size_type available() const
{
size_type write_index = write.load(etl::memory_order_acquire);
size_type read_index = read.load(etl::memory_order_acquire);
size_type read_index = read.load(etl::memory_order_acquire);
// no wraparound
if (write_index >= read_index)
@ -185,10 +185,10 @@ namespace etl
/// Constructs the buffer.
//*************************************************************************
bip_buffer_spsc_atomic_base(size_type reserved_)
: read(0)
, write(0)
, last(0)
, Reserved(reserved_)
: read(0)
, write(0)
, last(0)
, Reserved(reserved_)
{
}
@ -204,7 +204,7 @@ namespace etl
size_type get_write_reserve(size_type* psize, size_type fallback_size = numeric_limits<size_type>::max())
{
size_type write_index = write.load(etl::memory_order_relaxed);
size_type read_index = read.load(etl::memory_order_acquire);
size_type read_index = read.load(etl::memory_order_acquire);
// No wraparound
if (write_index >= read_index)
@ -262,7 +262,7 @@ namespace etl
if (wsize > 0)
{
size_type write_index = write.load(etl::memory_order_relaxed);
size_type read_index = read.load(etl::memory_order_acquire);
size_type read_index = read.load(etl::memory_order_acquire);
// Wrapped around already
if (write_index < read_index)
@ -285,7 +285,7 @@ namespace etl
// Correct wrapping point
last.store(write_index, etl::memory_order_release);
}
// Always update write index
write.store(windex + wsize, etl::memory_order_release);
}
@ -294,7 +294,7 @@ namespace etl
//*************************************************************************
size_type get_read_reserve(size_type* psize)
{
size_type read_index = read.load(etl::memory_order_relaxed);
size_type read_index = read.load(etl::memory_order_relaxed);
size_type write_index = write.load(etl::memory_order_acquire);
if (read_index > write_index)
@ -344,21 +344,19 @@ namespace etl
etl::atomic<size_type> read;
etl::atomic<size_type> write;
etl::atomic<size_type> last;
const size_type Reserved;
const size_type Reserved;
#if defined(ETL_POLYMORPHIC_SPSC_BIP_BUFFER_ATOMIC) || defined(ETL_POLYMORPHIC_CONTAINERS)
#if defined(ETL_POLYMORPHIC_SPSC_BIP_BUFFER_ATOMIC) || defined(ETL_POLYMORPHIC_CONTAINERS)
public:
virtual ~bip_buffer_spsc_atomic_base()
{
}
#else
virtual ~bip_buffer_spsc_atomic_base() {}
#else
protected:
~bip_buffer_spsc_atomic_base()
{
}
#endif
~bip_buffer_spsc_atomic_base() {}
#endif
};
//***************************************************************************
@ -370,21 +368,21 @@ namespace etl
private:
typedef typename etl::bip_buffer_spsc_atomic_base<Memory_Model> base_t;
using base_t::reset;
using base_t::get_read_reserve;
using base_t::apply_read_reserve;
using base_t::get_write_reserve;
using base_t::apply_write_reserve;
using base_t::get_read_reserve;
using base_t::get_write_reserve;
using base_t::reset;
public:
typedef T value_type; ///< The type stored in the buffer.
typedef T& reference; ///< A reference to the type used in the buffer.
typedef const T& const_reference; ///< A const reference to the type used in the buffer.
#if ETL_USING_CPP11
typedef T&& rvalue_reference;///< An rvalue_reference to the type used in the buffer.
#endif
typedef typename base_t::size_type size_type; ///< The type used for determining the size of the buffer.
typedef T value_type; ///< The type stored in the buffer.
typedef T& reference; ///< A reference to the type used in the buffer.
typedef const T& const_reference; ///< A const reference to the type used in the buffer.
#if ETL_USING_CPP11
typedef T&& rvalue_reference; ///< An rvalue_reference to the type used in the buffer.
#endif
typedef typename base_t::size_type size_type; ///< The type used for determining the size of the buffer.
using base_t::max_size;
@ -394,8 +392,8 @@ namespace etl
span<T> read_reserve(size_type max_reserve_size = numeric_limits<size_type>::max())
{
size_type reserve_size = max_reserve_size;
size_type rindex = get_read_reserve(&reserve_size);
size_type rindex = get_read_reserve(&reserve_size);
return span<T>(p_buffer + rindex, reserve_size);
}
@ -404,7 +402,7 @@ namespace etl
// the reserve can be trimmed at the end before committing.
// Throws bip_buffer_reserve_invalid
//*************************************************************************
void read_commit(const span<T> &reserve)
void read_commit(const span<T>& reserve)
{
size_type rindex = etl::distance(p_buffer, reserve.data());
apply_read_reserve(rindex, reserve.size());
@ -416,8 +414,8 @@ namespace etl
span<T> write_reserve(size_type max_reserve_size)
{
size_type reserve_size = max_reserve_size;
size_type windex = get_write_reserve(&reserve_size);
size_type windex = get_write_reserve(&reserve_size);
return span<T>(p_buffer + windex, reserve_size);
}
@ -427,10 +425,10 @@ namespace etl
//*************************************************************************
span<T> write_reserve_optimal(size_type min_reserve_size = 1U)
{
size_type reserve_size = numeric_limits<size_type>::max();
size_type windex = get_write_reserve(&reserve_size, min_reserve_size);
size_type reserve_size = numeric_limits<size_type>::max();
size_type windex = get_write_reserve(&reserve_size, min_reserve_size);
return span<T>(p_buffer + windex, reserve_size);
return span<T>(p_buffer + windex, reserve_size);
}
//*************************************************************************
@ -438,7 +436,7 @@ namespace etl
// the reserve can be trimmed at the end before committing.
// Throws bip_buffer_reserve_invalid
//*************************************************************************
void write_commit(const span<T> &reserve)
void write_commit(const span<T>& reserve)
{
size_type windex = etl::distance(p_buffer, reserve.data());
apply_write_reserve(windex, reserve.size());
@ -475,12 +473,12 @@ namespace etl
// Disable copy construction and assignment.
ibip_buffer_spsc_atomic(const ibip_buffer_spsc_atomic&) ETL_DELETE;
ibip_buffer_spsc_atomic& operator =(const ibip_buffer_spsc_atomic&) ETL_DELETE;
ibip_buffer_spsc_atomic& operator=(const ibip_buffer_spsc_atomic&) ETL_DELETE;
#if ETL_USING_CPP11
ibip_buffer_spsc_atomic(ibip_buffer_spsc_atomic&&) = delete;
ibip_buffer_spsc_atomic& operator =(ibip_buffer_spsc_atomic&&) = delete;
#endif
#if ETL_USING_CPP11
ibip_buffer_spsc_atomic(ibip_buffer_spsc_atomic&&) = delete;
ibip_buffer_spsc_atomic& operator=(ibip_buffer_spsc_atomic&&) = delete;
#endif
T* const p_buffer;
};
@ -490,7 +488,8 @@ namespace etl
/// This buffer supports concurrent access by one producer and one consumer.
/// \tparam T The type this buffer should support.
/// \tparam Size The maximum capacity of the buffer.
/// \tparam Memory_Model The memory model for the buffer. Determines the type of the internal counter variables.
/// \tparam Memory_Model The memory model for the buffer. Determines the type
/// of the internal counter variables.
//***************************************************************************
template <typename T, const size_t Size, const size_t Memory_Model = etl::memory_model::MEMORY_MODEL_LARGE>
class bip_buffer_spsc_atomic : public ibip_buffer_spsc_atomic<T, Memory_Model>
@ -529,15 +528,15 @@ namespace etl
base_t::clear();
}
private:
private:
/// The uninitialised buffer of T used in the bip_buffer_spsc.
etl::uninitialized_buffer_of<T, Reserved_Size> buffer;
};
template <typename T, const size_t Size, const size_t Memory_Model>
template <typename T, const size_t Size, const size_t Memory_Model>
ETL_CONSTANT typename bip_buffer_spsc_atomic<T, Size, Memory_Model>::size_type bip_buffer_spsc_atomic<T, Size, Memory_Model>::Reserved_Size;
}
} // namespace etl
#endif /* ETL_HAS_ATOMIC && ETL_USING_CPP11 */

83
include/etl/bit.h
View File

@ -32,10 +32,9 @@ SOFTWARE.
#define ETL_BIT_INCLUDED
#include "platform.h"
#include "type_traits.h"
#include "binary.h"
#include "integral_limits.h"
#include "endianness.h"
#include "integral_limits.h"
#include "type_traits.h"
#include <string.h>
@ -51,11 +50,9 @@ namespace etl
//***************************************************************************
template <typename TDestination, typename TSource>
ETL_NODISCARD
typename etl::enable_if<!(etl::is_integral<TDestination>::value&& etl::is_integral<TSource>::value) &&
(sizeof(TDestination) == sizeof(TSource)) &&
etl::is_trivially_copyable<TSource>::value &&
etl::is_trivially_copyable<TDestination>::value, TDestination>::type
bit_cast(const TSource& source) ETL_NOEXCEPT
typename etl::enable_if< !(etl::is_integral<TDestination>::value && etl::is_integral<TSource>::value) && (sizeof(TDestination) == sizeof(TSource))
&& etl::is_trivially_copyable<TSource>::value && etl::is_trivially_copyable<TDestination>::value,
TDestination>::type bit_cast(const TSource& source) ETL_NOEXCEPT
{
TDestination destination;
@ -68,11 +65,9 @@ namespace etl
/// bit_cast - Integral to integral
//***************************************************************************
template <typename TDestination, typename TSource>
ETL_NODISCARD
ETL_CONSTEXPR14
typename etl::enable_if<(etl::is_integral<TDestination>::value && etl::is_integral<TSource>::value) &&
(sizeof(TDestination) == sizeof(TSource)), TDestination>::type
bit_cast(const TSource& source) ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14
typename etl::enable_if< (etl::is_integral<TDestination>::value && etl::is_integral<TSource>::value) && (sizeof(TDestination) == sizeof(TSource)),
TDestination>::type bit_cast(const TSource& source) ETL_NOEXCEPT
{
return static_cast<TDestination>(source);
}
@ -81,9 +76,7 @@ namespace etl
/// byteswap
//***************************************************************************
template <typename T>
ETL_CONSTEXPR14
typename etl::enable_if<etl::is_integral<T>::value, T>::type
byteswap(T value) ETL_NOEXCEPT
ETL_CONSTEXPR14 typename etl::enable_if<etl::is_integral<T>::value, T>::type byteswap(T value) ETL_NOEXCEPT
{
return etl::reverse_bytes(value);
}
@ -92,8 +85,7 @@ namespace etl
/// has_single_bit
//***************************************************************************
template <typename T>
ETL_NODISCARD ETL_CONSTEXPR14
typename etl::enable_if<etl::is_unsigned<T>::value, bool>::type has_single_bit(T value) ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 typename etl::enable_if<etl::is_unsigned<T>::value, bool>::type has_single_bit(T value) ETL_NOEXCEPT
{
return (value & (value - 1)) == 0;
}
@ -101,9 +93,7 @@ namespace etl
/// countl_zero
//***************************************************************************
template <typename T>
ETL_NODISCARD ETL_CONSTEXPR14
typename etl::enable_if<etl::is_unsigned<T>::value, int>::type
countl_zero(T value) ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 typename etl::enable_if<etl::is_unsigned<T>::value, int>::type countl_zero(T value) ETL_NOEXCEPT
{
return etl::count_leading_zeros(value);
}
@ -112,9 +102,7 @@ namespace etl
/// countl_one
//***************************************************************************
template <typename T>
ETL_NODISCARD ETL_CONSTEXPR14
typename etl::enable_if<etl::is_unsigned<T>::value, int>::type
countl_one(T value) ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 typename etl::enable_if<etl::is_unsigned<T>::value, int>::type countl_one(T value) ETL_NOEXCEPT
{
return etl::count_leading_ones(value);
}
@ -123,9 +111,7 @@ namespace etl
/// countr_zero
//***************************************************************************
template <typename T>
ETL_NODISCARD ETL_CONSTEXPR14
typename etl::enable_if<etl::is_unsigned<T>::value, int>::type
countr_zero(T value) ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 typename etl::enable_if<etl::is_unsigned<T>::value, int>::type countr_zero(T value) ETL_NOEXCEPT
{
return etl::count_trailing_zeros(value);
}
@ -134,26 +120,21 @@ namespace etl
/// countr_one
//***************************************************************************
template <typename T>
ETL_NODISCARD ETL_CONSTEXPR14
typename etl::enable_if<etl::is_unsigned<T>::value, int>::type
countr_one(T value) ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 typename etl::enable_if<etl::is_unsigned<T>::value, int>::type countr_one(T value) ETL_NOEXCEPT
{
return etl::count_trailing_ones(value);
}
//***************************************************************************
/// bit_width
//***************************************************************************
template <typename T>
ETL_CONSTEXPR14
typename etl::enable_if<etl::is_unsigned<T>::value, T>::type
bit_width(T value) ETL_NOEXCEPT
ETL_CONSTEXPR14 typename etl::enable_if<etl::is_unsigned<T>::value, T>::type bit_width(T value) ETL_NOEXCEPT
{
#if ETL_USING_CPP20 && ETL_USING_STL
return std::bit_width(value);
return static_cast<T>(std::bit_width(value));
#else
return etl::integral_limits<T>::bits - etl::countl_zero(value);
return static_cast<T>(etl::integral_limits<T>::bits - etl::countl_zero(value));
#endif
}
@ -161,9 +142,7 @@ namespace etl
/// bit_ceil
//***************************************************************************
template <typename T>
ETL_NODISCARD ETL_CONSTEXPR14
typename etl::enable_if<etl::is_unsigned<T>::value, T>::type
bit_ceil(T value)
ETL_NODISCARD ETL_CONSTEXPR14 typename etl::enable_if<etl::is_unsigned<T>::value, T>::type bit_ceil(T value)
{
#if ETL_USING_CPP20 && ETL_USING_STL
return std::bit_ceil(value);
@ -183,9 +162,7 @@ namespace etl
/// bit_floor
//***************************************************************************
template <typename T>
ETL_NODISCARD ETL_CONSTEXPR14
typename etl::enable_if<etl::is_unsigned<T>::value, T>::type
bit_floor(T value) ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 typename etl::enable_if<etl::is_unsigned<T>::value, T>::type bit_floor(T value) ETL_NOEXCEPT
{
#if ETL_USING_CPP20 && ETL_USING_STL
return std::bit_floor(value);
@ -205,17 +182,15 @@ namespace etl
/// rotl
//***************************************************************************
template <typename T>
ETL_NODISCARD ETL_CONSTEXPR14
typename etl::enable_if<etl::is_unsigned<T>::value, T>::type
rotl(T value, int n) ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 typename etl::enable_if<etl::is_unsigned<T>::value, T>::type rotl(T value, int n) ETL_NOEXCEPT
{
if (n < 0)
{
return etl::rotate_right(value, -n);
return etl::rotate_right(value, static_cast<size_t>(-n));
}
else
{
return etl::rotate_left(value, n);
return etl::rotate_left(value, static_cast<size_t>(n));
}
}
@ -223,30 +198,26 @@ namespace etl
/// rotr
//***************************************************************************
template <typename T>
ETL_NODISCARD ETL_CONSTEXPR14
typename etl::enable_if<etl::is_unsigned<T>::value, T>::type
rotr(T value, int n) ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 typename etl::enable_if<etl::is_unsigned<T>::value, T>::type rotr(T value, int n) ETL_NOEXCEPT
{
if (n < 0)
{
return etl::rotate_left(value, -n);
return etl::rotate_left(value, static_cast<size_t>(-n));
}
else
{
return etl::rotate_right(value, n);
return etl::rotate_right(value, static_cast<size_t>(n));
}
}
//***************************************************************************
/// popcount
//***************************************************************************
template <typename T>
ETL_NODISCARD ETL_CONSTEXPR14
typename etl::enable_if<etl::is_unsigned<T>::value, int>::type
popcount(T value) ETL_NOEXCEPT
ETL_NODISCARD ETL_CONSTEXPR14 typename etl::enable_if<etl::is_unsigned<T>::value, int>::type popcount(T value) ETL_NOEXCEPT
{
return etl::count_bits(value);
}
}
} // namespace etl
#endif

158
include/etl/bit_stream.h
View File

@ -27,22 +27,22 @@ SOFTWARE.
#define ETL_BIT_STREAM_INCLUDED
#include "platform.h"
#include "type_traits.h"
#include "nullptr.h"
#include "endianness.h"
#include "integral_limits.h"
#include "binary.h"
#include "algorithm.h"
#include "binary.h"
#include "delegate.h"
#include "endianness.h"
#include "error_handler.h"
#include "exception.h"
#include "integral_limits.h"
#include "iterator.h"
#include "memory.h"
#include "delegate.h"
#include "span.h"
#include "nullptr.h"
#include "optional.h"
#include "exception.h"
#include "error_handler.h"
#include "span.h"
#include "type_traits.h"
#include <stdint.h>
#include <limits.h>
#include <stdint.h>
#include "private/minmax_push.h"
@ -73,7 +73,7 @@ namespace etl
//***************************************************************************
bit_stream(void* begin_, void* end_)
: pdata(reinterpret_cast<unsigned char*>(begin_))
, length_chars(etl::distance(reinterpret_cast<unsigned char*>(begin_), reinterpret_cast<unsigned char*>(end_)))
, length_chars(static_cast<size_t>(etl::distance(reinterpret_cast<unsigned char*>(begin_), reinterpret_cast<unsigned char*>(end_))))
{
restart();
}
@ -93,7 +93,7 @@ namespace etl
//***************************************************************************
void set_stream(void* begin_, size_t length_)
{
pdata = reinterpret_cast<unsigned char*>(begin_);
pdata = reinterpret_cast<unsigned char*>(begin_);
length_chars = length_;
restart();
}
@ -103,7 +103,7 @@ namespace etl
//***************************************************************************
void set_stream(void* begin_, void* end_)
{
set_stream(begin_, etl::distance(reinterpret_cast<unsigned char*>(begin_), reinterpret_cast<unsigned char*>(end_)));
set_stream(begin_, static_cast<size_t>(etl::distance(reinterpret_cast<unsigned char*>(begin_), reinterpret_cast<unsigned char*>(end_))));
}
//***************************************************************************
@ -112,8 +112,8 @@ namespace etl
void restart()
{
bits_available_in_char = CHAR_BIT;
char_index = 0U;
bits_available = CHAR_BIT * length_chars;
char_index = 0U;
bits_available = CHAR_BIT * length_chars;
}
//***************************************************************************
@ -148,8 +148,7 @@ namespace etl
/// For integral types
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value, bool>::type
put(T value, uint_least8_t nbits = CHAR_BIT * sizeof(T))
typename etl::enable_if<etl::is_integral<T>::value, bool>::type put(T value, uint_least8_t nbits = CHAR_BIT * sizeof(T))
{
return put_integral(static_cast<uint32_t>(value), nbits);
}
@ -176,8 +175,7 @@ namespace etl
/// For floating point types
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_floating_point<T>::value, bool>::type
put(T value)
typename etl::enable_if<etl::is_floating_point<T>::value, bool>::type put(T value)
{
bool success = true;
@ -207,7 +205,7 @@ namespace etl
// Do we have enough bits?
if (bits_available > 0U)
{
value = get_bit();
value = get_bit();
success = true;
}
}
@ -219,11 +217,10 @@ namespace etl
/// For integral types
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value, bool>::type
get(T& value, uint_least8_t nbits = CHAR_BIT * sizeof(T))
typename etl::enable_if<etl::is_integral<T>::value, bool>::type get(T& value, uint_least8_t nbits = CHAR_BIT * sizeof(T))
{
bool success = false;
uint_least8_t bits = nbits;
bool success = false;
uint_least8_t bits = nbits;
if (pdata != ETL_NULLPTR)
{
@ -238,7 +235,7 @@ namespace etl
unsigned char mask_width = static_cast<unsigned char>(etl::min(nbits, bits_available_in_char));
typedef typename etl::make_unsigned<T>::type chunk_t;
chunk_t chunk = get_chunk(mask_width);
chunk_t chunk = get_chunk(mask_width);
nbits -= mask_width;
value |= static_cast<T>(chunk << nbits);
@ -252,7 +249,7 @@ namespace etl
if (etl::is_signed<T>::value && (bits != (CHAR_BIT * sizeof(T))))
{
typedef typename etl::make_signed<T>::type ST;
value = etl::sign_extend<ST, ST>(value, bits);
value = static_cast<T>(etl::sign_extend<ST, ST>(static_cast<ST>(value), bits));
}
return success;
@ -262,8 +259,7 @@ namespace etl
/// For floating point types
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_floating_point<T>::value, bool>::type
get(T& value)
typename etl::enable_if<etl::is_floating_point<T>::value, bool>::type get(T& value)
{
bool success = false;
@ -279,7 +275,7 @@ namespace etl
for (size_t i = 0UL; i < sizeof(T); ++i)
{
get(data.raw[i], CHAR_BIT);
get(data.raw[i], CHAR_BIT);
}
from_bytes(reinterpret_cast<const unsigned char*>(data.raw), value);
@ -351,7 +347,7 @@ namespace etl
unsigned char mask_width = static_cast<unsigned char>(etl::min(nbits, bits_available_in_char));
nbits -= mask_width;
uint32_t mask = ((1U << mask_width) - 1U) << nbits;
//uint32_t mask = ((uint32_t(1U) << mask_width) - 1U) << nbits;
// uint32_t mask = ((uint32_t(1U) << mask_width) - 1U) << nbits;
// Move chunk to lowest char bits.
// Chunks are never larger than one char.
@ -422,7 +418,7 @@ namespace etl
//***************************************************************************
unsigned char get_chunk(unsigned char nbits)
{
unsigned char value = pdata[char_index];
unsigned char value = static_cast<unsigned char>(pdata[char_index]);
value >>= (bits_available_in_char - nbits);
@ -434,7 +430,7 @@ namespace etl
}
else
{
mask = (1U << nbits) - 1;
mask = static_cast<unsigned char>((1U << nbits) - 1);
}
value &= mask;
@ -449,7 +445,7 @@ namespace etl
//***************************************************************************
bool get_bit()
{
bool result = (pdata[char_index] & (1U << (bits_available_in_char - 1U))) != 0U;
bool result = (static_cast<unsigned char>(pdata[char_index]) & (1U << (bits_available_in_char - 1U))) != 0U;
step(1U);
@ -467,11 +463,11 @@ namespace etl
// Network to host.
if (etl::endianness::value() == etl::endian::little)
{
etl::reverse_copy(data, data + sizeof(T), temp.raw);
etl::reverse_copy(data, data + sizeof(T), reinterpret_cast<unsigned char*>(temp.raw));
}
else
{
etl::copy(data, data + sizeof(T), temp.raw);
etl::copy(data, data + sizeof(T), reinterpret_cast<unsigned char*>(temp.raw));
}
value = *reinterpret_cast<T*>(temp.raw);
@ -513,11 +509,13 @@ namespace etl
bits_available -= nbits;
}
unsigned char *pdata; ///< The start of the bitstream buffer.
size_t length_chars; ///< The length, in char, of the bitstream buffer.
unsigned char bits_available_in_char; ///< The number of available bits in the current char.
size_t char_index; ///< The index of the char in the bitstream buffer.
size_t bits_available; ///< The number of bits still available in the bitstream buffer.
unsigned char* pdata; ///< The start of the bitstream buffer.
size_t length_chars; ///< The length, in char, of the bitstream buffer.
unsigned char bits_available_in_char; ///< The number of available bits in
///< the current char.
size_t char_index; ///< The index of the char in the bitstream buffer.
size_t bits_available; ///< The number of bits still available in the
///< bitstream buffer.
};
//***************************************************************************
@ -527,10 +525,10 @@ namespace etl
{
public:
typedef char value_type;
typedef value_type* iterator;
typedef const value_type* const_iterator;
typedef etl::span<value_type> callback_parameter_type;
typedef char value_type;
typedef value_type* iterator;
typedef const value_type* const_iterator;
typedef etl::span<value_type> callback_parameter_type;
typedef etl::delegate<void(callback_parameter_type)> callback_type;
//***************************************************************************
@ -564,7 +562,7 @@ namespace etl
//***************************************************************************
bit_stream_writer(void* begin_, void* end_, etl::endian stream_endianness_, callback_type callback_ = callback_type())
: pdata(reinterpret_cast<char*>(begin_))
, length_chars(etl::distance(reinterpret_cast<unsigned char*>(begin_), reinterpret_cast<unsigned char*>(end_)))
, length_chars(static_cast<size_t>(etl::distance(reinterpret_cast<unsigned char*>(begin_), reinterpret_cast<unsigned char*>(end_))))
, stream_endianness(stream_endianness_)
, callback(callback_)
{
@ -589,8 +587,8 @@ namespace etl
void restart()
{
bits_available_in_char = CHAR_BIT;
char_index = 0U;
bits_available = capacity_bits();
char_index = 0U;
bits_available = capacity_bits();
}
//***************************************************************************
@ -653,8 +651,7 @@ namespace etl
/// For integral types
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value, void>::type
write_unchecked(T value, uint_least8_t nbits = CHAR_BIT * sizeof(T))
typename etl::enable_if<etl::is_integral<T>::value, void>::type write_unchecked(T value, uint_least8_t nbits = CHAR_BIT * sizeof(T))
{
typedef typename etl::unsigned_type<T>::type unsigned_t;
@ -665,8 +662,7 @@ namespace etl
/// For integral types
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value, bool>::type
write(T value, uint_least8_t nbits = CHAR_BIT * sizeof(T))
typename etl::enable_if<etl::is_integral<T>::value, bool>::type write(T value, uint_least8_t nbits = CHAR_BIT * sizeof(T))
{
bool success = (available(nbits) > 0U);
@ -975,10 +971,12 @@ namespace etl
char* const pdata; ///< The start of the bitstream buffer.
const size_t length_chars; ///< The length of the bitstream buffer.
const etl::endian stream_endianness; ///< The endianness of the stream data.
unsigned char bits_available_in_char; ///< The number of available bits in the current char.
size_t char_index; ///< The index of the current char in the bitstream buffer.
size_t bits_available; ///< The number of bits still available in the bitstream buffer.
callback_type callback; ///< An optional callback on every filled byte in buffer.
unsigned char bits_available_in_char; ///< The number of available bits in
///< the current char.
size_t char_index; ///< The index of the current char in the bitstream buffer.
size_t bits_available; ///< The number of bits still available in the
///< bitstream buffer.
callback_type callback; ///< An optional callback on every filled byte in buffer.
};
//***************************************************************************
@ -1005,8 +1003,8 @@ namespace etl
/// Overload this to support custom types.
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value, void>::type
write_unchecked(etl::bit_stream_writer& stream, const T& value, uint_least8_t nbits = CHAR_BIT * sizeof(T))
typename etl::enable_if<etl::is_integral<T>::value, void>::type write_unchecked(etl::bit_stream_writer& stream, const T& value,
uint_least8_t nbits = CHAR_BIT * sizeof(T))
{
stream.write_unchecked(value, nbits);
}
@ -1017,8 +1015,8 @@ namespace etl
/// Overload this to support custom types.
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value, bool>::type
write(etl::bit_stream_writer& stream, const T& value, uint_least8_t nbits = CHAR_BIT * sizeof(T))
typename etl::enable_if<etl::is_integral<T>::value, bool>::type write(etl::bit_stream_writer& stream, const T& value,
uint_least8_t nbits = CHAR_BIT * sizeof(T))
{
return stream.write(value, nbits);
}
@ -1030,7 +1028,7 @@ namespace etl
{
public:
typedef char value_type;
typedef char value_type;
typedef const char* const_iterator;
//***************************************************************************
@ -1086,7 +1084,7 @@ namespace etl
//***************************************************************************
bit_stream_reader(const void* begin_, const void* end_, etl::endian stream_endianness_)
: pdata(reinterpret_cast<const char*>(begin_))
, length_chars(etl::distance(reinterpret_cast<const char*>(begin_), reinterpret_cast<const char*>(end_)))
, length_chars(static_cast<size_t>(etl::distance(reinterpret_cast<const char*>(begin_), reinterpret_cast<const char*>(end_))))
, stream_endianness(stream_endianness_)
{
restart();
@ -1109,16 +1107,15 @@ namespace etl
void restart()
{
bits_available_in_char = CHAR_BIT;
char_index = 0U;
bits_available = CHAR_BIT * length_chars;
char_index = 0U;
bits_available = CHAR_BIT * length_chars;
}
//***************************************************************************
/// For bool types
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_same<bool, T>::value, bool>::type
read_unchecked()
typename etl::enable_if<etl::is_same<bool, T>::value, bool>::type read_unchecked()
{
return get_bit();
}
@ -1127,8 +1124,7 @@ namespace etl
/// For bool types
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_same<bool, T>::value, etl::optional<bool> >::type
read()
typename etl::enable_if<etl::is_same<bool, T>::value, etl::optional<bool> >::type read()
{
etl::optional<bool> result;
@ -1144,12 +1140,12 @@ namespace etl
/// For integral types
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value && !etl::is_same<bool, T>::value, T>::type
read_unchecked(uint_least8_t nbits = CHAR_BIT * sizeof(T))
typename etl::enable_if< etl::is_integral<T>::value && !etl::is_same<bool, T>::value, T>::type read_unchecked(uint_least8_t nbits = CHAR_BIT
* sizeof(T))
{
typedef typename etl::unsigned_type<T>::type unsigned_t;
T value = read_value<unsigned_t>(nbits, etl::is_signed<T>::value);
T value = static_cast<T>(read_value<unsigned_t>(nbits, etl::is_signed<T>::value));
return static_cast<T>(value);
}
@ -1166,7 +1162,7 @@ namespace etl
// Do we have enough bits?
if (bits_available >= nbits)
{
result = read_unchecked<T>(nbits);
result = read_unchecked<T>(nbits);
}
return result;
@ -1266,8 +1262,8 @@ namespace etl
// Make sure that we are not reading more bits than should be available.
nbits = (nbits > (CHAR_BIT * sizeof(T))) ? (CHAR_BIT * sizeof(T)) : nbits;
T value = 0;
uint_least8_t bits = nbits;
T value = 0;
uint_least8_t bits = nbits;
// Get the bits from the stream.
while (nbits != 0)
@ -1299,7 +1295,7 @@ namespace etl
//***************************************************************************
unsigned char get_chunk(unsigned char nbits)
{
unsigned char value = pdata[char_index];
unsigned char value = static_cast<unsigned char>(pdata[char_index]);
value >>= (bits_available_in_char - nbits);
unsigned char mask;
@ -1310,7 +1306,7 @@ namespace etl
}
else
{
mask = (1U << nbits) - 1;
mask = static_cast<unsigned char>((1U << nbits) - 1);
}
value &= mask;
@ -1325,7 +1321,7 @@ namespace etl
//***************************************************************************
bool get_bit()
{
bool result = (pdata[char_index] & (1U << (bits_available_in_char - 1U))) != 0U;
bool result = (static_cast<unsigned char>(pdata[char_index]) & (1U << (bits_available_in_char - 1U))) != 0U;
step(1U);
@ -1352,9 +1348,11 @@ namespace etl
const char* pdata; ///< The start of the bitstream buffer.
size_t length_chars; ///< The length, in char, of the bitstream buffer.
const etl::endian stream_endianness; ///< The endianness of the stream data.
unsigned char bits_available_in_char; ///< The number of available bits in the current char.
size_t char_index; ///< The index of the char in the bitstream buffer.
size_t bits_available; ///< The number of bits still available in the bitstream buffer.
unsigned char bits_available_in_char; ///< The number of available bits in
///< the current char.
size_t char_index; ///< The index of the char in the bitstream buffer.
size_t bits_available; ///< The number of bits still available in the
///< bitstream buffer.
};
//***************************************************************************
@ -1404,7 +1402,7 @@ namespace etl
{
return stream.read<bool>();
}
}
} // namespace etl
#include "private/minmax_pop.h"

40
include/etl/bloom_filter.h
View File

@ -32,12 +32,12 @@ SOFTWARE.
#define ETL_BLOOM_FILTER_INCLUDED
#include "platform.h"
#include "parameter_type.h"
#include "bitset.h"
#include "type_traits.h"
#include "binary.h"
#include "bitset.h"
#include "log.h"
#include "parameter_type.h"
#include "power.h"
#include "type_traits.h"
///\defgroup bloom_filter bloom_filter
/// A Bloom filter
@ -51,34 +51,33 @@ namespace etl
struct null_hash
{
template <typename T>
size_t operator ()(T)
size_t operator()(T)
{
return 0;
}
};
}
} // namespace private_bloom_filter
//***************************************************************************
/// An implementation of a bloom filter.
/// Allows up to three hashes to be defined.
/// Hashes must support the () operator and define 'argument_type'.
///\tparam Desired_Width The desired number of hash results that can be stored. Rounded up to best fit the underlying bitset.
///\tparam THash1 The first hash generator class.
///\tparam THash2 The second hash generator class. If omitted, uses the null hash.
///\tparam THash3 The third hash generator class. If omitted, uses the null hash.
/// The hash classes must define <b>argument_type</b>.
///\tparam Desired_Width The desired number of hash results that can be
/// stored. Rounded up to best fit the underlying
/// bitset. \tparam THash1 The first hash generator class. \tparam
/// THash2 The second hash generator class. If omitted, uses the null
/// hash. \tparam THash3 The third hash generator class. If omitted,
/// uses the null hash. The hash classes must define <b>argument_type</b>.
///\ingroup bloom_filter
//***************************************************************************
template <size_t Desired_Width,
typename THash1,
typename THash2 = private_bloom_filter::null_hash,
template <size_t Desired_Width, typename THash1, typename THash2 = private_bloom_filter::null_hash,
typename THash3 = private_bloom_filter::null_hash>
class bloom_filter
{
private:
typedef typename etl::parameter_type<typename THash1::argument_type>::type parameter_t;
typedef private_bloom_filter::null_hash null_hash;
typedef private_bloom_filter::null_hash null_hash;
public:
@ -90,11 +89,11 @@ namespace etl
//***************************************************************************
/// Clears the bloom filter of all entries.
//***************************************************************************
void clear()
{
flags.reset();
}
//***************************************************************************
void clear()
{
flags.reset();
}
//***************************************************************************
/// Adds a key to the filter.
@ -184,7 +183,6 @@ namespace etl
/// The Bloom filter flags.
etl::bitset<WIDTH> flags;
};
}
} // namespace etl
#endif

23
include/etl/bresenham_line.h
View File

@ -91,7 +91,7 @@ namespace etl
//***************************************************
/// Assignment operator
//***************************************************
const_iterator& operator =(const const_iterator& rhs)
const_iterator& operator=(const const_iterator& rhs)
{
p_bresenham_line = rhs.p_bresenham_line;
@ -101,7 +101,7 @@ namespace etl
//***************************************************
/// Pre-increment operator
//***************************************************
const_iterator& operator ++()
const_iterator& operator++()
{
// Has the end of the series has been reached?
if (p_bresenham_line->get_coordinate() == p_bresenham_line->back())
@ -120,7 +120,7 @@ namespace etl
//***************************************************
/// De-reference operator
//***************************************************
value_type operator *() const
value_type operator*() const
{
return p_bresenham_line->get_coordinate();
}
@ -128,7 +128,7 @@ namespace etl
//***************************************************
/// Equality operator
//***************************************************
friend bool operator ==(const const_iterator& lhs, const const_iterator& rhs)
friend bool operator==(const const_iterator& lhs, const const_iterator& rhs)
{
return lhs.p_bresenham_line == rhs.p_bresenham_line;
}
@ -136,7 +136,7 @@ namespace etl
//***************************************************
/// Inequality operator
//***************************************************
friend bool operator !=(const const_iterator& lhs, const const_iterator& rhs)
friend bool operator!=(const const_iterator& lhs, const const_iterator& rhs)
{
return !(lhs == rhs);
}
@ -240,18 +240,18 @@ namespace etl
{
if (y_is_major_axis())
{
return (dy / 2) + 1;
return static_cast<size_t>((dy / 2) + 1);
}
else
{
return (dx / 2) + 1;
return static_cast<size_t>((dx / 2) + 1);
}
}
//***************************************************
/// Equality operator
//***************************************************
friend bool operator ==(const bresenham_line& lhs, const bresenham_line& rhs)
friend bool operator==(const bresenham_line& lhs, const bresenham_line& rhs)
{
return (lhs.front() == rhs.front()) && (lhs.back() == rhs.back());
}
@ -259,7 +259,7 @@ namespace etl
//***************************************************
/// Inequality operator
//***************************************************
friend bool operator !=(const bresenham_line& lhs, const bresenham_line& rhs)
friend bool operator!=(const bresenham_line& lhs, const bresenham_line& rhs)
{
return !(lhs == rhs);
}
@ -272,7 +272,7 @@ namespace etl
void initialise(T first_x, T first_y, T last_x, T last_y)
{
first = value_type(first_x, first_y);
last = value_type(last_x, last_y);
last = value_type(last_x, last_y);
coordinate = first;
x_increment = (last_x < first_x) ? -1 : 1;
y_increment = (last_y < first_y) ? -1 : 1;
@ -355,7 +355,6 @@ namespace etl
work_t balance;
bool do_minor_increment;
};
}
} // namespace etl
#endif

38
include/etl/buffer_descriptors.h
View File

@ -32,12 +32,12 @@ SOFTWARE.
#define ETL_BUFFER_DESCRIPTORS_INCLUDED
#include "platform.h"
#include "array.h"
#include "delegate.h"
#include "type_traits.h"
#include "static_assert.h"
#include "cyclic_value.h"
#include "algorithm.h"
#include "array.h"
#include "cyclic_value.h"
#include "delegate.h"
#include "static_assert.h"
#include "type_traits.h"
#include <cstring>
@ -89,7 +89,7 @@ namespace etl
}
//*********************************
descriptor& operator =(const descriptor& other)
descriptor& operator=(const descriptor& other)
{
pdesc_item = other.pdesc_item;
return *this;
@ -99,14 +99,13 @@ namespace etl
pointer data() const
{
assert(pdesc_item != ETL_NULLPTR);
#include "private/diagnostic_null_dereference_push.h"
#include "private/diagnostic_null_dereference_push.h"
return pdesc_item->pbuffer;
#include "private/diagnostic_pop.h"
#include "private/diagnostic_pop.h"
}
//*********************************
ETL_NODISCARD
ETL_CONSTEXPR size_type max_size() const
ETL_NODISCARD ETL_CONSTEXPR size_type max_size() const
{
return BUFFER_SIZE;
}
@ -284,23 +283,26 @@ namespace etl
//*********************************
struct descriptor_item
{
pointer pbuffer;
pointer pbuffer;
volatile flag_type in_use;
};
callback_type callback;
etl::array<descriptor_item, N_BUFFERS> descriptor_items;
callback_type callback;
etl::array<descriptor_item, N_BUFFERS> descriptor_items;
etl::cyclic_value<uint_least8_t, 0U, N_BUFFERS - 1> next;
};
template <typename TBuffer, size_t BUFFER_SIZE_, size_t N_BUFFERS_, typename TFlag>
ETL_CONSTANT typename buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::size_type buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::N_BUFFERS;
ETL_CONSTANT typename buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::size_type
buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::N_BUFFERS;
template <typename TBuffer, size_t BUFFER_SIZE_, size_t N_BUFFERS_, typename TFlag>
ETL_CONSTANT typename buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::size_type buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::BUFFER_SIZE;
ETL_CONSTANT typename buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::size_type
buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::BUFFER_SIZE;
template <typename TBuffer, size_t BUFFER_SIZE_, size_t N_BUFFERS_, typename TFlag>
ETL_CONSTANT typename buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::size_type buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::descriptor::MAX_SIZE;
}
ETL_CONSTANT typename buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::size_type
buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::descriptor::MAX_SIZE;
} // namespace etl
#endif
#endif

94
include/etl/byte.h
View File

@ -33,15 +33,15 @@ namespace etl
{
#if ETL_USING_CPP11 && !defined(ETL_BYTE_FORCE_CPP03_IMPLEMENTATION)
enum class byte : unsigned char {};
enum class byte : unsigned char
{
};
//*************************************************************************
/// To integer.
//*************************************************************************
template <typename TInteger>
constexpr
typename etl::enable_if<etl::is_integral<TInteger>::value, TInteger>::type
to_integer(etl::byte b) ETL_NOEXCEPT
constexpr typename etl::enable_if<etl::is_integral<TInteger>::value, TInteger>::type to_integer(etl::byte b) ETL_NOEXCEPT
{
return TInteger(b);
}
@ -50,31 +50,25 @@ namespace etl
/// Shift left.
//*************************************************************************
template <typename TInteger>
constexpr
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte>::type
operator <<(etl::byte b, TInteger shift) ETL_NOEXCEPT
constexpr typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte>::type operator<<(etl::byte b, TInteger shift) ETL_NOEXCEPT
{
return etl::byte(static_cast<unsigned int>(b) << shift);
return etl::byte(static_cast<unsigned int>(b) << shift);
}
//*************************************************************************
/// Shift right
//*************************************************************************
template <typename TInteger>
constexpr
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte>::type
operator >>(etl::byte b, TInteger shift) ETL_NOEXCEPT
constexpr typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte>::type operator>>(etl::byte b, TInteger shift) ETL_NOEXCEPT
{
return etl::byte(static_cast<unsigned int>(b) >> shift);
return etl::byte(static_cast<unsigned int>(b) >> shift);
}
//*************************************************************************
/// Shift left equals.
//*************************************************************************
template <typename TInteger>
constexpr
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte&>::type
operator <<=(etl::byte& b, TInteger shift) ETL_NOEXCEPT
constexpr typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte&>::type operator<<=(etl::byte& b, TInteger shift) ETL_NOEXCEPT
{
return b = b << shift;
}
@ -83,9 +77,7 @@ namespace etl
/// Shift right equals.
//*************************************************************************
template <typename TInteger>
constexpr
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte&>::type
operator >>=(etl::byte& b, TInteger shift) ETL_NOEXCEPT
constexpr typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte&>::type operator>>=(etl::byte& b, TInteger shift) ETL_NOEXCEPT
{
return b = b >> shift;
}
@ -93,7 +85,7 @@ namespace etl
//*************************************************************************
/// Or.
//*************************************************************************
inline constexpr etl::byte operator |(etl::byte lhs, etl::byte rhs) ETL_NOEXCEPT
inline constexpr etl::byte operator|(etl::byte lhs, etl::byte rhs) ETL_NOEXCEPT
{
return etl::byte(static_cast<unsigned int>(lhs) | static_cast<unsigned int>(rhs));
}
@ -101,7 +93,7 @@ namespace etl
//*************************************************************************
/// And.
//*************************************************************************
inline constexpr etl::byte operator &(etl::byte lhs, etl::byte rhs) ETL_NOEXCEPT
inline constexpr etl::byte operator&(etl::byte lhs, etl::byte rhs) ETL_NOEXCEPT
{
return etl::byte(static_cast<unsigned int>(lhs) & static_cast<unsigned int>(rhs));
}
@ -109,7 +101,7 @@ namespace etl
//*************************************************************************
/// Exclusive Or.
//*************************************************************************
inline constexpr etl::byte operator ^(etl::byte lhs, etl::byte rhs) ETL_NOEXCEPT
inline constexpr etl::byte operator^(etl::byte lhs, etl::byte rhs) ETL_NOEXCEPT
{
return etl::byte(static_cast<unsigned int>(lhs) ^ static_cast<unsigned int>(rhs));
}
@ -117,7 +109,7 @@ namespace etl
//*************************************************************************
/// Or equals.
//*************************************************************************
inline ETL_CONSTEXPR14 etl::byte& operator |=(etl::byte& lhs, etl::byte rhs) ETL_NOEXCEPT
inline ETL_CONSTEXPR14 etl::byte& operator|=(etl::byte& lhs, etl::byte rhs) ETL_NOEXCEPT
{
return lhs = lhs | rhs;
}
@ -125,7 +117,7 @@ namespace etl
//*************************************************************************
/// And equals
//*************************************************************************
inline ETL_CONSTEXPR14 etl::byte& operator &=(etl::byte& lhs, etl::byte rhs) ETL_NOEXCEPT
inline ETL_CONSTEXPR14 etl::byte& operator&=(etl::byte& lhs, etl::byte rhs) ETL_NOEXCEPT
{
return lhs = lhs & rhs;
}
@ -133,7 +125,7 @@ namespace etl
//*************************************************************************
/// Exclusive or equals.
//*************************************************************************
inline ETL_CONSTEXPR14 etl::byte& operator ^=(etl::byte& lhs, etl::byte rhs) ETL_NOEXCEPT
inline ETL_CONSTEXPR14 etl::byte& operator^=(etl::byte& lhs, etl::byte rhs) ETL_NOEXCEPT
{
return lhs = lhs ^ rhs;
}
@ -141,7 +133,7 @@ namespace etl
//*************************************************************************
/// Not.
//*************************************************************************
inline constexpr etl::byte operator ~(etl::byte b) ETL_NOEXCEPT
inline constexpr etl::byte operator~(etl::byte b) ETL_NOEXCEPT
{
return etl::byte(~static_cast<unsigned int>(b));
}
@ -157,11 +149,9 @@ namespace etl
// Friend functions
template <typename TInteger>
friend
typename etl::enable_if<etl::is_integral<TInteger>::value, TInteger>::type
to_integer(etl::byte b);
friend typename etl::enable_if<etl::is_integral<TInteger>::value, TInteger>::type to_integer(etl::byte b);
friend bool operator ==(etl::byte lhs, etl::byte rhs);
friend bool operator==(etl::byte lhs, etl::byte rhs);
// Default constructor
byte()
@ -192,7 +182,7 @@ namespace etl
//*************************************************************************
/// Equality test
//*************************************************************************
inline bool operator ==(etl::byte lhs, etl::byte rhs)
inline bool operator==(etl::byte lhs, etl::byte rhs)
{
return (lhs.value == rhs.value);
}
@ -200,7 +190,7 @@ namespace etl
//*************************************************************************
/// Inequality test
//*************************************************************************
inline bool operator !=(etl::byte lhs, etl::byte rhs)
inline bool operator!=(etl::byte lhs, etl::byte rhs)
{
return !(lhs == rhs);
}
@ -208,9 +198,8 @@ namespace etl
//*************************************************************************
/// To integer.
//*************************************************************************
template <typename TInteger>
typename etl::enable_if<etl::is_integral<TInteger>::value, TInteger>::type
to_integer(etl::byte b)
template <typename TInteger>
typename etl::enable_if<etl::is_integral<TInteger>::value, TInteger>::type to_integer(etl::byte b)
{
return TInteger(b);
}
@ -219,28 +208,25 @@ namespace etl
/// Shift left.
//*************************************************************************
template <typename TInteger>
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte>::type
operator <<(etl::byte b, TInteger shift)
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte>::type operator<<(etl::byte b, TInteger shift)
{
return etl::byte(to_integer<unsigned int>(b) << shift);
return etl::byte(to_integer<unsigned int>(b) << shift);
}
//*************************************************************************
/// Shift right
//*************************************************************************
template <typename TInteger>
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte>::type
operator >>(etl::byte b, TInteger shift)
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte>::type operator>>(etl::byte b, TInteger shift)
{
return etl::byte(to_integer<unsigned int>(b) >> shift);
return etl::byte(to_integer<unsigned int>(b) >> shift);
}
//*************************************************************************
/// Shift left equals.
//*************************************************************************
template <typename TInteger>
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte&>::type
operator <<=(etl::byte& b, TInteger shift)
template <typename TInteger>
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte&>::type operator<<=(etl::byte& b, TInteger shift)
{
b = b << shift;
@ -251,8 +237,7 @@ namespace etl
/// Shift right equals.
//*************************************************************************
template <typename TInteger>
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte&>::type
operator >>=(etl::byte& b, TInteger shift)
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte&>::type operator>>=(etl::byte& b, TInteger shift)
{
b = b >> shift;
@ -262,7 +247,7 @@ namespace etl
//*************************************************************************
/// Or.
//*************************************************************************
inline etl::byte operator |(etl::byte lhs, etl::byte rhs)
inline etl::byte operator|(etl::byte lhs, etl::byte rhs)
{
return etl::byte(to_integer<unsigned int>(lhs) | to_integer<unsigned int>(rhs));
}
@ -270,7 +255,7 @@ namespace etl
//*************************************************************************
/// And.
//*************************************************************************
inline etl::byte operator &(etl::byte lhs, etl::byte rhs)
inline etl::byte operator&(etl::byte lhs, etl::byte rhs)
{
return etl::byte(to_integer<unsigned int>(lhs) & to_integer<unsigned int>(rhs));
}
@ -278,15 +263,15 @@ namespace etl
//*************************************************************************
/// Exclusive Or.
//*************************************************************************
inline etl::byte operator ^(etl::byte lhs, etl::byte rhs)
inline etl::byte operator^(etl::byte lhs, etl::byte rhs)
{
return etl::byte(to_integer<unsigned int>(lhs) ^ to_integer<unsigned int>(rhs));
return etl::byte(to_integer<unsigned int>(lhs) ^ to_integer<unsigned int>(rhs));
}
//*************************************************************************
/// Or equals.
//*************************************************************************
inline etl::byte& operator |=(etl::byte& lhs, etl::byte rhs)
inline etl::byte& operator|=(etl::byte& lhs, etl::byte rhs)
{
return lhs = lhs | rhs;
}
@ -294,7 +279,7 @@ namespace etl
//*************************************************************************
/// And equals
//*************************************************************************
inline etl::byte& operator &=(etl::byte& lhs, etl::byte rhs)
inline etl::byte& operator&=(etl::byte& lhs, etl::byte rhs)
{
return lhs = lhs & rhs;
}
@ -302,7 +287,7 @@ namespace etl
//*************************************************************************
/// Exclusive or equals.
//*************************************************************************
inline etl::byte& operator ^=(etl::byte& lhs, etl::byte rhs)
inline etl::byte& operator^=(etl::byte& lhs, etl::byte rhs)
{
return lhs = lhs ^ rhs;
}
@ -310,14 +295,13 @@ namespace etl
//*************************************************************************
/// Not.
//*************************************************************************
inline etl::byte operator ~(etl::byte b)
inline etl::byte operator~(etl::byte b)
{
return etl::byte(~to_integer<unsigned char>(b));
}
#endif
}
} // namespace etl
#endif

93
include/etl/byte_stream.h
View File

@ -32,22 +32,21 @@ SOFTWARE.
#define ETL_BYTE_STREAM_INCLUDED
#include "platform.h"
#include "type_traits.h"
#include "nullptr.h"
#include "endianness.h"
#include "integral_limits.h"
#include "algorithm.h"
#include "delegate.h"
#include "endianness.h"
#include "error_handler.h"
#include "exception.h"
#include "integral_limits.h"
#include "iterator.h"
#include "memory.h"
#include "span.h"
#include "iterator.h"
#include "nullptr.h"
#include "optional.h"
#include "delegate.h"
#include "exception.h"
#include "error_handler.h"
#include "span.h"
#include "type_traits.h"
#include <stdint.h>
#include <limits.h>
#include <stdint.h>
namespace etl
{
@ -58,9 +57,9 @@ namespace etl
{
public:
typedef char* iterator;
typedef const char* const_iterator;
typedef etl::span<char> callback_parameter_type;
typedef char* iterator;
typedef const char* const_iterator;
typedef etl::span<char> callback_parameter_type;
typedef etl::delegate<void(callback_parameter_type)> callback_type;
//***************************************************************************
@ -93,7 +92,7 @@ namespace etl
byte_stream_writer(void* begin_, void* end_, etl::endian stream_endianness_, callback_type callback_ = callback_type())
: pdata(reinterpret_cast<char*>(begin_))
, pcurrent(reinterpret_cast<char*>(begin_))
, stream_length(etl::distance(reinterpret_cast<char*>(begin_), reinterpret_cast<char*>(end_)))
, stream_length(static_cast<size_t>(etl::distance(reinterpret_cast<char*>(begin_), reinterpret_cast<char*>(end_))))
, stream_endianness(stream_endianness_)
, callback(callback_)
{
@ -115,7 +114,7 @@ namespace etl
/// Construct from array.
//***************************************************************************
template <typename T, size_t Size>
byte_stream_writer(T(&begin_)[Size], etl::endian stream_endianness_, callback_type callback_ = callback_type())
byte_stream_writer(T (&begin_)[Size], etl::endian stream_endianness_, callback_type callback_ = callback_type())
: pdata(begin_)
, pcurrent(begin_)
, stream_length(begin_ + (Size * sizeof(T)))
@ -151,8 +150,7 @@ namespace etl
/// Write a value to the stream.
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value || etl::is_floating_point<T>::value, void>::type
write_unchecked(T value)
typename etl::enable_if<etl::is_integral<T>::value || etl::is_floating_point<T>::value, void>::type write_unchecked(T value)
{
to_bytes<T>(value);
}
@ -161,8 +159,7 @@ namespace etl
/// Write a value to the stream.
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value || etl::is_floating_point<T>::value, bool>::type
write(T value)
typename etl::enable_if<etl::is_integral<T>::value || etl::is_floating_point<T>::value, bool>::type write(T value)
{
bool success = (available<T>() > 0U);
@ -178,8 +175,7 @@ namespace etl
/// Write a range of T to the stream.
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value || etl::is_floating_point<T>::value, void>::type
write_unchecked(const etl::span<T>& range)
typename etl::enable_if<etl::is_integral<T>::value || etl::is_floating_point<T>::value, void>::type write_unchecked(const etl::span<T>& range)
{
typename etl::span<T>::iterator itr = range.begin();
@ -194,8 +190,7 @@ namespace etl
/// Write a range of T to the stream.
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value || etl::is_floating_point<T>::value, bool>::type
write(const etl::span<T>& range)
typename etl::enable_if<etl::is_integral<T>::value || etl::is_floating_point<T>::value, bool>::type write(const etl::span<T>& range)
{
bool success = (available<T>() >= range.size());
@ -211,8 +206,7 @@ namespace etl
/// Write a range of T to the stream.
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value || etl::is_floating_point<T>::value, void>::type
write_unchecked(const T* start, size_t length)
typename etl::enable_if<etl::is_integral<T>::value || etl::is_floating_point<T>::value, void>::type write_unchecked(const T* start, size_t length)
{
while (length-- != 0U)
{
@ -225,8 +219,7 @@ namespace etl
/// Write a range of T to the stream.
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value || etl::is_floating_point<T>::value, bool>::type
write(const T* start, size_t length)
typename etl::enable_if<etl::is_integral<T>::value || etl::is_floating_point<T>::value, bool>::type write(const T* start, size_t length)
{
bool success = (available<T>() >= length);
@ -381,7 +374,7 @@ namespace etl
//***************************************************************************
size_t size_bytes() const
{
return etl::distance(pdata, pcurrent);
return static_cast<size_t>(etl::distance(pdata, pcurrent));
}
//***************************************************************************
@ -439,8 +432,7 @@ namespace etl
/// to_bytes
//***************************************************************************
template <typename T>
typename etl::enable_if<sizeof(T) == 1U, void>::type
to_bytes(const T value)
typename etl::enable_if<sizeof(T) == 1U, void>::type to_bytes(const T value)
{
*pcurrent = static_cast<char>(value);
step(1U);
@ -448,8 +440,7 @@ namespace etl
//*********************************
template <typename T>
typename etl::enable_if<sizeof(T) != 1U, void>::type
to_bytes(const T value)
typename etl::enable_if<sizeof(T) != 1U, void>::type to_bytes(const T value)
{
const char* pv = reinterpret_cast<const char*>(&value);
copy_value(pv, pcurrent, sizeof(T));
@ -494,7 +485,7 @@ namespace etl
{
public:
typedef char* iterator;
typedef char* iterator;
typedef const char* const_iterator;
//***************************************************************************
@ -525,7 +516,7 @@ namespace etl
byte_stream_reader(const void* begin_, const void* end_, etl::endian stream_endianness_)
: pdata(reinterpret_cast<const char*>(begin_))
, pcurrent(reinterpret_cast<const char*>(begin_))
, stream_length(etl::distance(reinterpret_cast<const char*>(begin_), reinterpret_cast<const char*>(end_)))
, stream_length(static_cast<size_t>(etl::distance(reinterpret_cast<const char*>(begin_), reinterpret_cast<const char*>(end_))))
, stream_endianness(stream_endianness_)
{
}
@ -545,7 +536,7 @@ namespace etl
/// Construct from array.
//***************************************************************************
template <typename T, size_t Size>
byte_stream_reader(T(&begin_)[Size], etl::endian stream_endianness_)
byte_stream_reader(T (&begin_)[Size], etl::endian stream_endianness_)
: pdata(begin_)
, pcurrent(begin_)
, stream_length(begin_ + (Size * sizeof(T)))
@ -557,7 +548,7 @@ namespace etl
/// Construct from const array.
//***************************************************************************
template <typename T, size_t Size>
byte_stream_reader(const T(&begin_)[Size], etl::endian stream_endianness_)
byte_stream_reader(const T (&begin_)[Size], etl::endian stream_endianness_)
: pdata(begin_)
, pcurrent(begin_)
, stream_length(begin_ + (Size * sizeof(T)))
@ -569,8 +560,7 @@ namespace etl
/// Read a value from the stream.
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value || etl::is_floating_point<T>::value, T>::type
read_unchecked()
typename etl::enable_if< etl::is_integral<T>::value || etl::is_floating_point<T>::value, T>::type read_unchecked()
{
return from_bytes<T>();
}
@ -579,8 +569,7 @@ namespace etl
/// Read a value from the stream.
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value || etl::is_floating_point<T>::value, etl::optional<T> >::type
read()
typename etl::enable_if<etl::is_integral<T>::value || etl::is_floating_point<T>::value, etl::optional<T> >::type read()
{
etl::optional<T> result;
@ -597,14 +586,13 @@ namespace etl
/// Read a byte range from the stream.
//***************************************************************************
template <typename T>
typename etl::enable_if<sizeof(T) == 1U, etl::span<const T> >::type
read_unchecked(size_t n)
typename etl::enable_if<sizeof(T) == 1U, etl::span<const T> >::type read_unchecked(size_t n)
{
etl::span<const T> result;
const char* pend = pcurrent + (n * sizeof(T));
result = etl::span<const T>(reinterpret_cast<const T*>(pcurrent), reinterpret_cast<const T*>(pend));
result = etl::span<const T>(reinterpret_cast<const T*>(pcurrent), reinterpret_cast<const T*>(pend));
pcurrent = pend;
return result;
@ -614,8 +602,7 @@ namespace etl
/// Read a byte range from the stream.
//***************************************************************************
template <typename T>
typename etl::enable_if<sizeof(T) == 1U, etl::optional<etl::span<const T> > >::type
read(size_t n)
typename etl::enable_if<sizeof(T) == 1U, etl::optional<etl::span<const T> > >::type read(size_t n)
{
etl::optional<etl::span<const T> > result;
@ -665,8 +652,8 @@ namespace etl
/// Read a range of T from the stream.
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value || etl::is_floating_point<T>::value, etl::span<const T> >::type
read_unchecked(T* start, size_t length)
typename etl::enable_if<etl::is_integral<T>::value || etl::is_floating_point<T>::value, etl::span<const T> >::type read_unchecked(T* start,
size_t length)
{
T* destination = start;
@ -799,7 +786,7 @@ namespace etl
template <typename T>
size_t available() const
{
size_t used = etl::distance(pdata, pcurrent);
size_t used = static_cast<size_t>(etl::distance(pdata, pcurrent));
return (stream_length - used) / sizeof(T);
}
@ -826,16 +813,14 @@ namespace etl
/// from_bytes
//***************************************************************************
template <typename T>
typename etl::enable_if<sizeof(T) == 1U, T>::type
from_bytes()
typename etl::enable_if<sizeof(T) == 1U, T>::type from_bytes()
{
return static_cast<T>(*pcurrent++);
}
//*********************************
template <typename T>
typename etl::enable_if<sizeof(T) != 1U, T>::type
from_bytes()
typename etl::enable_if<sizeof(T) != 1U, T>::type from_bytes()
{
T value;
@ -893,7 +878,7 @@ namespace etl
/// Overload this to support custom types.
//***************************************************************************
template <typename T>
T read_unchecked(etl::byte_stream_reader& stream)
T read_unchecked(etl::byte_stream_reader& stream)
{
return stream.read_unchecked<T>();
}
@ -906,6 +891,6 @@ namespace etl
{
return stream.read<T>();
}
}
} // namespace etl
#endif

25
include/etl/callback.h
View File

@ -34,9 +34,10 @@ SOFTWARE.
namespace etl
{
//***************************************************************************
/// A callback class designed to be multiply inherited by other client classes.
/// The class is parametrised with a callback parameter type and a unique id.
/// The unique id allows multiple callbacks with the same parameter type.
/// A callback class designed to be multiply inherited by other client
/// classes. The class is parametrised with a callback parameter type and a
/// unique id. The unique id allows multiple callbacks with the same parameter
/// type.
///\tparam TParameter The callback parameter type.
///\tparam ID The unique id for this callback.
//***************************************************************************
@ -49,25 +50,25 @@ namespace etl
template <typename T, const int I>
struct parameter
{
parameter(T value_)
: value(value_)
{
}
parameter(T value_)
: value(value_)
{
}
typedef T value_type;
typedef T value_type;
T value;
T value;
private:
parameter();
parameter();
};
// Specialisation for void.
template <const int I>
struct parameter<void, I>
{
typedef void value_type;
typedef void value_type;
};
public:
@ -76,6 +77,6 @@ namespace etl
virtual void etl_callback(type p = type()) = 0;
};
}
} // namespace etl
#endif

18
include/etl/callback_service.h
View File

@ -32,10 +32,10 @@ SOFTWARE.
#define ETL_CALLBACK_SERVICE_INCLUDED
#include "platform.h"
#include "array.h"
#include "function.h"
#include "nullptr.h"
#include "static_assert.h"
#include "function.h"
#include "array.h"
namespace etl
{
@ -55,8 +55,8 @@ namespace etl
/// Sets all callbacks to the internal default.
//*************************************************************************
callback_service()
: unhandled_callback(*this),
p_unhandled(ETL_NULLPTR)
: unhandled_callback(*this)
, p_unhandled(ETL_NULLPTR)
{
lookup.fill(&unhandled_callback);
}
@ -71,7 +71,7 @@ namespace etl
void register_callback(etl::ifunction<size_t>& callback)
{
ETL_STATIC_ASSERT(Id < (Offset + Range), "Callback Id out of range");
ETL_STATIC_ASSERT(Id >= Offset, "Callback Id out of range");
ETL_STATIC_ASSERT(Id >= Offset, "Callback Id out of range");
lookup[Id - Offset] = &callback;
}
@ -108,7 +108,7 @@ namespace etl
void callback()
{
ETL_STATIC_ASSERT(Id < (Offset + Range), "Callback Id out of range");
ETL_STATIC_ASSERT(Id >= Offset, "Callback Id out of range");
ETL_STATIC_ASSERT(Id >= Offset, "Callback Id out of range");
(*lookup[Id - Offset])(Id);
}
@ -144,9 +144,7 @@ namespace etl
}
/// The default callback for unhandled ids.
etl::function_mp<callback_service<Range, Offset>,
size_t,
&callback_service<Range, Offset>::unhandled> unhandled_callback;
etl::function_mp<callback_service<Range, Offset>, size_t, &callback_service<Range, Offset>::unhandled> unhandled_callback;
/// Pointer to the user defined 'unhandled' callback.
etl::ifunction<size_t>* p_unhandled;
@ -154,6 +152,6 @@ namespace etl
/// Lookup table of callbacks.
etl::array<etl::ifunction<size_t>*, Range> lookup;
};
}
} // namespace etl
#endif

188
include/etl/callback_timer.h
View File

@ -31,14 +31,14 @@ SOFTWARE.
#include "platform.h"
#include "algorithm.h"
#include "nullptr.h"
#include "atomic.h"
#include "delegate.h"
#include "error_handler.h"
#include "function.h"
#include "nullptr.h"
#include "placement_new.h"
#include "static_assert.h"
#include "timer.h"
#include "atomic.h"
#include "error_handler.h"
#include "placement_new.h"
#include "delegate.h"
#include <stdint.h>
@ -91,9 +91,7 @@ namespace etl
//*******************************************
/// Register a timer.
//*******************************************
etl::timer::id::type register_timer(void (*p_callback_)(),
uint32_t period_,
bool repeating_)
etl::timer::id::type register_timer(void (*p_callback_)(), uint32_t period_, bool repeating_)
{
etl::timer::id::type id = etl::timer::id::NO_TIMER;
@ -123,9 +121,7 @@ namespace etl
//*******************************************
/// Register a timer.
//*******************************************
etl::timer::id::type register_timer(etl::ifunction<void>& callback_,
uint32_t period_,
bool repeating_)
etl::timer::id::type register_timer(etl::ifunction<void>& callback_, uint32_t period_, bool repeating_)
{
etl::timer::id::type id = etl::timer::id::NO_TIMER;
@ -152,38 +148,36 @@ namespace etl
return id;
}
//*******************************************
/// Register a timer.
//*******************************************
//*******************************************
/// Register a timer.
//*******************************************
#if ETL_USING_CPP11
etl::timer::id::type register_timer(callback_type& callback_,
uint32_t period_,
bool repeating_)
etl::timer::id::type register_timer(callback_type& callback_, uint32_t period_, bool repeating_)
{
etl::timer::id::type id = etl::timer::id::NO_TIMER;
bool is_space = (registered_timers < MAX_TIMERS);
if (is_space)
{
etl::timer::id::type id = etl::timer::id::NO_TIMER;
// Search for the free space.
for (uint_least8_t i = 0U; i < MAX_TIMERS; ++i)
{
timer_data& timer = timer_array[i];
bool is_space = (registered_timers < MAX_TIMERS);
if (is_space)
if (timer.id == etl::timer::id::NO_TIMER)
{
// Search for the free space.
for (uint_least8_t i = 0U; i < MAX_TIMERS; ++i)
{
timer_data& timer = timer_array[i];
if (timer.id == etl::timer::id::NO_TIMER)
{
// Create in-place.
new (&timer) timer_data(i, callback_, period_, repeating_);
++registered_timers;
id = i;
break;
}
}
// Create in-place.
new (&timer) timer_data(i, callback_, period_, repeating_);
++registered_timers;
id = i;
break;
}
return id;
}
}
return id;
}
#endif
//*******************************************
@ -290,17 +284,17 @@ namespace etl
if (timer.cbk_type == timer_data::C_CALLBACK)
{
// Call the C callback.
reinterpret_cast<void(*)()>(timer.p_callback)();
reinterpret_cast<void (*)()>(timer.p_callback)();
}
else if(timer.cbk_type == timer_data::IFUNCTION)
else if (timer.cbk_type == timer_data::IFUNCTION)
{
// Call the function wrapper callback.
(*reinterpret_cast<etl::ifunction<void>*>(timer.p_callback))();
}
else if(timer.cbk_type == timer_data::DELEGATE)
else if (timer.cbk_type == timer_data::DELEGATE)
{
// Call the delegate callback.
(*reinterpret_cast<callback_type*>(timer.p_callback))();
// Call the delegate callback.
(*reinterpret_cast<callback_type*>(timer.p_callback))();
}
}
@ -427,7 +421,8 @@ namespace etl
//*******************************************
/// Get the time to the next timer event.
/// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
/// Returns etl::timer::interval::No_Active_Interval if there is no active
/// timer.
//*******************************************
uint32_t time_to_next() const
{
@ -524,10 +519,7 @@ namespace etl
//*******************************************
/// C function callback
//*******************************************
timer_data(etl::timer::id::type id_,
void (*p_callback_)(),
uint32_t period_,
bool repeating_)
timer_data(etl::timer::id::type id_, void (*p_callback_)(), uint32_t period_, bool repeating_)
: p_callback(reinterpret_cast<void*>(p_callback_))
, period(period_)
, delta(etl::timer::state::Inactive)
@ -542,10 +534,7 @@ namespace etl
//*******************************************
/// ETL function callback
//*******************************************
timer_data(etl::timer::id::type id_,
etl::ifunction<void>& callback_,
uint32_t period_,
bool repeating_)
timer_data(etl::timer::id::type id_, etl::ifunction<void>& callback_, uint32_t period_, bool repeating_)
: p_callback(reinterpret_cast<void*>(&callback_))
, period(period_)
, delta(etl::timer::state::Inactive)
@ -560,18 +549,15 @@ namespace etl
//*******************************************
/// ETL delegate callback
//*******************************************
timer_data(etl::timer::id::type id_,
callback_type& callback_,
uint32_t period_,
bool repeating_)
: p_callback(reinterpret_cast<void*>(&callback_)),
period(period_),
delta(etl::timer::state::Inactive),
id(id_),
previous(etl::timer::id::NO_TIMER),
next(etl::timer::id::NO_TIMER),
repeating(repeating_),
cbk_type(DELEGATE)
timer_data(etl::timer::id::type id_, callback_type& callback_, uint32_t period_, bool repeating_)
: p_callback(reinterpret_cast<void*>(&callback_))
, period(period_)
, delta(etl::timer::state::Inactive)
, id(id_)
, previous(etl::timer::id::NO_TIMER)
, next(etl::timer::id::NO_TIMER)
, repeating(repeating_)
, cbk_type(DELEGATE)
{
}
@ -591,34 +577,36 @@ namespace etl
delta = etl::timer::state::Inactive;
}
void* p_callback;
uint32_t period;
uint32_t delta;
etl::timer::id::type id;
uint_least8_t previous;
uint_least8_t next;
bool repeating;
callback_type_id cbk_type;
void* p_callback;
uint32_t period;
uint32_t delta;
etl::timer::id::type id;
uint_least8_t previous;
uint_least8_t next;
bool repeating;
callback_type_id cbk_type;
private:
// Disabled.
timer_data(const timer_data& other);
timer_data& operator =(const timer_data& other);
timer_data& operator=(const timer_data& other);
};
//*******************************************
/// Constructor.
//*******************************************
icallback_timer(timer_data* const timer_array_, const uint_least8_t Max_Timers_)
: timer_array(timer_array_),
active_list(timer_array_),
enabled(false),
icallback_timer(timer_data* const timer_array_, const uint_least8_t Max_Timers_)
: timer_array(timer_array_)
, active_list(timer_array_)
, enabled(false)
,
#if defined(ETL_CALLBACK_TIMER_USE_ATOMIC_LOCK)
process_semaphore(0),
process_semaphore(0)
,
#endif
registered_timers(0),
MAX_TIMERS(Max_Timers_)
registered_timers(0)
, MAX_TIMERS(Max_Timers_)
{
}
@ -662,10 +650,10 @@ namespace etl
if (head == etl::timer::id::NO_TIMER)
{
// No entries yet.
head = id_;
tail = id_;
head = id_;
tail = id_;
timer.previous = etl::timer::id::NO_TIMER;
timer.next = etl::timer::id::NO_TIMER;
timer.next = etl::timer::id::NO_TIMER;
}
else
{
@ -686,8 +674,8 @@ namespace etl
// Insert before test.
timer.previous = test.previous;
test.previous = timer.id;
timer.next = test.id;
test.previous = timer.id;
timer.next = test.id;
// Adjust the next delta to compensate.
test.delta -= timer.delta;
@ -711,9 +699,9 @@ namespace etl
{
// Tag on to the tail.
ptimers[tail].next = timer.id;
timer.previous = tail;
timer.next = etl::timer::id::NO_TIMER;
tail = timer.id;
timer.previous = tail;
timer.next = etl::timer::id::NO_TIMER;
tail = timer.id;
}
}
}
@ -751,8 +739,8 @@ namespace etl
}
timer.previous = etl::timer::id::NO_TIMER;
timer.next = etl::timer::id::NO_TIMER;
timer.delta = etl::timer::state::Inactive;
timer.next = etl::timer::id::NO_TIMER;
timer.delta = etl::timer::state::Inactive;
}
//*******************************
@ -796,12 +784,12 @@ namespace etl
while (id != etl::timer::id::NO_TIMER)
{
timer_data& timer = ptimers[id];
id = next(id);
timer.next = etl::timer::id::NO_TIMER;
id = next(id);
timer.next = etl::timer::id::NO_TIMER;
}
head = etl::timer::id::NO_TIMER;
tail = etl::timer::id::NO_TIMER;
head = etl::timer::id::NO_TIMER;
tail = etl::timer::id::NO_TIMER;
current = etl::timer::id::NO_TIMER;
}
@ -823,15 +811,15 @@ namespace etl
volatile bool enabled;
#if defined(ETL_CALLBACK_TIMER_USE_ATOMIC_LOCK)
#if defined(ETL_TIMER_SEMAPHORE_TYPE)
#if defined(ETL_TIMER_SEMAPHORE_TYPE)
typedef ETL_TIMER_SEMAPHORE_TYPE timer_semaphore_t;
#else
#if ETL_HAS_ATOMIC
typedef etl::atomic_uint16_t timer_semaphore_t;
#else
#error No atomic type available
#if ETL_HAS_ATOMIC
typedef etl::atomic_uint16_t timer_semaphore_t;
#else
#error No atomic type available
#endif
#endif
#endif
mutable etl::timer_semaphore_t process_semaphore;
#endif
@ -867,7 +855,7 @@ namespace etl
timer_data timer_array[Max_Timers_];
};
}
} // namespace etl
#undef ETL_DISABLE_TIMER_UPDATES
#undef ETL_ENABLE_TIMER_UPDATES

96
include/etl/callback_timer_atomic.h
View File

@ -31,13 +31,13 @@ SOFTWARE.
#include "platform.h"
#include "algorithm.h"
#include "nullptr.h"
#include "delegate.h"
#include "error_handler.h"
#include "function.h"
#include "nullptr.h"
#include "placement_new.h"
#include "static_assert.h"
#include "timer.h"
#include "error_handler.h"
#include "placement_new.h"
#include "delegate.h"
#include <stdint.h>
@ -58,35 +58,33 @@ namespace etl
//*******************************************
/// Register a timer.
//*******************************************
etl::timer::id::type register_timer(callback_type callback_,
uint32_t period_,
bool repeating_)
etl::timer::id::type register_timer(callback_type callback_, uint32_t period_, bool repeating_)
{
etl::timer::id::type id = etl::timer::id::NO_TIMER;
bool is_space = (number_of_registered_timers < Max_Timers);
etl::timer::id::type id = etl::timer::id::NO_TIMER;
if (is_space)
bool is_space = (number_of_registered_timers < Max_Timers);
if (is_space)
{
// Search for the free space.
for (uint_least8_t i = 0U; i < Max_Timers; ++i)
{
// Search for the free space.
for (uint_least8_t i = 0U; i < Max_Timers; ++i)
{
timer_data& timer = timer_array[i];
if (timer.id == etl::timer::id::NO_TIMER)
{
// Create in-place.
new (&timer) timer_data(i, callback_, period_, repeating_);
++number_of_registered_timers;
id = i;
break;
}
timer_data& timer = timer_array[i];
if (timer.id == etl::timer::id::NO_TIMER)
{
// Create in-place.
new (&timer) timer_data(i, callback_, period_, repeating_);
++number_of_registered_timers;
id = i;
break;
}
}
return id;
}
return id;
}
//*******************************************
/// Unregister a timer.
//*******************************************
@ -319,7 +317,8 @@ namespace etl
//*******************************************
/// Get the time to the next timer event.
/// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
/// Returns etl::timer::interval::No_Active_Interval if there is no active
/// timer.
//*******************************************
uint32_t time_to_next() const
{
@ -412,10 +411,7 @@ namespace etl
//*******************************************
/// ETL delegate callback
//*******************************************
timer_data(etl::timer::id::type id_,
callback_type callback_,
uint32_t period_,
bool repeating_)
timer_data(etl::timer::id::type id_, callback_type callback_, uint32_t period_, bool repeating_)
: callback(callback_)
, period(period_)
, delta(etl::timer::state::Inactive)
@ -454,13 +450,13 @@ namespace etl
// Disabled.
timer_data(const timer_data& other) ETL_DELETE;
timer_data& operator =(const timer_data& other) ETL_DELETE;
timer_data& operator=(const timer_data& other) ETL_DELETE;
};
//*******************************************
/// Constructor.
//*******************************************
icallback_timer_atomic(timer_data* const timer_array_, const uint_least8_t Max_Timers_)
icallback_timer_atomic(timer_data* const timer_array_, const uint_least8_t Max_Timers_)
: timer_array(timer_array_)
, active_list(timer_array_)
, enabled(false)
@ -512,10 +508,10 @@ namespace etl
if (head == etl::timer::id::NO_TIMER)
{
// No entries yet.
head = id_;
tail = id_;
head = id_;
tail = id_;
timer.previous = etl::timer::id::NO_TIMER;
timer.next = etl::timer::id::NO_TIMER;
timer.next = etl::timer::id::NO_TIMER;
}
else
{
@ -536,8 +532,8 @@ namespace etl
// Insert before test.
timer.previous = test.previous;
test.previous = timer.id;
timer.next = test.id;
test.previous = timer.id;
timer.next = test.id;
// Adjust the next delta to compensate.
test.delta -= timer.delta;
@ -561,9 +557,9 @@ namespace etl
{
// Tag on to the tail.
ptimers[tail].next = timer.id;
timer.previous = tail;
timer.next = etl::timer::id::NO_TIMER;
tail = timer.id;
timer.previous = tail;
timer.next = etl::timer::id::NO_TIMER;
tail = timer.id;
}
}
}
@ -601,8 +597,8 @@ namespace etl
}
timer.previous = etl::timer::id::NO_TIMER;
timer.next = etl::timer::id::NO_TIMER;
timer.delta = etl::timer::state::Inactive;
timer.next = etl::timer::id::NO_TIMER;
timer.delta = etl::timer::state::Inactive;
}
//*******************************
@ -646,12 +642,12 @@ namespace etl
while (id != etl::timer::id::NO_TIMER)
{
timer_data& timer = ptimers[id];
id = next(id);
timer.next = etl::timer::id::NO_TIMER;
id = next(id);
timer.next = etl::timer::id::NO_TIMER;
}
head = etl::timer::id::NO_TIMER;
tail = etl::timer::id::NO_TIMER;
head = etl::timer::id::NO_TIMER;
tail = etl::timer::id::NO_TIMER;
current = etl::timer::id::NO_TIMER;
}
@ -670,9 +666,9 @@ namespace etl
// The list of active timers.
timer_list active_list;
bool enabled;
bool enabled;
mutable TSemaphore process_semaphore;
uint_least8_t number_of_registered_timers;
uint_least8_t number_of_registered_timers;
event_callback_type insert_callback;
event_callback_type remove_callback;
@ -704,6 +700,6 @@ namespace etl
typename etl::icallback_timer_atomic<TSemaphore>::timer_data timer_array[Max_Timers_];
};
}
} // namespace etl
#endif

42
include/etl/callback_timer_deferred_locked.h
View File

@ -31,10 +31,10 @@ SOFTWARE.
#include "platform.h"
#include "callback_timer_locked.h"
#include "delegate.h"
#include "etl/nullptr.h"
#include "etl/optional.h"
#include "priority_queue.h"
#include "delegate.h"
namespace etl
{
@ -103,7 +103,7 @@ namespace etl
{
if (!handler_queue.full())
{
handler_queue.push(callback_node(timer.callback, timer_priorities[timer.id]));
handler_queue.push(callback_node(timer.callback, timer_priorities[timer.id]));
}
}
@ -143,18 +143,17 @@ namespace etl
{
callback_type work_todo_callback;
do
{
do {
lock();
if (handler_queue.empty())
{
work_todo_callback.clear();
}
else
{
callback_node &work_todo_callback_node = handler_queue.top();
work_todo_callback = work_todo_callback_node.callback;
callback_node& work_todo_callback_node = handler_queue.top();
work_todo_callback = work_todo_callback_node.callback;
handler_queue.pop();
}
@ -169,11 +168,9 @@ namespace etl
//*******************************************
/// Register a timer.
//*******************************************
etl::timer::id::type register_timer(const callback_type& callback_,
uint32_t period_,
bool repeating_)
etl::timer::id::type register_timer(const callback_type& callback_, uint32_t period_, bool repeating_)
{
return register_timer(callback_, period_, repeating_, 0);
return register_timer(callback_, period_, repeating_, 0);
}
//*******************************************
@ -182,27 +179,24 @@ namespace etl
/// Suggestion: this could be used as amonth of work to do and
/// less work will be done in first place.
//*******************************************
etl::timer::id::type register_timer(const callback_type& callback_,
uint32_t period_,
bool repeating_,
uint_least8_t priority_)
etl::timer::id::type register_timer(const callback_type& callback_, uint32_t period_, bool repeating_, uint_least8_t priority_)
{
etl::timer::id::type id = icallback_timer_locked::register_timer(callback_, period_, repeating_);
etl::timer::id::type id = icallback_timer_locked::register_timer(callback_, period_, repeating_);
if (id != etl::timer::id::NO_TIMER)
{
timer_priorities[id] = priority_;
}
if (id != etl::timer::id::NO_TIMER)
{
timer_priorities[id] = priority_;
}
return id;
return id;
}
private:
priority_queue<callback_node, Max_Handlers_> handler_queue;
uint_least8_t timer_priorities[Max_Timers_];
timer_data timer_array[Max_Timers_];
uint_least8_t timer_priorities[Max_Timers_];
timer_data timer_array[Max_Timers_];
};
}
} // namespace etl
#endif

52
include/etl/callback_timer_interrupt.h
View File

@ -1,4 +1,4 @@
/******************************************************************************
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
@ -31,12 +31,12 @@ SOFTWARE.
#include "platform.h"
#include "algorithm.h"
#include "nullptr.h"
#include "delegate.h"
#include "error_handler.h"
#include "nullptr.h"
#include "placement_new.h"
#include "static_assert.h"
#include "timer.h"
#include "error_handler.h"
#include "placement_new.h"
#include <stdint.h>
@ -57,9 +57,7 @@ namespace etl
//*******************************************
/// Register a timer.
//*******************************************
etl::timer::id::type register_timer(const callback_type& callback_,
uint32_t period_,
bool repeating_)
etl::timer::id::type register_timer(const callback_type& callback_, uint32_t period_, bool repeating_)
{
etl::timer::id::type id = etl::timer::id::NO_TIMER;
@ -168,7 +166,7 @@ namespace etl
if (enabled)
{
// We have something to do?
bool has_active = !active_list.empty();
bool has_active = !active_list.empty();
if (has_active)
{
@ -320,7 +318,8 @@ namespace etl
//*******************************************
/// Get the time to the next timer event.
/// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
/// Returns etl::timer::interval::No_Active_Interval if there is no active
/// timer.
//*******************************************
uint32_t time_to_next() const
{
@ -349,7 +348,7 @@ namespace etl
if (has_active_timer())
{
TInterruptGuard guard;
(void)guard; // Silence 'unused variable warnings.
(void)guard; // Silence 'unused variable warnings.
const timer_data& timer = timer_array[id_];
@ -413,10 +412,7 @@ namespace etl
//*******************************************
/// ETL delegate callback
//*******************************************
timer_data(etl::timer::id::type id_,
callback_type callback_,
uint32_t period_,
bool repeating_)
timer_data(etl::timer::id::type id_, callback_type callback_, uint32_t period_, bool repeating_)
: callback(callback_)
, period(period_)
, delta(etl::timer::state::Inactive)
@ -455,13 +451,13 @@ namespace etl
// Disabled.
timer_data(const timer_data& other) ETL_DELETE;
timer_data& operator =(const timer_data& other) ETL_DELETE;
timer_data& operator=(const timer_data& other) ETL_DELETE;
};
//*******************************************
/// Constructor.
//*******************************************
icallback_timer_interrupt(timer_data* const timer_array_, const uint_least8_t Max_Timers_)
icallback_timer_interrupt(timer_data* const timer_array_, const uint_least8_t Max_Timers_)
: timer_array(timer_array_)
, active_list(timer_array_)
, enabled(false)
@ -512,10 +508,10 @@ namespace etl
if (head == etl::timer::id::NO_TIMER)
{
// No entries yet.
head = id_;
tail = id_;
head = id_;
tail = id_;
timer.previous = etl::timer::id::NO_TIMER;
timer.next = etl::timer::id::NO_TIMER;
timer.next = etl::timer::id::NO_TIMER;
}
else
{
@ -536,8 +532,8 @@ namespace etl
// Insert before test.
timer.previous = test.previous;
test.previous = timer.id;
timer.next = test.id;
test.previous = timer.id;
timer.next = test.id;
// Adjust the next delta to compensate.
test.delta -= timer.delta;
@ -561,9 +557,9 @@ namespace etl
{
// Tag on to the tail.
ptimers[tail].next = timer.id;
timer.previous = tail;
timer.next = etl::timer::id::NO_TIMER;
tail = timer.id;
timer.previous = tail;
timer.next = etl::timer::id::NO_TIMER;
tail = timer.id;
}
}
}
@ -646,8 +642,8 @@ namespace etl
while (id != etl::timer::id::NO_TIMER)
{
timer_data& timer = ptimers[id];
id = next(id);
timer.next = etl::timer::id::NO_TIMER;
id = next(id);
timer.next = etl::timer::id::NO_TIMER;
}
head = etl::timer::id::NO_TIMER;
@ -670,7 +666,7 @@ namespace etl
// The list of active timers.
timer_list active_list;
bool enabled;
bool enabled;
uint_least8_t number_of_registered_timers;
event_callback_type insert_callback;
@ -705,6 +701,6 @@ namespace etl
typename icallback_timer_interrupt<TInterruptGuard>::timer_data timer_array[Max_Timers_];
};
}
} // namespace etl
#endif

75
include/etl/callback_timer_locked.h
View File

@ -31,12 +31,12 @@ SOFTWARE.
#include "platform.h"
#include "algorithm.h"
#include "nullptr.h"
#include "delegate.h"
#include "error_handler.h"
#include "nullptr.h"
#include "placement_new.h"
#include "static_assert.h"
#include "timer.h"
#include "error_handler.h"
#include "placement_new.h"
#include <stdint.h>
@ -59,9 +59,7 @@ namespace etl
//*******************************************
/// Register a timer.
//*******************************************
etl::timer::id::type register_timer(const callback_type& callback_,
uint32_t period_,
bool repeating_)
etl::timer::id::type register_timer(const callback_type& callback_, uint32_t period_, bool repeating_)
{
etl::timer::id::type id = etl::timer::id::NO_TIMER;
@ -281,7 +279,8 @@ namespace etl
//*******************************************
/// Get the time to the next timer event.
/// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
/// Returns etl::timer::interval::No_Active_Interval if there is no active
/// timer.
//*******************************************
uint32_t time_to_next() const
{
@ -355,17 +354,20 @@ namespace etl
protected:
class callback_node
class callback_node
{
public:
callback_node(callback_type &callback_,uint_least8_t priority_) : callback(callback_), priority(priority_)
callback_node(callback_type& callback_, uint_least8_t priority_)
: callback(callback_)
, priority(priority_)
{
}
bool operator < (const callback_node& p) const
bool operator<(const callback_node& p) const
{
return this->priority > p.priority; // comparison was inverted here to easy the code design
return this->priority > p.priority; // comparison was inverted here to
// easy the code design
}
callback_type callback;
@ -391,10 +393,7 @@ namespace etl
//*******************************************
/// ETL delegate callback
//*******************************************
timer_data(etl::timer::id::type id_,
callback_type callback_,
uint32_t period_,
bool repeating_)
timer_data(etl::timer::id::type id_, callback_type callback_, uint32_t period_, bool repeating_)
: callback(callback_)
, period(period_)
, delta(etl::timer::state::Inactive)
@ -433,18 +432,18 @@ namespace etl
// Disabled.
timer_data(const timer_data& other) ETL_DELETE;
timer_data& operator =(const timer_data& other) ETL_DELETE;
timer_data& operator=(const timer_data& other) ETL_DELETE;
};
//*******************************************
/// Constructor.
//*******************************************
icallback_timer_locked(timer_data* const timer_array_, const uint_least8_t Max_Timers_)
: timer_array(timer_array_),
active_list(timer_array_),
enabled(false),
number_of_registered_timers(0U),
Max_Timers(Max_Timers_)
icallback_timer_locked(timer_data* const timer_array_, const uint_least8_t Max_Timers_)
: timer_array(timer_array_)
, active_list(timer_array_)
, enabled(false)
, number_of_registered_timers(0U)
, Max_Timers(Max_Timers_)
{
}
@ -482,10 +481,10 @@ namespace etl
if (head == etl::timer::id::NO_TIMER)
{
// No entries yet.
head = id_;
tail = id_;
head = id_;
tail = id_;
timer.previous = etl::timer::id::NO_TIMER;
timer.next = etl::timer::id::NO_TIMER;
timer.next = etl::timer::id::NO_TIMER;
}
else
{
@ -506,8 +505,8 @@ namespace etl
// Insert before test.
timer.previous = test.previous;
test.previous = timer.id;
timer.next = test.id;
test.previous = timer.id;
timer.next = test.id;
// Adjust the next delta to compensate.
test.delta -= timer.delta;
@ -531,9 +530,9 @@ namespace etl
{
// Tag on to the tail.
ptimers[tail].next = timer.id;
timer.previous = tail;
timer.next = etl::timer::id::NO_TIMER;
tail = timer.id;
timer.previous = tail;
timer.next = etl::timer::id::NO_TIMER;
tail = timer.id;
}
}
}
@ -571,8 +570,8 @@ namespace etl
}
timer.previous = etl::timer::id::NO_TIMER;
timer.next = etl::timer::id::NO_TIMER;
timer.delta = etl::timer::state::Inactive;
timer.next = etl::timer::id::NO_TIMER;
timer.delta = etl::timer::state::Inactive;
}
//*******************************
@ -616,12 +615,12 @@ namespace etl
while (id != etl::timer::id::NO_TIMER)
{
timer_data& timer = ptimers[id];
id = next(id);
timer.next = etl::timer::id::NO_TIMER;
id = next(id);
timer.next = etl::timer::id::NO_TIMER;
}
head = etl::timer::id::NO_TIMER;
tail = etl::timer::id::NO_TIMER;
head = etl::timer::id::NO_TIMER;
tail = etl::timer::id::NO_TIMER;
current = etl::timer::id::NO_TIMER;
}
@ -648,7 +647,7 @@ namespace etl
// The list of active timers.
timer_list active_list;
bool enabled;
bool enabled;
uint_least8_t number_of_registered_timers;
try_lock_type try_lock; ///< The callback that tries to lock.
@ -766,6 +765,6 @@ namespace etl
timer_data timer_array[Max_Timers_];
};
}
} // namespace etl
#endif

48
include/etl/char_traits.h
View File

@ -45,9 +45,11 @@ SOFTWARE.
namespace etl
{
template<typename T> struct char_traits_types;
template <typename T>
struct char_traits_types;
template<> struct char_traits_types<char>
template <>
struct char_traits_types<char>
{
typedef char char_type;
typedef int int_type;
@ -56,7 +58,8 @@ namespace etl
typedef char state_type;
};
template<> struct char_traits_types<signed char>
template <>
struct char_traits_types<signed char>
{
typedef signed char char_type;
typedef int int_type;
@ -65,7 +68,8 @@ namespace etl
typedef signed char state_type;
};
template<> struct char_traits_types<unsigned char>
template <>
struct char_traits_types<unsigned char>
{
typedef unsigned char char_type;
typedef int int_type;
@ -74,7 +78,8 @@ namespace etl
typedef unsigned char state_type;
};
template<> struct char_traits_types<wchar_t>
template <>
struct char_traits_types<wchar_t>
{
typedef wchar_t char_type;
typedef uint_least16_t int_type;
@ -84,17 +89,19 @@ namespace etl
};
#if ETL_USING_CPP20
template<> struct char_traits_types<char8_t>
template <>
struct char_traits_types<char8_t>
{
typedef char8_t char_type;
typedef unsigned int int_type;
typedef long long off_type;
typedef size_t pos_type;
typedef char state_type;
typedef char8_t char_type;
typedef unsigned int int_type;
typedef long long off_type;
typedef size_t pos_type;
typedef char state_type;
};
#endif
template<> struct char_traits_types<char16_t>
template <>
struct char_traits_types<char16_t>
{
typedef char16_t char_type;
typedef uint_least16_t int_type;
@ -103,7 +110,8 @@ namespace etl
typedef char state_type;
};
template<> struct char_traits_types<char32_t>
template <>
struct char_traits_types<char32_t>
{
typedef char32_t char_type;
typedef uint_least32_t int_type;
@ -115,7 +123,7 @@ namespace etl
//***************************************************************************
/// Character traits for any character type.
//***************************************************************************
template<typename T>
template <typename T>
struct char_traits : public char_traits_types<T>
{
typedef typename char_traits_types<T>::char_type char_type;
@ -196,9 +204,7 @@ namespace etl
}
else
{
etl::copy_n(ETL_OR_STD::reverse_iterator<const char_type*>(src + count),
count,
ETL_OR_STD::reverse_iterator<char_type*>(dst + count));
etl::copy_n(ETL_OR_STD::reverse_iterator<const char_type*>(src + count), count, ETL_OR_STD::reverse_iterator<char_type*>(dst + count));
}
return dst;
@ -270,7 +276,7 @@ namespace etl
//*************************************************************************
static ETL_CONSTEXPR int_type eof() ETL_NOEXCEPT
{
return -1;
return static_cast<int_type>(-1);
}
//*************************************************************************
@ -310,7 +316,7 @@ namespace etl
{
return 1;
}
if (*t1 < *t2)
{
return -1;
@ -343,7 +349,7 @@ namespace etl
++t1;
++t2;
--n;
}
}
return 0;
}
@ -384,6 +390,6 @@ namespace etl
return result;
}
}
} // namespace etl
#endif

12
include/etl/checksum.h
View File

@ -179,7 +179,7 @@ namespace etl
/// \param begin Start of the range.
/// \param end End of the range.
//*************************************************************************
template<typename TIterator>
template <typename TIterator>
checksum(TIterator begin, const TIterator end)
{
this->reset();
@ -208,7 +208,7 @@ namespace etl
/// \param begin Start of the range.
/// \param end End of the range.
//*************************************************************************
template<typename TIterator>
template <typename TIterator>
bsd_checksum(TIterator begin, const TIterator end)
{
this->reset();
@ -237,7 +237,7 @@ namespace etl
/// \param begin Start of the range.
/// \param end End of the range.
//*************************************************************************
template<typename TIterator>
template <typename TIterator>
xor_checksum(TIterator begin, const TIterator end)
{
this->reset();
@ -266,7 +266,7 @@ namespace etl
/// \param begin Start of the range.
/// \param end End of the range.
//*************************************************************************
template<typename TIterator>
template <typename TIterator>
xor_rotate_checksum(TIterator begin, const TIterator end)
{
this->reset();
@ -295,13 +295,13 @@ namespace etl
/// \param begin Start of the range.
/// \param end End of the range.
//*************************************************************************
template<typename TIterator>
template <typename TIterator>
parity_checksum(TIterator begin, const TIterator end)
{
this->reset();
this->add(begin, end);
}
};
}
} // namespace etl
#endif

24
include/etl/chrono.h
View File

@ -41,12 +41,12 @@ SOFTWARE.
#if ETL_USING_CPP11
#include "type_traits.h"
#include "integral_limits.h"
#include "hash.h"
#include "hash.h"
#include "integral_limits.h"
#include "type_traits.h"
#include <stdint.h>
#include <time.h>
#include <stdint.h>
#include <time.h>
namespace etl
{
@ -57,17 +57,17 @@ namespace etl
{
};
#if ETL_USING_CPP17
#if ETL_USING_CPP17
template <typename TRep>
constexpr bool treat_as_floating_point_v = treat_as_floating_point<TRep>::value;
#endif
}
#endif
} // namespace chrono
// Use the same type as defined in time.h.
using time_t = ::time_t;
}
} // namespace etl
// clang-format off
// clang-format off
// Keeping the order is important here
#include "private/chrono/last_spec.h"
#include "private/chrono/duration.h"
@ -89,11 +89,11 @@ namespace etl
namespace etl
{
namespace chrono
namespace chrono
{
using namespace literals::chrono_literals;
}
}
} // namespace etl
#endif

182
include/etl/circular_buffer.h
View File

@ -32,15 +32,15 @@ SOFTWARE.
#define ETL_CIRCULAR_BUFFER_INCLUDED
#include "platform.h"
#include "vector.h"
#include "exception.h"
#include "error_handler.h"
#include "exception.h"
#include "initializer_list.h"
#include "iterator.h"
#include "memory.h"
#include "memory_model.h"
#include "type_traits.h"
#include "iterator.h"
#include "static_assert.h"
#include "initializer_list.h"
#include "type_traits.h"
#include "vector.h"
namespace etl
{
@ -170,7 +170,7 @@ namespace etl
size_type buffer_size;
size_type in; ///< Index to the next write.
size_type out; ///< Index to the next read.
ETL_DECLARE_DEBUG_COUNT; ///< Internal debugging.
ETL_DECLARE_DEBUG_COUNT; ///< Internal debugging.
};
//***************************************************************************
@ -181,14 +181,14 @@ namespace etl
{
public:
typedef T value_type;
typedef T& reference;
typedef const T& const_reference;
typedef T value_type;
typedef T& reference;
typedef const T& const_reference;
#if ETL_USING_CPP11
typedef T&& rvalue_reference;
typedef T&& rvalue_reference;
#endif
typedef T* pointer;
typedef const T* const_pointer;
typedef T* pointer;
typedef const T* const_pointer;
typedef typename etl::iterator_traits<pointer>::difference_type difference_type;
@ -222,7 +222,7 @@ namespace etl
//*************************************************************************
/// Assignment operator.
//*************************************************************************
iterator& operator =(const iterator& other)
iterator& operator=(const iterator& other)
{
picb = other.picb;
current = other.current;
@ -233,7 +233,7 @@ namespace etl
//*************************************************************************
/// * operator
//*************************************************************************
reference operator *() const
reference operator*() const
{
return picb->pbuffer[current];
}
@ -241,7 +241,7 @@ namespace etl
//*************************************************************************
/// -> operator
//*************************************************************************
pointer operator ->() const
pointer operator->() const
{
return &picb->pbuffer[current];
}
@ -249,7 +249,7 @@ namespace etl
//*************************************************************************
/// [] operator
//*************************************************************************
reference operator [](size_t index)
reference operator[](size_t index)
{
return picb->pbuffer[(current + index) % picb->buffer_size];
}
@ -257,7 +257,7 @@ namespace etl
//*************************************************************************
/// [] operator
//*************************************************************************
const_reference operator [](size_t index) const
const_reference operator[](size_t index) const
{
return picb->pbuffer[(current + index) % picb->buffer_size];
}
@ -265,7 +265,7 @@ namespace etl
//*************************************************************************
/// Pre-increment.
//*************************************************************************
iterator& operator ++()
iterator& operator++()
{
++current;
@ -281,7 +281,7 @@ namespace etl
//*************************************************************************
/// Post increment.
//*************************************************************************
iterator operator ++(int)
iterator operator++(int)
{
iterator original(*this);
@ -293,7 +293,7 @@ namespace etl
//*************************************************************************
/// Pre-decrement.
//*************************************************************************
iterator& operator --()
iterator& operator--()
{
// Are we at the end of the buffer?
if (current == 0U)
@ -311,7 +311,7 @@ namespace etl
//*************************************************************************
/// Post increment.
//*************************************************************************
iterator operator --(int)
iterator operator--(int)
{
iterator original(*this);
@ -323,9 +323,9 @@ namespace etl
//*************************************************************************
/// Add offset.
//*************************************************************************
iterator& operator +=(int n)
iterator& operator+=(int n)
{
current += size_type(picb->buffer_size + n);
current += size_type(static_cast<int>(picb->buffer_size) + n);
current %= picb->buffer_size;
return (*this);
@ -334,7 +334,7 @@ namespace etl
//*************************************************************************
/// Subtract offset.
//*************************************************************************
iterator& operator -=(int n)
iterator& operator-=(int n)
{
return (this->operator+=(-n));
}
@ -342,7 +342,7 @@ namespace etl
//*************************************************************************
/// Add offset.
//*************************************************************************
friend iterator operator +(const iterator& lhs, int n)
friend iterator operator+(const iterator& lhs, int n)
{
iterator temp = lhs;
@ -354,7 +354,7 @@ namespace etl
//*************************************************************************
/// Add offset.
//*************************************************************************
friend iterator operator +(int n, const iterator& rhs)
friend iterator operator+(int n, const iterator& rhs)
{
iterator temp = rhs;
@ -366,7 +366,7 @@ namespace etl
//*************************************************************************
/// Subtract offset.
//*************************************************************************
friend iterator operator -(const iterator& lhs, int n)
friend iterator operator-(const iterator& lhs, int n)
{
iterator temp = lhs;
@ -378,7 +378,7 @@ namespace etl
//*************************************************************************
/// Equality operator
//*************************************************************************
friend bool operator == (const iterator& lhs, const iterator& rhs)
friend bool operator==(const iterator& lhs, const iterator& rhs)
{
return (lhs.current == rhs.current);
}
@ -386,18 +386,18 @@ namespace etl
//*************************************************************************
/// Inequality operator
//*************************************************************************
friend bool operator != (const iterator& lhs, const iterator& rhs)
friend bool operator!=(const iterator& lhs, const iterator& rhs)
{
return !(lhs == rhs);
}
//***************************************************
friend bool operator < (const iterator& lhs, const iterator& rhs)
friend bool operator<(const iterator& lhs, const iterator& rhs)
{
const difference_type lhs_index = lhs.get_index();
const difference_type rhs_index = rhs.get_index();
const difference_type lhs_index = lhs.get_index();
const difference_type rhs_index = rhs.get_index();
const difference_type reference_index = lhs.container().begin().get_index();
const size_t buffer_size = lhs.container().max_size() + 1UL;
const difference_type buffer_size = static_cast<difference_type>(lhs.container().max_size() + 1UL);
const difference_type lhs_distance = (lhs_index < reference_index) ? buffer_size + lhs_index - reference_index : lhs_index - reference_index;
const difference_type rhs_distance = (rhs_index < reference_index) ? buffer_size + rhs_index - reference_index : rhs_index - reference_index;
@ -406,19 +406,19 @@ namespace etl
}
//***************************************************
friend bool operator <= (const iterator& lhs, const iterator& rhs)
friend bool operator<=(const iterator& lhs, const iterator& rhs)
{
return !(lhs > rhs);
}
//***************************************************
friend bool operator > (const iterator& lhs, const iterator& rhs)
friend bool operator>(const iterator& lhs, const iterator& rhs)
{
return (rhs < lhs);
}
//***************************************************
friend bool operator >= (const iterator& lhs, const iterator& rhs)
friend bool operator>=(const iterator& lhs, const iterator& rhs)
{
return !(lhs < rhs);
}
@ -426,7 +426,7 @@ namespace etl
//***************************************************
difference_type get_index() const
{
return current;
return static_cast<difference_type>(current);
}
//***************************************************
@ -468,7 +468,7 @@ namespace etl
private:
const icircular_buffer<T>* picb;
size_type current;
size_type current;
};
//*************************************************************************
@ -510,7 +510,7 @@ namespace etl
//*************************************************************************
/// Assignment operator.
//*************************************************************************
const_iterator& operator =(const typename icircular_buffer::iterator& other)
const_iterator& operator=(const typename icircular_buffer::iterator& other)
{
picb = other.picb;
current = other.current;
@ -521,7 +521,7 @@ namespace etl
//*************************************************************************
/// Assignment operator.
//*************************************************************************
const_iterator& operator =(const const_iterator& other)
const_iterator& operator=(const const_iterator& other)
{
picb = other.picb;
current = other.current;
@ -532,7 +532,7 @@ namespace etl
//*************************************************************************
/// * operator
//*************************************************************************
const_reference operator *() const
const_reference operator*() const
{
return picb->pbuffer[current];
}
@ -540,7 +540,7 @@ namespace etl
//*************************************************************************
/// -> operator
//*************************************************************************
const_pointer operator ->() const
const_pointer operator->() const
{
return &(picb->pbuffer[current]);
}
@ -548,7 +548,7 @@ namespace etl
//*************************************************************************
/// [] operator
//*************************************************************************
const_reference operator [](size_t index) const
const_reference operator[](size_t index) const
{
return picb->pbuffer[(current + index) % picb->buffer_size];
}
@ -556,7 +556,7 @@ namespace etl
//*************************************************************************
/// Pre-increment.
//*************************************************************************
const_iterator& operator ++()
const_iterator& operator++()
{
++current;
@ -572,7 +572,7 @@ namespace etl
//*************************************************************************
/// Post increment.
//*************************************************************************
const_iterator operator ++(int)
const_iterator operator++(int)
{
const_iterator original(*this);
@ -584,7 +584,7 @@ namespace etl
//*************************************************************************
/// Pre-decrement.
//*************************************************************************
const_iterator& operator --()
const_iterator& operator--()
{
// Are we at the end of the buffer?
if (current == 0U)
@ -602,7 +602,7 @@ namespace etl
//*************************************************************************
/// Post increment.
//*************************************************************************
const_iterator operator --(int)
const_iterator operator--(int)
{
const_iterator original(*this);
@ -614,9 +614,9 @@ namespace etl
//*************************************************************************
/// Add offset.
//*************************************************************************
const_iterator& operator +=(int n)
const_iterator& operator+=(int n)
{
current += size_type(picb->buffer_size + n);
current += size_type(static_cast<int>(picb->buffer_size) + n);
current %= picb->buffer_size;
return (*this);
@ -625,7 +625,7 @@ namespace etl
//*************************************************************************
/// Subtract offset.
//*************************************************************************
const_iterator& operator -=(int n)
const_iterator& operator-=(int n)
{
return (this->operator+=(-n));
}
@ -633,7 +633,7 @@ namespace etl
//*************************************************************************
/// Add offset.
//*************************************************************************
friend const_iterator operator +(const const_iterator& lhs, int n)
friend const_iterator operator+(const const_iterator& lhs, int n)
{
const_iterator temp = lhs;
@ -645,7 +645,7 @@ namespace etl
//*************************************************************************
/// Subtract offset.
//*************************************************************************
friend const_iterator operator -(const const_iterator& lhs, int n)
friend const_iterator operator-(const const_iterator& lhs, int n)
{
const_iterator temp = lhs;
@ -657,7 +657,7 @@ namespace etl
//*************************************************************************
/// Equality operator
//*************************************************************************
friend bool operator == (const const_iterator& lhs, const const_iterator& rhs)
friend bool operator==(const const_iterator& lhs, const const_iterator& rhs)
{
return (lhs.current == rhs.current);
}
@ -665,18 +665,18 @@ namespace etl
//*************************************************************************
/// Inequality operator
//*************************************************************************
friend bool operator != (const const_iterator& lhs, const const_iterator& rhs)
friend bool operator!=(const const_iterator& lhs, const const_iterator& rhs)
{
return !(lhs == rhs);
}
//***************************************************
friend bool operator < (const const_iterator& lhs, const const_iterator& rhs)
friend bool operator<(const const_iterator& lhs, const const_iterator& rhs)
{
const difference_type lhs_index = lhs.get_index();
const difference_type rhs_index = rhs.get_index();
const difference_type lhs_index = lhs.get_index();
const difference_type rhs_index = rhs.get_index();
const difference_type reference_index = lhs.container().begin().get_index();
const size_t buffer_size = lhs.container().max_size() + 1UL;
const difference_type buffer_size = static_cast<difference_type>(lhs.container().max_size() + 1UL);
const difference_type lhs_distance = (lhs_index < reference_index) ? buffer_size + lhs_index - reference_index : lhs_index - reference_index;
const difference_type rhs_distance = (rhs_index < reference_index) ? buffer_size + rhs_index - reference_index : rhs_index - reference_index;
@ -685,19 +685,19 @@ namespace etl
}
//***************************************************
friend bool operator <= (const const_iterator& lhs, const const_iterator& rhs)
friend bool operator<=(const const_iterator& lhs, const const_iterator& rhs)
{
return !(lhs > rhs);
}
//***************************************************
friend bool operator > (const const_iterator& lhs, const const_iterator& rhs)
friend bool operator>(const const_iterator& lhs, const const_iterator& rhs)
{
return (rhs < lhs);
}
//***************************************************
friend bool operator >= (const const_iterator& lhs, const const_iterator& rhs)
friend bool operator>=(const const_iterator& lhs, const const_iterator& rhs)
{
return !(lhs < rhs);
}
@ -705,7 +705,7 @@ namespace etl
//***************************************************
difference_type get_index() const
{
return current;
return static_cast<difference_type>(current);
}
//***************************************************
@ -734,7 +734,7 @@ namespace etl
private:
const icircular_buffer<T>* picb;
size_type current;
size_type current;
};
friend class iterator;
@ -886,7 +886,7 @@ namespace etl
//*************************************************************************
/// Get a reference to the item.
//*************************************************************************
reference operator [](size_t index)
reference operator[](size_t index)
{
return pbuffer[(out + index) % buffer_size];
}
@ -895,7 +895,7 @@ namespace etl
/// Get a const reference to the item at the back of the buffer.
/// Asserts an error if the buffer is empty.
//*************************************************************************
const_reference operator [](size_t index) const
const_reference operator[](size_t index) const
{
return pbuffer[(out + index) % buffer_size];
}
@ -988,7 +988,7 @@ namespace etl
//*************************************************************************
void clear()
{
if ETL_IF_CONSTEXPR(etl::is_trivially_destructible<T>::value)
if ETL_IF_CONSTEXPR (etl::is_trivially_destructible<T>::value)
{
in = 0U;
out = 0U;
@ -1021,7 +1021,7 @@ namespace etl
//*************************************************************************
/// - operator for iterator
//*************************************************************************
friend difference_type operator -(const iterator& lhs, const iterator& rhs)
friend difference_type operator-(const iterator& lhs, const iterator& rhs)
{
return distance(rhs, lhs);
}
@ -1029,7 +1029,7 @@ namespace etl
//*************************************************************************
/// - operator for const_iterator
//*************************************************************************
friend difference_type operator -(const const_iterator& lhs, const const_iterator& rhs)
friend difference_type operator-(const const_iterator& lhs, const const_iterator& rhs)
{
return distance(rhs, lhs);
}
@ -1058,14 +1058,15 @@ namespace etl
}
//*************************************************************************
/// Measures the distance from the _begin iterator to the specified iterator.
/// Measures the distance from the _begin iterator to the specified
/// iterator.
//*************************************************************************
template <typename TIterator>
static difference_type distance(const TIterator& other)
{
const difference_type index = other.get_index();
const difference_type reference_index = static_cast<difference_type>(other.container().out);
const size_t buffer_size = other.container().buffer_size;
const difference_type buffer_size = static_cast<difference_type>(other.container().buffer_size);
if (index < reference_index)
{
@ -1093,15 +1094,15 @@ namespace etl
/// Destructor.
//*************************************************************************
#if defined(ETL_POLYMORPHIC_CIRCULAR_BUFFER) || defined(ETL_POLYMORPHIC_CONTAINERS)
public:
virtual ~icircular_buffer()
{
}
virtual ~icircular_buffer() {}
#else
protected:
~icircular_buffer()
{
}
~icircular_buffer() {}
#endif
};
@ -1167,7 +1168,7 @@ namespace etl
//*************************************************************************
/// Assignment operator
//*************************************************************************
circular_buffer& operator =(const circular_buffer& other)
circular_buffer& operator=(const circular_buffer& other)
{
if (this != &other)
{
@ -1199,7 +1200,7 @@ namespace etl
//*************************************************************************
/// Move Assignment operator
//*************************************************************************
circular_buffer& operator =(circular_buffer&& other)
circular_buffer& operator=(circular_buffer&& other)
{
if (this != &other)
{
@ -1228,9 +1229,9 @@ namespace etl
/// Fix the internal pointers after a low level memory copy.
//*************************************************************************
#ifdef ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE
virtual void repair() ETL_OVERRIDE
virtual void repair() ETL_OVERRIDE
#else
void repair()
void repair()
#endif
{
ETL_ASSERT(etl::is_trivially_copyable<T>::value, ETL_ERROR(etl::circular_buffer_incompatible_type));
@ -1278,7 +1279,8 @@ namespace etl
/// Constructs a buffer from an iterator range.
//*************************************************************************
template <typename TIterator>
circular_buffer_ext(TIterator first, const TIterator& last, void* buffer, size_t max_size, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
circular_buffer_ext(TIterator first, const TIterator& last, void* buffer, size_t max_size,
typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: icircular_buffer<T>(reinterpret_cast<T*>(buffer), max_size)
{
while (first != last)
@ -1319,9 +1321,8 @@ namespace etl
//*************************************************************************
/// Assignment operator
//*************************************************************************
circular_buffer_ext& operator =(const circular_buffer_ext& other)
circular_buffer_ext& operator=(const circular_buffer_ext& other)
{
if (this != &other)
{
this->clear();
@ -1352,7 +1353,7 @@ namespace etl
//*************************************************************************
/// Move Assignment operator
//*************************************************************************
circular_buffer_ext& operator =(circular_buffer_ext&& other)
circular_buffer_ext& operator=(circular_buffer_ext&& other)
{
if (this != &other)
{
@ -1398,9 +1399,9 @@ namespace etl
swap(this->pbuffer, other.pbuffer);
swap(this->buffer_size, other.buffer_size);
#if defined(ETL_DEBUG_COUNT)
#if defined(ETL_DEBUG_COUNT)
this->etl_debug_count.swap(other.etl_debug_count);
#endif
#endif
}
#endif
@ -1445,8 +1446,7 @@ namespace etl
//*************************************************************************
#if ETL_USING_CPP17 && ETL_HAS_INITIALIZER_LIST
template <typename T, typename... Ts>
circular_buffer(T, Ts...)
->circular_buffer<etl::enable_if_t<(etl::is_same_v<T, Ts> && ...), T>, 1U + sizeof...(Ts)>;
circular_buffer(T, Ts...) -> circular_buffer<etl::enable_if_t<(etl::is_same_v<T, Ts> && ...), T>, 1U + sizeof...(Ts)>;
#endif
//*************************************************************************
@ -1473,7 +1473,7 @@ namespace etl
/// Equality operator
//*************************************************************************
template <typename T>
bool operator ==(const icircular_buffer<T>& lhs, const icircular_buffer<T>& rhs)
bool operator==(const icircular_buffer<T>& lhs, const icircular_buffer<T>& rhs)
{
return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin());
}
@ -1482,10 +1482,10 @@ namespace etl
/// Inequality operator
//*************************************************************************
template <typename T>
bool operator !=(const icircular_buffer<T>& lhs, const icircular_buffer<T>& rhs)
bool operator!=(const icircular_buffer<T>& lhs, const icircular_buffer<T>& rhs)
{
return !(lhs == rhs);
}
}
} // namespace etl
#endif

118
include/etl/circular_iterator.h
View File

@ -46,7 +46,7 @@ namespace etl
//***************************************************************************
template <typename TIterator>
class circular_iterator_common
: public etl::iterator<typename etl::iterator_traits<TIterator>::iterator_category, typename etl::iterator_traits<TIterator>::value_type>
: public etl::iterator< typename etl::iterator_traits<TIterator>::iterator_category, typename etl::iterator_traits<TIterator>::value_type>
{
public:
@ -89,11 +89,11 @@ namespace etl
//***************************************************************************
/// Assignment
//***************************************************************************
ETL_CONSTEXPR14 circular_iterator_common& operator =(const circular_iterator_common& other)
ETL_CONSTEXPR14 circular_iterator_common& operator=(const circular_iterator_common& other)
{
itr_begin = other.itr_begin;
itr_end = other.itr_end;
itr = other.itr;
itr_end = other.itr_end;
itr = other.itr;
return *this;
}
@ -119,7 +119,7 @@ namespace etl
//***************************************************************************
ETL_CONSTEXPR14 size_t size() const
{
return etl::distance(itr_begin, itr_end);
return static_cast<size_t>(etl::distance(itr_begin, itr_end));
}
//***************************************************************************
@ -133,7 +133,7 @@ namespace etl
//***************************************************************************
/// Dereference operator.
//***************************************************************************
ETL_CONSTEXPR14 value_type operator *()
ETL_CONSTEXPR14 value_type operator*()
{
return *itr;
}
@ -141,7 +141,7 @@ namespace etl
//***************************************************************************
/// Dereference operator.
//***************************************************************************
ETL_CONSTEXPR14 const value_type operator *() const
ETL_CONSTEXPR14 const value_type operator*() const
{
return *itr;
}
@ -149,7 +149,7 @@ namespace etl
//***************************************************************************
/// -> operator.
//***************************************************************************
ETL_CONSTEXPR14 TIterator operator ->()
ETL_CONSTEXPR14 TIterator operator->()
{
return itr;
}
@ -157,7 +157,7 @@ namespace etl
//***************************************************************************
/// -> operator.
//***************************************************************************
ETL_CONSTEXPR14 const TIterator operator ->() const
ETL_CONSTEXPR14 const TIterator operator->() const
{
return itr;
}
@ -187,14 +187,17 @@ namespace etl
//***************************************************************************
/// A circular iterator class.
/// This iterator can be given a pair of iterator values, which will loop if the start or end of the range is reached.
/// This iterator can be given a pair of iterator values, which will loop if
/// the start or end of the range is reached.
///\ingroup iterator
//***************************************************************************
template <typename TIterator, typename TTag = typename etl::iterator_traits<TIterator>::iterator_category>
class circular_iterator_impl
{
ETL_STATIC_ASSERT((etl::is_same<TTag, ETL_OR_STD::input_iterator_tag>::value_type), "input_iterator_catagory is not supported by circular_iterator");
ETL_STATIC_ASSERT((etl::is_same<TTag, ETL_OR_STD::output_iterator_tag>::value_type), "output_iterator_catagory is not supported by circular_iterator");
ETL_STATIC_ASSERT((etl::is_same<TTag, ETL_OR_STD::input_iterator_tag>::value_type),
"input_iterator_catagory is not supported by circular_iterator");
ETL_STATIC_ASSERT((etl::is_same<TTag, ETL_OR_STD::output_iterator_tag>::value_type),
"output_iterator_catagory is not supported by circular_iterator");
};
//***************************************************************************
@ -203,8 +206,7 @@ namespace etl
///\ingroup iterator
/// //***************************************************************************
template <typename TIterator>
class circular_iterator_impl<TIterator, ETL_OR_STD::forward_iterator_tag>
: public circular_iterator_common<TIterator>
class circular_iterator_impl<TIterator, ETL_OR_STD::forward_iterator_tag> : public circular_iterator_common<TIterator>
{
private:
@ -255,7 +257,7 @@ namespace etl
//***************************************************************************
/// Assignment
//***************************************************************************
ETL_CONSTEXPR14 circular_iterator_impl& operator =(const circular_iterator_impl& other)
ETL_CONSTEXPR14 circular_iterator_impl& operator=(const circular_iterator_impl& other)
{
common_t::operator=(other);
@ -265,7 +267,7 @@ namespace etl
//***************************************************************************
/// Increment.
//***************************************************************************
ETL_CONSTEXPR14 circular_iterator_impl& operator ++()
ETL_CONSTEXPR14 circular_iterator_impl& operator++()
{
if (++this->itr == this->itr_end)
{
@ -278,7 +280,7 @@ namespace etl
//***************************************************************************
/// Increment.
//***************************************************************************
ETL_CONSTEXPR14 circular_iterator_impl operator ++(int)
ETL_CONSTEXPR14 circular_iterator_impl operator++(int)
{
circular_iterator_impl original(*this);
@ -294,8 +296,7 @@ namespace etl
///\ingroup iterator
/// //***************************************************************************
template <typename TIterator>
class circular_iterator_impl<TIterator, ETL_OR_STD::bidirectional_iterator_tag>
: public circular_iterator_common<TIterator>
class circular_iterator_impl<TIterator, ETL_OR_STD::bidirectional_iterator_tag> : public circular_iterator_common<TIterator>
{
private:
@ -346,7 +347,7 @@ namespace etl
//***************************************************************************
/// Assignment
//***************************************************************************
ETL_CONSTEXPR14 circular_iterator_impl& operator =(const circular_iterator_impl& other)
ETL_CONSTEXPR14 circular_iterator_impl& operator=(const circular_iterator_impl& other)
{
common_t::operator=(other);
@ -356,7 +357,7 @@ namespace etl
//***************************************************************************
/// Increment.
//***************************************************************************
ETL_CONSTEXPR14 circular_iterator_impl& operator ++()
ETL_CONSTEXPR14 circular_iterator_impl& operator++()
{
if (++this->itr == this->itr_end)
{
@ -369,7 +370,7 @@ namespace etl
//***************************************************************************
/// Increment.
//***************************************************************************
ETL_CONSTEXPR14 circular_iterator_impl operator ++(int)
ETL_CONSTEXPR14 circular_iterator_impl operator++(int)
{
circular_iterator_impl original(*this);
@ -381,7 +382,7 @@ namespace etl
//***************************************************************************
/// Decrement.
//***************************************************************************
ETL_CONSTEXPR14 circular_iterator_impl& operator --()
ETL_CONSTEXPR14 circular_iterator_impl& operator--()
{
if (this->itr == this->itr_begin)
{
@ -400,7 +401,7 @@ namespace etl
//***************************************************************************
/// Decrement.
//***************************************************************************
ETL_CONSTEXPR14 circular_iterator_impl operator --(int)
ETL_CONSTEXPR14 circular_iterator_impl operator--(int)
{
circular_iterator_impl original(*this);
@ -417,11 +418,11 @@ namespace etl
//***************************************************************************
template <typename TIterator>
class circular_iterator_impl<TIterator, ETL_OR_STD::random_access_iterator_tag>
: public etl::private_circular_iterator::circular_iterator_common<TIterator>
: public etl::private_circular_iterator::circular_iterator_common< TIterator>
{
private:
typedef etl::private_circular_iterator::circular_iterator_common<TIterator> common_t;
typedef etl::private_circular_iterator::circular_iterator_common< TIterator> common_t;
public:
@ -468,7 +469,7 @@ namespace etl
//***************************************************************************
/// Assignment
//***************************************************************************
ETL_CONSTEXPR14 circular_iterator_impl& operator =(const circular_iterator_impl& other)
ETL_CONSTEXPR14 circular_iterator_impl& operator=(const circular_iterator_impl& other)
{
common_t::operator=(other);
@ -478,7 +479,7 @@ namespace etl
//***************************************************************************
/// Increment.
//***************************************************************************
ETL_CONSTEXPR14 circular_iterator_impl& operator ++()
ETL_CONSTEXPR14 circular_iterator_impl& operator++()
{
if (++this->itr == this->itr_end)
{
@ -491,7 +492,7 @@ namespace etl
//***************************************************************************
/// Increment.
//***************************************************************************
ETL_CONSTEXPR14 circular_iterator_impl operator ++(int)
ETL_CONSTEXPR14 circular_iterator_impl operator++(int)
{
circular_iterator_impl original(*this);
@ -503,7 +504,7 @@ namespace etl
//***************************************************************************
/// Decrement.
//***************************************************************************
ETL_CONSTEXPR14 circular_iterator_impl& operator --()
ETL_CONSTEXPR14 circular_iterator_impl& operator--()
{
if (this->itr == this->itr_begin)
{
@ -522,7 +523,7 @@ namespace etl
//***************************************************************************
/// Decrement.
//***************************************************************************
ETL_CONSTEXPR14 circular_iterator_impl operator --(int)
ETL_CONSTEXPR14 circular_iterator_impl operator--(int)
{
circular_iterator_impl original(*this);
@ -534,7 +535,7 @@ namespace etl
//***************************************************************************
/// += operator.
//***************************************************************************
ETL_CONSTEXPR14 circular_iterator_impl& operator +=(difference_type offset)
ETL_CONSTEXPR14 circular_iterator_impl& operator+=(difference_type offset)
{
const difference_type length = difference_type(this->size());
offset %= length;
@ -542,7 +543,7 @@ namespace etl
if (offset != 0)
{
const difference_type distance_from_begin = etl::distance(this->itr_begin, this->itr);
const difference_type distance_to_end = etl::distance(this->itr, this->itr_end);
const difference_type distance_to_end = etl::distance(this->itr, this->itr_end);
if (offset > 0)
{
@ -579,25 +580,27 @@ namespace etl
//***************************************************************************
/// -= operator.
//***************************************************************************
ETL_CONSTEXPR14 circular_iterator_impl& operator -=(typename etl::iterator_traits<TIterator>::difference_type offset)
ETL_CONSTEXPR14 circular_iterator_impl& operator-=(typename etl::iterator_traits<TIterator>::difference_type offset)
{
return operator +=(-offset);
return operator+=(-offset);
}
};
}
} // namespace private_circular_iterator
//***************************************************************************
/// A circular iterator class.
/// This iterator can be given a pair of iterator values, which will loop if the start or end of the range is reached.
/// This iterator can be given a pair of iterator values, which will loop if
/// the start or end of the range is reached.
///\ingroup iterator
//**************************************************************************
template <typename TIterator>
class circular_iterator ETL_FINAL
: public etl::private_circular_iterator::circular_iterator_impl<TIterator, typename etl::iterator_traits<TIterator>::iterator_category>
: public etl::private_circular_iterator::circular_iterator_impl< TIterator, typename etl::iterator_traits<TIterator>::iterator_category>
{
private:
typedef typename etl::private_circular_iterator::circular_iterator_impl<TIterator, typename etl::iterator_traits<TIterator>::iterator_category> impl_t;
typedef typename etl::private_circular_iterator::circular_iterator_impl< TIterator, typename etl::iterator_traits<TIterator>::iterator_category>
impl_t;
public:
@ -644,7 +647,7 @@ namespace etl
//***************************************************************************
/// Assignment
//***************************************************************************
ETL_CONSTEXPR14 circular_iterator& operator =(const circular_iterator& other)
ETL_CONSTEXPR14 circular_iterator& operator=(const circular_iterator& other)
{
impl_t::operator=(other);
@ -656,12 +659,12 @@ namespace etl
/// + addition operator.
//*****************************************************************************
template <typename TIterator>
ETL_CONSTEXPR14 etl::circular_iterator<TIterator> operator +(etl::circular_iterator<TIterator>& lhs,
typename etl::iterator_traits<TIterator>::difference_type offset)
ETL_CONSTEXPR14 etl::circular_iterator<TIterator> operator+(etl::circular_iterator<TIterator>& lhs,
typename etl::iterator_traits<TIterator>::difference_type offset)
{
etl::circular_iterator<TIterator> result(lhs);
result += offset;
return result;
}
@ -669,8 +672,8 @@ namespace etl
/// - offset operator.
//*****************************************************************************
template <typename TIterator>
ETL_CONSTEXPR14 etl::circular_iterator<TIterator> operator -(etl::circular_iterator<TIterator>& lhs,
typename etl::iterator_traits<TIterator>::difference_type offset)
ETL_CONSTEXPR14 etl::circular_iterator<TIterator> operator-(etl::circular_iterator<TIterator>& lhs,
typename etl::iterator_traits<TIterator>::difference_type offset)
{
etl::circular_iterator<TIterator> result(lhs);
result -= offset;
@ -682,8 +685,8 @@ namespace etl
/// - circular_iterator difference operator.
//*****************************************************************************
template <typename TIterator>
ETL_CONSTEXPR14 typename etl::iterator_traits<TIterator>::difference_type operator -(etl::circular_iterator<TIterator>& lhs,
etl::circular_iterator<TIterator>& rhs)
ETL_CONSTEXPR14 typename etl::iterator_traits<TIterator>::difference_type operator-(etl::circular_iterator<TIterator>& lhs,
etl::circular_iterator<TIterator>& rhs)
{
return TIterator(lhs) - TIterator(rhs);
}
@ -692,8 +695,7 @@ namespace etl
/// Equality operator. circular_iterator == circular_iterator.
//*****************************************************************************
template <typename TIterator>
ETL_CONSTEXPR14 bool operator ==(const etl::circular_iterator<TIterator>& lhs,
const etl::circular_iterator<TIterator>& rhs)
ETL_CONSTEXPR14 bool operator==(const etl::circular_iterator<TIterator>& lhs, const etl::circular_iterator<TIterator>& rhs)
{
return TIterator(lhs) == TIterator(rhs);
}
@ -702,8 +704,7 @@ namespace etl
/// Equality operator. circular_iterator == iterator.
//*****************************************************************************
template <typename TIterator>
ETL_CONSTEXPR14 bool operator ==(const etl::circular_iterator<TIterator>& lhs,
TIterator rhs)
ETL_CONSTEXPR14 bool operator==(const etl::circular_iterator<TIterator>& lhs, TIterator rhs)
{
return TIterator(lhs) == rhs;
}
@ -712,19 +713,16 @@ namespace etl
/// Equality operator. iterator == circular_iterator.
//*****************************************************************************
template <typename TIterator>
ETL_CONSTEXPR14 bool operator ==(TIterator lhs,
const etl::circular_iterator<TIterator>& rhs)
ETL_CONSTEXPR14 bool operator==(TIterator lhs, const etl::circular_iterator<TIterator>& rhs)
{
return lhs == TIterator(rhs);
}
//*****************************************************************************
/// Inequality operator. circular_iterator == circular_iterator.
//*****************************************************************************
template <typename TIterator>
ETL_CONSTEXPR14 bool operator !=(const etl::circular_iterator<TIterator>& lhs,
const etl::circular_iterator<TIterator>& rhs)
ETL_CONSTEXPR14 bool operator!=(const etl::circular_iterator<TIterator>& lhs, const etl::circular_iterator<TIterator>& rhs)
{
return !(lhs == rhs);
}
@ -733,8 +731,7 @@ namespace etl
/// Inequality operator. circular_iterator == iterator.
//*****************************************************************************
template <typename TIterator>
ETL_CONSTEXPR14 bool operator !=(const etl::circular_iterator<TIterator>& lhs,
TIterator rhs)
ETL_CONSTEXPR14 bool operator!=(const etl::circular_iterator<TIterator>& lhs, TIterator rhs)
{
return !(lhs == rhs);
}
@ -743,11 +740,10 @@ namespace etl
/// Inequality operator. iterator == circular_iterator.
//*****************************************************************************
template <typename TIterator>
ETL_CONSTEXPR14 bool operator !=(TIterator& lhs,
const etl::circular_iterator<TIterator>& rhs)
ETL_CONSTEXPR14 bool operator!=(TIterator& lhs, const etl::circular_iterator<TIterator>& rhs)
{
return !(lhs == rhs);
}
}
} // namespace etl
#endif

66
include/etl/closure.h
View File

@ -34,8 +34,8 @@ SOFTWARE.
#include "platform.h"
#include "delegate.h"
#include "tuple.h"
#include "utility.h"
#include "type_list.h"
#include "utility.h"
namespace etl
{
@ -62,10 +62,10 @@ namespace etl
class closure<TReturn(TArgs...)>
{
public:
using delegate_type = etl::delegate<TReturn(TArgs...)>; ///< The delegate type to be invoked.
using argument_types = etl::type_list<TArgs...>; ///< The type list of arguments.
//*********************************************************************
/// Construct a closure with a delegate and its arguments.
/// \param f The delegate to be invoked.
@ -96,7 +96,7 @@ namespace etl
template <size_t Index, typename UArg>
ETL_CONSTEXPR14 void bind(UArg arg)
{
static_assert(etl::is_convertible<UArg, etl::type_list_type_at_index_t<argument_types, Index>>::value, "Argument is not convertible");
static_assert(etl::is_convertible< UArg, etl::type_list_type_at_index_t<argument_types, Index>>::value, "Argument is not convertible");
static_assert(!etl::is_reference<UArg>::value, "Cannot bind reference arguments");
etl::get<Index>(m_args) = arg;
@ -133,13 +133,13 @@ namespace etl
/// \tparam idx Index sequence for tuple unpacking.
/// \return The result of the delegate invocation.
//*********************************************************************
template<size_t... Indexes>
template <size_t... Indexes>
ETL_CONSTEXPR14 TReturn execute(etl::index_sequence<Indexes...>) const
{
return m_f(etl::get<Indexes>(m_args)...);
}
delegate_type m_f; ///< The delegate to invoke.
delegate_type m_f; ///< The delegate to invoke.
etl::tuple<TArgs...> m_args; ///< The bound arguments.
};
#else
@ -154,7 +154,7 @@ namespace etl
/// \tparam TReturn The return type of the delegate.
/// \tparam TArg0 The type of the argument.
//*************************************************************************
template<typename TReturn, typename TArg0>
template <typename TReturn, typename TArg0>
class closure<TReturn(TArg0)>
{
public:
@ -177,7 +177,7 @@ namespace etl
/// Invoke the stored delegate with the bound argument.
/// \return The result of the delegate invocation.
//*********************************************************************
TReturn operator()() const
TReturn operator()() const
{
return m_f(m_arg0);
}
@ -185,7 +185,7 @@ namespace etl
private:
delegate_type m_f; ///< The delegate to invoke.
TArg0 m_arg0;
TArg0 m_arg0;
};
//*************************************************************************
@ -194,7 +194,7 @@ namespace etl
/// \tparam TArg0 The type of the first argument.
/// \tparam TArg1 The type of the second argument.
//*************************************************************************
template<typename TReturn, typename TArg0, typename TArg1>
template <typename TReturn, typename TArg0, typename TArg1>
class closure<TReturn(TArg0, TArg1)>
{
public:
@ -218,7 +218,7 @@ namespace etl
/// Invoke the stored delegate with the bound arguments.
/// \return The result of the delegate invocation.
//*********************************************************************
TReturn operator()() const
TReturn operator()() const
{
return m_f(m_arg0, m_arg1);
}
@ -226,8 +226,8 @@ namespace etl
private:
delegate_type m_f; ///< The delegate to invoke.
TArg0 m_arg0;
TArg1 m_arg1;
TArg0 m_arg0;
TArg1 m_arg1;
};
//*************************************************************************
@ -237,7 +237,7 @@ namespace etl
/// \tparam TArg1 The type of the second argument.
/// \tparam TArg2 The type of the third argument.
//*************************************************************************
template<typename TReturn, typename TArg0, typename TArg1, typename TArg2>
template <typename TReturn, typename TArg0, typename TArg1, typename TArg2>
class closure<TReturn(TArg0, TArg1, TArg2)>
{
public:
@ -263,7 +263,7 @@ namespace etl
/// Invoke the stored delegate with the bound arguments.
/// \return The result of the delegate invocation.
//*********************************************************************
TReturn operator()() const
TReturn operator()() const
{
return m_f(m_arg0, m_arg1, m_arg2);
}
@ -271,9 +271,9 @@ namespace etl
private:
delegate_type m_f; ///< The delegate to invoke.
TArg0 m_arg0;
TArg1 m_arg1;
TArg2 m_arg2;
TArg0 m_arg0;
TArg1 m_arg1;
TArg2 m_arg2;
};
//*************************************************************************
@ -284,7 +284,7 @@ namespace etl
/// \tparam TArg2 The type of the third argument.
/// \tparam TArg3 The type of the fourth argument.
//*************************************************************************
template<typename TReturn, typename TArg0, typename TArg1, typename TArg2, typename TArg3>
template <typename TReturn, typename TArg0, typename TArg1, typename TArg2, typename TArg3>
class closure<TReturn(TArg0, TArg1, TArg2, TArg3)>
{
public:
@ -312,7 +312,7 @@ namespace etl
/// Invoke the stored delegate with the bound arguments.
/// \return The result of the delegate invocation.
//*********************************************************************
TReturn operator()() const
TReturn operator()() const
{
return m_f(m_arg0, m_arg1, m_arg2, m_arg3);
}
@ -320,10 +320,10 @@ namespace etl
private:
delegate_type m_f; ///< The delegate to invoke.
TArg0 m_arg0;
TArg1 m_arg1;
TArg2 m_arg2;
TArg3 m_arg3;
TArg0 m_arg0;
TArg1 m_arg1;
TArg2 m_arg2;
TArg3 m_arg3;
};
//*************************************************************************
@ -335,7 +335,7 @@ namespace etl
/// \tparam TArg3 The type of the fourth argument.
/// \tparam TArg4 The type of the fifth argument.
//*************************************************************************
template<typename TReturn, typename TArg0, typename TArg1, typename TArg2, typename TArg3, typename TArg4>
template <typename TReturn, typename TArg0, typename TArg1, typename TArg2, typename TArg3, typename TArg4>
class closure<TReturn(TArg0, TArg1, TArg2, TArg3, TArg4)>
{
public:
@ -365,7 +365,7 @@ namespace etl
/// Invoke the stored delegate with the bound arguments.
/// \return The result of the delegate invocation.
//*********************************************************************
TReturn operator()() const
TReturn operator()() const
{
return m_f(m_arg0, m_arg1, m_arg2, m_arg3, m_arg4);
}
@ -373,13 +373,13 @@ namespace etl
private:
delegate_type m_f; ///< The delegate to invoke.
TArg0 m_arg0;
TArg1 m_arg1;
TArg2 m_arg2;
TArg3 m_arg3;
TArg4 m_arg4;
TArg0 m_arg0;
TArg1 m_arg1;
TArg2 m_arg2;
TArg3 m_arg3;
TArg4 m_arg4;
};
#endif
}
} // namespace etl
#endif
#endif

4
include/etl/combinations.h
View File

@ -32,8 +32,8 @@ SOFTWARE.
#define ETL_COMBINATIONS_INCLUDED
#include "platform.h"
#include "permutations.h"
#include "factorial.h"
#include "permutations.h"
///\defgroup combinations combinations
/// combinations<N, K> : Calculates K combinations from N.
@ -58,6 +58,6 @@ namespace etl
template <size_t Value, size_t KV>
inline constexpr size_t combinations_v = combinations<Value, KV>::value;
#endif
}
} // namespace etl
#endif

4
include/etl/compare.h
View File

@ -32,8 +32,8 @@ SOFTWARE.
#define ETL_COMPARE_INCLUDED
#include "platform.h"
#include "parameter_type.h"
#include "functional.h"
#include "parameter_type.h"
//*****************************************************************************
///\defgroup compare compare
@ -107,6 +107,6 @@ namespace etl
{
return etl::compare<T>::cmp(lhs, rhs);
}
}
} // namespace etl
#endif

73
include/etl/concepts.h
View File

@ -33,8 +33,8 @@ SOFTWARE.
#include "platform.h"
#include "utility.h"
#include "type_traits.h"
#include "utility.h"
#if ETL_NOT_USING_CPP20 && !defined(ETL_IN_UNIT_TEST)
#error NOT SUPPORTED FOR BELOW C++20
@ -42,27 +42,27 @@ SOFTWARE.
#if ETL_USING_CPP20
#if ETL_USING_STL
#include <concepts>
#endif
#if ETL_USING_STL
#include <concepts>
#endif
namespace etl
{
#if ETL_USING_STL
#if ETL_USING_STL
using std::same_as;
using std::derived_from;
using std::convertible_to;
using std::assignable_from;
using std::common_reference_with;
using std::common_with;
using std::convertible_to;
using std::derived_from;
using std::floating_point;
using std::integral;
using std::same_as;
using std::signed_integral;
using std::unsigned_integral;
using std::floating_point;
using std::assignable_from;
#else // not ETL_USING_STL
#else // not ETL_USING_STL
namespace private_concepts
{
@ -76,41 +76,23 @@ namespace etl
//***************************************************************************
template <typename Derived, typename Base>
concept derived_from =
etl::is_base_of_v<Base, Derived> &&
etl::is_convertible_v<const volatile Derived*, const volatile Base*>;
concept derived_from = etl::is_base_of_v<Base, Derived> && etl::is_convertible_v<const volatile Derived*, const volatile Base*>;
//***************************************************************************
template <typename From, typename To>
concept convertible_to =
etl::is_convertible_v<From, To> &&
requires {
static_cast<To>(etl::declval<From>());
};
concept convertible_to = etl::is_convertible_v<From, To> && requires { static_cast<To>(etl::declval<From>()); };
//***************************************************************************
template< class T, typename U >
concept common_reference_with =
etl::same_as<etl::common_reference_t<T, U>, etl::common_reference_t<U, T>> &&
etl::convertible_to<T, etl::common_reference_t<T, U>> &&
etl::convertible_to<U, etl::common_reference_t<T, U>>;
template < class T, typename U >
concept common_reference_with = etl::same_as<etl::common_reference_t<T, U>, etl::common_reference_t<U, T> >
&& etl::convertible_to<T, etl::common_reference_t<T, U> > && etl::convertible_to<U, etl::common_reference_t<T, U> >;
//***************************************************************************
template <typename T, typename U>
concept common_with =
etl::same_as<etl::common_type_t<T, U>, etl::common_type_t<U, T>> &&
requires {
static_cast<etl::common_type_t<T, U>>(etl::declval<T>());
static_cast<etl::common_type_t<T, U>>(etl::declval<U>());
} &&
etl::common_reference_with<
etl::add_lvalue_reference_t<const T>,
etl::add_lvalue_reference_t<const U>> &&
etl::common_reference_with<
etl::add_lvalue_reference_t<etl::common_type_t<T, U>>,
etl::common_reference_t<
etl::add_lvalue_reference_t<const T>,
etl::add_lvalue_reference_t<const U>>>;
concept common_with = etl::same_as<etl::common_type_t<T, U>, etl::common_type_t<U, T> > && requires {
static_cast<etl::common_type_t<T, U> >(etl::declval<T>());
static_cast<etl::common_type_t<T, U> >(etl::declval<U>());
} && etl::common_reference_with< etl::add_lvalue_reference_t<const T>, etl::add_lvalue_reference_t<const U> > && etl::common_reference_with< etl::add_lvalue_reference_t<etl::common_type_t<T, U> >, etl::common_reference_t< etl::add_lvalue_reference_t<const T>, etl::add_lvalue_reference_t<const U> > >;
//***************************************************************************
template <typename T>
@ -131,15 +113,12 @@ namespace etl
//***************************************************************************
template <typename LHS, typename RHS>
concept assignable_from =
etl::is_lvalue_reference_v<LHS> &&
etl::common_reference_with<
const etl::remove_reference_t<LHS>&,
const etl::remove_reference_t<RHS>&> &&
requires(LHS lhs, RHS&& rhs) {
{ lhs = etl::forward<RHS>(rhs) } -> etl::same_as<LHS>;
};
etl::is_lvalue_reference_v<LHS> && etl::common_reference_with< const etl::remove_reference_t<LHS>&, const etl::remove_reference_t<RHS>&>
&& requires(LHS lhs, RHS&& rhs) {
{ lhs = etl::forward<RHS>(rhs) } -> etl::same_as<LHS>;
};
#endif
}
#endif
} // namespace etl
#endif
#endif

120
include/etl/const_map.h
View File

@ -38,10 +38,10 @@ SOFTWARE.
#endif
#include "algorithm.h"
#include "type_traits.h"
#include "functional.h"
#include "nth_type.h"
#include "span.h"
#include "type_traits.h"
#include "private/comparator_is_transparent.h"
@ -57,7 +57,7 @@ namespace etl
using key_type = TKey;
using value_type = ETL_OR_STD::pair<const TKey, TMapped>;
using mapped_type = TMapped ;
using mapped_type = TMapped;
using key_compare = TKeyCompare;
using const_reference = const value_type&;
using const_pointer = const value_type*;
@ -72,13 +72,13 @@ namespace etl
public:
// Compare two value types.
ETL_CONSTEXPR14 bool operator ()(const value_type& element1, const value_type& element2) const ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator()(const value_type& element1, const value_type& element2) const ETL_NOEXCEPT
{
return kcompare(element1.first, element2.first);
}
// Compare value type and key.
ETL_CONSTEXPR14 bool operator ()(const value_type& element, const key_type& key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator()(const value_type& element, const key_type& key) const ETL_NOEXCEPT
{
return kcompare(element.first, key);
}
@ -86,13 +86,13 @@ namespace etl
// Compare value types and key.
// Enabled for transparent comparators.
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 bool operator ()(const value_type& element, const K& key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator()(const value_type& element, const K& key) const ETL_NOEXCEPT
{
return kcompare(element.first, key);
}
// Compare key and value type.
ETL_CONSTEXPR14 bool operator ()(const key_type& key, const value_type& element) const ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator()(const key_type& key, const value_type& element) const ETL_NOEXCEPT
{
return kcompare(key, element.first);
}
@ -100,7 +100,7 @@ namespace etl
// Compare key and value type.
// Enabled for transparent comparators.
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 bool operator ()(const K& key, const value_type& element) const ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator()(const K& key, const value_type& element) const ETL_NOEXCEPT
{
return kcompare(key, element.first);
}
@ -161,13 +161,14 @@ namespace etl
//*************************************************************************
///\brief Index operator.
///\param key The key of the element to return.
///\return A <code>const mapped_type&</code> to the mapped value at the index.
///\return A <code>const mapped_type&</code> to the mapped value at the
/// index.
/// Undefined behaviour if the key is not in the map.
//*************************************************************************
ETL_CONSTEXPR14 const mapped_type& operator[](const key_type& key) const ETL_NOEXCEPT
{
const_iterator itr = find(key);
return itr->second;
}
@ -175,7 +176,8 @@ namespace etl
///\brief Key index operator.
/// Enabled for transparent comparators.
///\param key The key of the element to return.
///\return A <code>const mapped_type&</code> to the mapped value at the key index.
///\return A <code>const mapped_type&</code> to the mapped value at the key
/// index.
/// Undefined behaviour if the key is not in the map.
//*************************************************************************
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
@ -189,7 +191,8 @@ namespace etl
//*************************************************************************
///\brief Gets the mapped value at the key index.
///\param key The key of the element to return.
///\return A <code>const mapped_type&</code> to the mapped value at the index.
///\return A <code>const mapped_type&</code> to the mapped value at the
/// index.
/// Undefined behaviour if the key is not in the map.
//*************************************************************************
ETL_CONSTEXPR14 const mapped_type& at(const key_type& key) const ETL_NOEXCEPT
@ -203,7 +206,8 @@ namespace etl
///\brief Gets the mapped value at the key index.
/// Enabled if the comparator is transparent.
///\param key The key of the element to return.
///\return A <code>const mapped_type&</code> to the mapped value at the index.
///\return A <code>const mapped_type&</code> to the mapped value at the
/// index.
/// Undefined behaviour if the key is not in the map.
//*************************************************************************
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
@ -283,7 +287,7 @@ namespace etl
{
return contains(key) ? 1 : 0;
}
//*************************************************************************
///\brief Counts the numbeer elements with key.
/// Enabled if the comparator is transparent.
@ -297,9 +301,9 @@ namespace etl
}
//*************************************************************************
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
/// element greater than the key.
///\param key The key of the element
///\return etl::pair or std::pair containing a pair of iterators.
@ -310,9 +314,9 @@ namespace etl
}
//*************************************************************************
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
/// element greater than the key.
/// Enabled if the comparator is transparent.
///\param key The key of the element
@ -325,8 +329,10 @@ namespace etl
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is not less than the key.
/// Returns a const_iterator to the first element that is not less than the key.
///\brief Returns a const_iterator to the first element that is not less
/// than the key.
/// Returns a const_iterator to the first element that is not less than the
/// key.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
@ -336,9 +342,10 @@ namespace etl
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is not less than the key.
/// Returns a const_iterator to the first element that is not less than the key.
/// Enabled if the comparator is transparent.
///\brief Returns a const_iterator to the first element that is not less
/// than the key.
/// Returns a const_iterator to the first element that is not less than the
/// key. Enabled if the comparator is transparent.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
@ -349,8 +356,10 @@ namespace etl
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is greater than the key.
/// Returns a const_iterator to the first element that is greater than the key.
///\brief Returns a const_iterator to the first element that is greater than
/// the key.
/// Returns a const_iterator to the first element that is greater than the
/// key.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
@ -360,9 +369,10 @@ namespace etl
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is greater than the key.
/// Returns a const_iterator to the first element that is greater than the key.
/// Enabled if the comparator is transparent.
///\brief Returns a const_iterator to the first element that is greater than
/// the key.
/// Returns a const_iterator to the first element that is greater than the
/// key. Enabled if the comparator is transparent.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
@ -488,20 +498,21 @@ namespace etl
using key_type = typename base_t::key_type;
using value_type = typename base_t::value_type;
using mapped_type = typename base_t::mapped_type ;
using mapped_type = typename base_t::mapped_type;
using key_compare = typename base_t::key_compare;
using const_reference = typename base_t::const_reference;
using const_pointer = typename base_t::const_pointer;
using const_iterator = typename base_t::const_iterator;
using size_type = typename base_t::size_type;
static_assert((etl::is_default_constructible<key_type>::value), "key_type must be default constructible");
static_assert((etl::is_default_constructible<key_type>::value), "key_type must be default constructible");
static_assert((etl::is_default_constructible<mapped_type>::value), "mapped_type must be default constructible");
//*************************************************************************
///\brief Construct a const_map from a variadic list of elements.
/// Static asserts if the elements are not of type <code>value_type</code>.
/// Static asserts if the number of elements is greater than the capacity of the const_map.
/// Static asserts if the number of elements is greater than the capacity of
/// the const_map.
//*************************************************************************
template <typename... TElements>
ETL_CONSTEXPR14 explicit const_map(TElements&&... elements) ETL_NOEXCEPT
@ -509,7 +520,7 @@ namespace etl
, element_list{etl::forward<TElements>(elements)...}
{
static_assert((etl::are_all_same<value_type, etl::decay_t<TElements>...>::value), "All elements must be value_type");
static_assert(sizeof...(elements) <= Size, "Number of elements exceeds capacity");
static_assert(sizeof...(elements) <= Size, "Number of elements exceeds capacity");
}
private:
@ -522,9 +533,8 @@ namespace etl
//*************************************************************************
#if ETL_USING_CPP17
template <typename... TElements>
const_map(TElements...) -> const_map<typename etl::nth_type_t<0, TElements...>::first_type,
typename etl::nth_type_t<0, TElements...>::second_type,
sizeof...(TElements)>;
const_map(TElements...)
-> const_map<typename etl::nth_type_t<0, TElements...>::first_type, typename etl::nth_type_t<0, TElements...>::second_type, sizeof...(TElements)>;
#endif
//*********************************************************************
@ -539,14 +549,14 @@ namespace etl
using key_type = typename base_t::key_type;
using value_type = typename base_t::value_type;
using mapped_type = typename base_t::mapped_type ;
using mapped_type = typename base_t::mapped_type;
using key_compare = typename base_t::key_compare;
using const_reference = typename base_t::const_reference;
using const_pointer = typename base_t::const_pointer;
using const_iterator = typename base_t::const_iterator;
using size_type = typename base_t::size_type;
static_assert((etl::is_default_constructible<key_type>::value), "key_type must be default constructible");
static_assert((etl::is_default_constructible<key_type>::value), "key_type must be default constructible");
static_assert((etl::is_default_constructible<mapped_type>::value), "mapped_type must be default constructible");
//*************************************************************************
@ -570,7 +580,7 @@ namespace etl
///\brief Construct a const_map from an array.
//*************************************************************************
template <size_type Size>
ETL_CONSTEXPR14 explicit const_map_ext(const value_type(&begin_)[Size]) ETL_NOEXCEPT
ETL_CONSTEXPR14 explicit const_map_ext(const value_type (&begin_)[Size]) ETL_NOEXCEPT
: iconst_map<TKey, TMapped, TKeyCompare>(begin_, Size, Size)
{
}
@ -584,15 +594,15 @@ namespace etl
const_map_ext(const etl::span<TElements, Size>&) -> const_map_ext<typename TElements::first_type, typename TElements::second_type>;
template <typename TElements, size_t Size>
const_map_ext(const TElements(&)[Size]) -> const_map_ext<typename TElements::first_type, typename TElements::second_type>;
const_map_ext(const TElements (&)[Size]) -> const_map_ext<typename TElements::first_type, typename TElements::second_type>;
#endif
//*************************************************************************
/// Equality test.
//*************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator ==(const etl::iconst_map<TKey, TMapped, TKeyCompare>& lhs,
const etl::iconst_map<TKey, TMapped, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator==(const etl::iconst_map<TKey, TMapped, TKeyCompare>& lhs, const etl::iconst_map<TKey, TMapped, TKeyCompare>& rhs)
ETL_NOEXCEPT
{
return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin());
}
@ -601,8 +611,8 @@ namespace etl
/// Inequality test.
//*************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator !=(const etl::iconst_map<TKey, TMapped, TKeyCompare>& lhs,
const etl::iconst_map<TKey, TMapped, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator!=(const etl::iconst_map<TKey, TMapped, TKeyCompare>& lhs, const etl::iconst_map<TKey, TMapped, TKeyCompare>& rhs)
ETL_NOEXCEPT
{
return !(lhs == rhs);
}
@ -611,20 +621,18 @@ namespace etl
/// Less-than.
//*************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator <(const etl::iconst_map<TKey, TMapped, TKeyCompare>& lhs,
const etl::iconst_map<TKey, TMapped, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator<(const etl::iconst_map<TKey, TMapped, TKeyCompare>& lhs, const etl::iconst_map<TKey, TMapped, TKeyCompare>& rhs)
ETL_NOEXCEPT
{
return etl::lexicographical_compare(lhs.begin(), lhs.end(),
rhs.begin(), rhs.end(),
lhs.value_comp());
return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), lhs.value_comp());
}
//*************************************************************************
/// Greater-than.
//*************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator >(const etl::iconst_map<TKey, TMapped, TKeyCompare>& lhs,
const etl::iconst_map<TKey, TMapped, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator>(const etl::iconst_map<TKey, TMapped, TKeyCompare>& lhs, const etl::iconst_map<TKey, TMapped, TKeyCompare>& rhs)
ETL_NOEXCEPT
{
return (rhs < lhs);
}
@ -633,8 +641,8 @@ namespace etl
/// Less-than-equal.
//*************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator <=(const etl::iconst_map<TKey, TMapped, TKeyCompare>& lhs,
const etl::iconst_map<TKey, TMapped, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator<=(const etl::iconst_map<TKey, TMapped, TKeyCompare>& lhs, const etl::iconst_map<TKey, TMapped, TKeyCompare>& rhs)
ETL_NOEXCEPT
{
return !(rhs < lhs);
}
@ -643,11 +651,11 @@ namespace etl
/// Greater-than-equal.
//*************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator >=(const etl::iconst_map<TKey, TMapped, TKeyCompare>& lhs,
const etl::iconst_map<TKey, TMapped, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator>=(const etl::iconst_map<TKey, TMapped, TKeyCompare>& lhs, const etl::iconst_map<TKey, TMapped, TKeyCompare>& rhs)
ETL_NOEXCEPT
{
return !(lhs < rhs);
}
}
} // namespace etl
#endif

111
include/etl/const_multimap.h
View File

@ -31,17 +31,17 @@ SOFTWARE.
#ifndef ETL_CONST_MULTIMAP_INCLUDED
#define ETL_CONST_MULTIMAP_INCLUDED
#include "platform.h"
#include "platform.h"
#if ETL_NOT_USING_CPP11
#error NOT SUPPORTED FOR C++03 OR BELOW
#endif
#include "algorithm.h"
#include "type_traits.h"
#include "functional.h"
#include "nth_type.h"
#include "span.h"
#include "type_traits.h"
#include "private/comparator_is_transparent.h"
@ -57,7 +57,7 @@ namespace etl
using key_type = TKey;
using value_type = ETL_OR_STD::pair<const TKey, TMapped>;
using mapped_type = TMapped ;
using mapped_type = TMapped;
using key_compare = TKeyCompare;
using const_reference = const value_type&;
using const_pointer = const value_type*;
@ -72,13 +72,13 @@ namespace etl
public:
// Compare two value types.
ETL_CONSTEXPR14 bool operator ()(const value_type& element1, const value_type& element2) const ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator()(const value_type& element1, const value_type& element2) const ETL_NOEXCEPT
{
return kcompare(element1.first, element2.first);
}
// Compare value type and key.
ETL_CONSTEXPR14 bool operator ()(const value_type& element, const key_type& key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator()(const value_type& element, const key_type& key) const ETL_NOEXCEPT
{
return kcompare(element.first, key);
}
@ -86,13 +86,13 @@ namespace etl
// Compare value types and key.
// Enabled for transparent comparators.
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 bool operator ()(const value_type& element, const K& key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator()(const value_type& element, const K& key) const ETL_NOEXCEPT
{
return kcompare(element.first, key);
}
// Compare key and value type.
ETL_CONSTEXPR14 bool operator ()(const key_type& key, const value_type& element) const ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator()(const key_type& key, const value_type& element) const ETL_NOEXCEPT
{
return kcompare(key, element.first);
}
@ -100,7 +100,7 @@ namespace etl
// Compare key and value type.
// Enabled for transparent comparators.
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 bool operator ()(const K& key, const value_type& element) const ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator()(const K& key, const value_type& element) const ETL_NOEXCEPT
{
return kcompare(key, element.first);
}
@ -234,7 +234,7 @@ namespace etl
return size_type(etl::distance(range.first, range.second));
}
//*************************************************************************
///\brief Counts the numbeer elements with key.
/// Enabled if the comparator is transparent.
@ -250,9 +250,9 @@ namespace etl
}
//*************************************************************************
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
/// element greater than the key.
///\param key The key of the element
///\return etl::pair or std::pair containing a pair of iterators.
@ -263,9 +263,9 @@ namespace etl
}
//*************************************************************************
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
/// element greater than the key.
/// Enabled if the comparator is transparent.
///\param key The key of the element
@ -278,8 +278,10 @@ namespace etl
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is not less than the key.
/// Returns a const_iterator to the first element that is not less than the key.
///\brief Returns a const_iterator to the first element that is not less
/// than the key.
/// Returns a const_iterator to the first element that is not less than the
/// key.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
@ -289,9 +291,10 @@ namespace etl
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is not less than the key.
/// Returns a const_iterator to the first element that is not less than the key.
/// Enabled if the comparator is transparent.
///\brief Returns a const_iterator to the first element that is not less
/// than the key.
/// Returns a const_iterator to the first element that is not less than the
/// key. Enabled if the comparator is transparent.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
@ -302,8 +305,10 @@ namespace etl
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is greater than the key.
/// Returns a const_iterator to the first element that is greater than the key.
///\brief Returns a const_iterator to the first element that is greater than
/// the key.
/// Returns a const_iterator to the first element that is greater than the
/// key.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
@ -313,9 +318,10 @@ namespace etl
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is greater than the key.
/// Returns a const_iterator to the first element that is greater than the key.
/// Enabled if the comparator is transparent.
///\brief Returns a const_iterator to the first element that is greater than
/// the key.
/// Returns a const_iterator to the first element that is greater than the
/// key. Enabled if the comparator is transparent.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
@ -426,7 +432,7 @@ namespace etl
const value_type* element_list;
const value_type* element_list_end;
size_type max_elements;
size_type max_elements;
};
//*************************************************************************
@ -448,14 +454,15 @@ namespace etl
using const_iterator = typename base_t::const_iterator;
using size_type = typename base_t::size_type;
static_assert((etl::is_default_constructible<key_type>::value), "key_type must be default constructible");
static_assert((etl::is_default_constructible<key_type>::value), "key_type must be default constructible");
static_assert((etl::is_default_constructible<mapped_type>::value), "mapped_type must be default constructible");
//*************************************************************************
///\brief Construct a const_map from a variadic list of elements.
/// Static asserts if the element type is not constructible.
/// Static asserts if the elements are not of type <code>value_type</code>.
/// Static asserts if the number of elements is greater than the capacity of the const_map.
/// Static asserts if the number of elements is greater than the capacity of
/// the const_map.
//*************************************************************************
template <typename... TElements>
ETL_CONSTEXPR14 explicit const_multimap(TElements&&... elements) ETL_NOEXCEPT
@ -463,7 +470,7 @@ namespace etl
, element_list{etl::forward<TElements>(elements)...}
{
static_assert((etl::are_all_same<value_type, etl::decay_t<TElements>...>::value), "All elements must be value_type");
static_assert(sizeof...(elements) <= Size, "Number of elements exceeds capacity");
static_assert(sizeof...(elements) <= Size, "Number of elements exceeds capacity");
}
private:
@ -476,9 +483,8 @@ namespace etl
//*************************************************************************
#if ETL_USING_CPP17
template <typename... TPairs>
const_multimap(TPairs...) -> const_multimap<typename etl::nth_type_t<0, TPairs...>::first_type,
typename etl::nth_type_t<0, TPairs...>::second_type,
sizeof...(TPairs)>;
const_multimap(TPairs...)
-> const_multimap<typename etl::nth_type_t<0, TPairs...>::first_type, typename etl::nth_type_t<0, TPairs...>::second_type, sizeof...(TPairs)>;
#endif
//*********************************************************************
@ -493,14 +499,14 @@ namespace etl
using key_type = typename base_t::key_type;
using value_type = typename base_t::value_type;
using mapped_type = typename base_t::mapped_type ;
using mapped_type = typename base_t::mapped_type;
using key_compare = typename base_t::key_compare;
using const_reference = typename base_t::const_reference;
using const_pointer = typename base_t::const_pointer;
using const_iterator = typename base_t::const_iterator;
using size_type = typename base_t::size_type;
static_assert((etl::is_default_constructible<key_type>::value), "key_type must be default constructible");
static_assert((etl::is_default_constructible<key_type>::value), "key_type must be default constructible");
static_assert((etl::is_default_constructible<mapped_type>::value), "mapped_type must be default constructible");
//*************************************************************************
@ -524,7 +530,7 @@ namespace etl
///\brief Construct a const_map from an array.
//*************************************************************************
template <size_type Size>
ETL_CONSTEXPR14 explicit const_multimap_ext(const value_type(&begin_)[Size]) ETL_NOEXCEPT
ETL_CONSTEXPR14 explicit const_multimap_ext(const value_type (&begin_)[Size]) ETL_NOEXCEPT
: iconst_multimap<TKey, TMapped, TKeyCompare>(begin_, Size, Size)
{
}
@ -538,15 +544,15 @@ namespace etl
const_multimap_ext(const etl::span<TElements, Size>&) -> const_multimap_ext<typename TElements::first_type, typename TElements::second_type>;
template <typename TElements, size_t Size>
const_multimap_ext(const TElements(&)[Size]) -> const_multimap_ext<typename TElements::first_type, typename TElements::second_type>;
const_multimap_ext(const TElements (&)[Size]) -> const_multimap_ext<typename TElements::first_type, typename TElements::second_type>;
#endif
//*************************************************************************
/// Equality test.
//*************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator ==(const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& lhs,
const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator==(const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& lhs,
const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return etl::equal(lhs.begin(), lhs.end(), rhs.begin());
}
@ -555,8 +561,8 @@ namespace etl
/// Inequality test.
//*************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator !=(const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& lhs,
const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator!=(const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& lhs,
const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return !(lhs == rhs);
}
@ -569,12 +575,10 @@ namespace etl
/// second, otherwise <b>false</b>.
//*************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator <(const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& lhs,
const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator<(const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& lhs,
const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return etl::lexicographical_compare(lhs.begin(), lhs.end(),
rhs.begin(), rhs.end(),
lhs.value_comp());
return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), lhs.value_comp());
}
//*************************************************************************
@ -585,8 +589,8 @@ namespace etl
/// second, otherwise <b>false</b>.
//*************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator >(const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& lhs,
const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator>(const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& lhs,
const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return (rhs < lhs);
}
@ -595,12 +599,13 @@ namespace etl
/// Less than or equal operator.
///\param lhs Reference to the first list.
///\param rhs Reference to the second list.
///\return <b>true</b> if the first list is lexicographically less than or equal
///\return <b>true</b> if the first list is lexicographically less than or
/// equal
/// to the second, otherwise <b>false</b>.
//*************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator <=(const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& lhs,
const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator<=(const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& lhs,
const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return !(rhs < lhs);
}
@ -613,11 +618,11 @@ namespace etl
/// equal to the second, otherwise <b>false</b>.
//*************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator >=(const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& lhs,
const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator>=(const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& lhs,
const etl::iconst_multimap<TKey, TMapped, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return !(lhs < rhs);
}
}
} // namespace etl
#endif

82
include/etl/const_multiset.h
View File

@ -31,17 +31,17 @@ SOFTWARE.
#ifndef ETL_CONST_MULTISET_INCLUDED
#define ETL_CONST_MULTISET_INCLUDED
#include "platform.h"
#include "platform.h"
#if ETL_NOT_USING_CPP11
#error NOT SUPPORTED FOR C++03 OR BELOW
#endif
#include "algorithm.h"
#include "type_traits.h"
#include "functional.h"
#include "nth_type.h"
#include "span.h"
#include "type_traits.h"
#include "private/comparator_is_transparent.h"
@ -190,7 +190,7 @@ namespace etl
return size_type(etl::distance(range.first, range.second));
}
//*************************************************************************
///\brief Counts the numbeer elements with key.
/// Enabled if the comparator is transparent.
@ -206,9 +206,9 @@ namespace etl
}
//*************************************************************************
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
/// element greater than the key.
///\param key The key of the element
///\return etl::pair or std::pair containing a pair of iterators.
@ -219,9 +219,9 @@ namespace etl
}
//*************************************************************************
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
/// element greater than the key.
/// Enabled if the comparator is transparent.
///\param key The key of the element
@ -234,8 +234,10 @@ namespace etl
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is not less than the key.
/// Returns a const_iterator to the first element that is not less than the key.
///\brief Returns a const_iterator to the first element that is not less
/// than the key.
/// Returns a const_iterator to the first element that is not less than the
/// key.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
@ -245,9 +247,10 @@ namespace etl
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is not less than the key.
/// Returns a const_iterator to the first element that is not less than the key.
/// Enabled if the comparator is transparent.
///\brief Returns a const_iterator to the first element that is not less
/// than the key.
/// Returns a const_iterator to the first element that is not less than the
/// key. Enabled if the comparator is transparent.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
@ -258,8 +261,10 @@ namespace etl
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is greater than the key.
/// Returns a const_iterator to the first element that is greater than the key.
///\brief Returns a const_iterator to the first element that is greater than
/// the key.
/// Returns a const_iterator to the first element that is greater than the
/// key.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
@ -269,9 +274,10 @@ namespace etl
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is greater than the key.
/// Returns a const_iterator to the first element that is greater than the key.
/// Enabled if the comparator is transparent.
///\brief Returns a const_iterator to the first element that is greater than
/// the key.
/// Returns a const_iterator to the first element that is greater than the
/// key. Enabled if the comparator is transparent.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
@ -383,7 +389,7 @@ namespace etl
const value_type* element_list;
const value_type* element_list_end;
size_type max_elements;
size_type max_elements;
};
//*************************************************************************
@ -410,7 +416,8 @@ namespace etl
///\brief Construct a const_set from a variadic list of elements.
/// Static asserts if the element type is not constructible.
/// Static asserts if the elements are not of type <code>value_type</code>.
/// Static asserts if the number of elements is greater than the capacity of the const_set.
/// Static asserts if the number of elements is greater than the capacity of
/// the const_set.
//*************************************************************************
template <typename... TElements>
ETL_CONSTEXPR14 explicit const_multiset(TElements&&... elements) ETL_NOEXCEPT
@ -418,7 +425,7 @@ namespace etl
, element_list{etl::forward<TElements>(elements)...}
{
static_assert((etl::are_all_same<value_type, etl::decay_t<TElements>...>::value), "All elements must be value_type");
static_assert(sizeof...(elements) <= Size, "Number of elements exceeds capacity");
static_assert(sizeof...(elements) <= Size, "Number of elements exceeds capacity");
}
private:
@ -475,7 +482,7 @@ namespace etl
///\brief Construct a const_multiset from an array.
//*************************************************************************
template <size_type Size>
ETL_CONSTEXPR14 explicit const_multiset_ext(const value_type(&begin_)[Size]) ETL_NOEXCEPT
ETL_CONSTEXPR14 explicit const_multiset_ext(const value_type (&begin_)[Size]) ETL_NOEXCEPT
: iconst_multiset<TKey, TKeyCompare>(begin_, Size, Size)
{
}
@ -489,15 +496,14 @@ namespace etl
const_multiset_ext(const etl::span<TElements, Size>&) -> const_multiset_ext<TElements>;
template <typename TElements, size_t Size>
const_multiset_ext(const TElements(&)[Size]) -> const_multiset_ext<TElements>;
const_multiset_ext(const TElements (&)[Size]) -> const_multiset_ext<TElements>;
#endif
//*************************************************************************
/// Equality test.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator ==(const etl::iconst_multiset<TKey, TKeyCompare>& lhs,
const etl::iconst_multiset<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator==(const etl::iconst_multiset<TKey, TKeyCompare>& lhs, const etl::iconst_multiset<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin());
}
@ -506,8 +512,7 @@ namespace etl
/// Inequality test.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator !=(const etl::iconst_multiset<TKey, TKeyCompare>& lhs,
const etl::iconst_multiset<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator!=(const etl::iconst_multiset<TKey, TKeyCompare>& lhs, const etl::iconst_multiset<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return !(lhs == rhs);
}
@ -520,12 +525,9 @@ namespace etl
/// second, otherwise <b>false</b>.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator <(const etl::iconst_multiset<TKey, TKeyCompare>& lhs,
const etl::iconst_multiset<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator<(const etl::iconst_multiset<TKey, TKeyCompare>& lhs, const etl::iconst_multiset<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return etl::lexicographical_compare(lhs.begin(), lhs.end(),
rhs.begin(), rhs.end(),
lhs.value_comp());
return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), lhs.value_comp());
}
//*************************************************************************
@ -536,8 +538,7 @@ namespace etl
/// second, otherwise <b>false</b>.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator >(const etl::iconst_multiset<TKey, TKeyCompare>& lhs,
const etl::iconst_multiset<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator>(const etl::iconst_multiset<TKey, TKeyCompare>& lhs, const etl::iconst_multiset<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return (rhs < lhs);
}
@ -546,12 +547,12 @@ namespace etl
/// Less than or equal operator.
///\param lhs Reference to the first list.
///\param rhs Reference to the second list.
///\return <b>true</b> if the first list is lexicographically less than or equal
///\return <b>true</b> if the first list is lexicographically less than or
/// equal
/// to the second, otherwise <b>false</b>.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator <=(const etl::iconst_multiset<TKey, TKeyCompare>& lhs,
const etl::iconst_multiset<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator<=(const etl::iconst_multiset<TKey, TKeyCompare>& lhs, const etl::iconst_multiset<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return !(rhs < lhs);
}
@ -564,11 +565,10 @@ namespace etl
/// equal to the second, otherwise <b>false</b>.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator >=(const etl::iconst_multiset<TKey, TKeyCompare>& lhs,
const etl::iconst_multiset<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator>=(const etl::iconst_multiset<TKey, TKeyCompare>& lhs, const etl::iconst_multiset<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return !(lhs < rhs);
}
}
} // namespace etl
#endif

75
include/etl/const_set.h
View File

@ -38,10 +38,10 @@ SOFTWARE.
#endif
#include "algorithm.h"
#include "type_traits.h"
#include "functional.h"
#include "nth_type.h"
#include "span.h"
#include "type_traits.h"
#include "private/comparator_is_transparent.h"
@ -183,7 +183,7 @@ namespace etl
{
return contains(key) ? 1 : 0;
}
//*************************************************************************
///\brief Counts the numbeer elements with key.
/// Enabled if the comparator is transparent.
@ -197,9 +197,9 @@ namespace etl
}
//*************************************************************************
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
/// element greater than the key.
///\param key The key of the element
///\return etl::pair or std::pair containing a pair of iterators.
@ -210,9 +210,9 @@ namespace etl
}
//*************************************************************************
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
/// element greater than the key.
/// Enabled if the comparator is transparent.
///\param key The key of the element
@ -225,8 +225,10 @@ namespace etl
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is not less than the key.
/// Returns a const_iterator to the first element that is not less than the key.
///\brief Returns a const_iterator to the first element that is not less
/// than the key.
/// Returns a const_iterator to the first element that is not less than the
/// key.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
@ -236,9 +238,10 @@ namespace etl
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is not less than the key.
/// Returns a const_iterator to the first element that is not less than the key.
/// Enabled if the comparator is transparent.
///\brief Returns a const_iterator to the first element that is not less
/// than the key.
/// Returns a const_iterator to the first element that is not less than the
/// key. Enabled if the comparator is transparent.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
@ -249,8 +252,10 @@ namespace etl
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is greater than the key.
/// Returns a const_iterator to the first element that is greater than the key.
///\brief Returns a const_iterator to the first element that is greater than
/// the key.
/// Returns a const_iterator to the first element that is greater than the
/// key.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
@ -260,9 +265,10 @@ namespace etl
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is greater than the key.
/// Returns a const_iterator to the first element that is greater than the key.
/// Enabled if the comparator is transparent.
///\brief Returns a const_iterator to the first element that is greater than
/// the key.
/// Returns a const_iterator to the first element that is greater than the
/// key. Enabled if the comparator is transparent.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
@ -403,7 +409,8 @@ namespace etl
//*************************************************************************
///\brief Construct a const_set from a variadic list of elements.
/// Static asserts if the elements are not of type <code>value_type</code>.
/// Static asserts if the number of elements is greater than the capacity of the const_set.
/// Static asserts if the number of elements is greater than the capacity of
/// the const_set.
//*************************************************************************
template <typename... TElements>
ETL_CONSTEXPR14 explicit const_set(TElements&&... elements) ETL_NOEXCEPT
@ -411,7 +418,7 @@ namespace etl
, element_list{etl::forward<TElements>(elements)...}
{
static_assert((etl::are_all_same<value_type, etl::decay_t<TElements>...>::value), "All elements must be key_type");
static_assert(sizeof...(elements) <= Size, "Number of elements exceeds capacity");
static_assert(sizeof...(elements) <= Size, "Number of elements exceeds capacity");
}
private:
@ -468,7 +475,7 @@ namespace etl
///\brief Construct a const_set from an array.
//*************************************************************************
template <size_type Size>
ETL_CONSTEXPR14 explicit const_set_ext(const value_type(&begin_)[Size]) ETL_NOEXCEPT
ETL_CONSTEXPR14 explicit const_set_ext(const value_type (&begin_)[Size]) ETL_NOEXCEPT
: iconst_set<TKey, TKeyCompare>(begin_, Size, Size)
{
}
@ -482,15 +489,14 @@ namespace etl
const_set_ext(const etl::span<TElements, Size>&) -> const_set_ext<TElements>;
template <typename TElements, size_t Size>
const_set_ext(const TElements(&)[Size]) -> const_set_ext<TElements>;
const_set_ext(const TElements (&)[Size]) -> const_set_ext<TElements>;
#endif
//*************************************************************************
/// Equality test.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator ==(const etl::iconst_set<TKey, TKeyCompare>& lhs,
const etl::iconst_set<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator==(const etl::iconst_set<TKey, TKeyCompare>& lhs, const etl::iconst_set<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin());
}
@ -499,8 +505,7 @@ namespace etl
/// Inequality test.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator !=(const etl::iconst_set<TKey, TKeyCompare>& lhs,
const etl::iconst_set<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator!=(const etl::iconst_set<TKey, TKeyCompare>& lhs, const etl::iconst_set<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return !(lhs == rhs);
}
@ -509,20 +514,16 @@ namespace etl
/// Less-than.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator <(const etl::iconst_set<TKey, TKeyCompare>& lhs,
const etl::iconst_set<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator<(const etl::iconst_set<TKey, TKeyCompare>& lhs, const etl::iconst_set<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return etl::lexicographical_compare(lhs.begin(), lhs.end(),
rhs.begin(), rhs.end(),
lhs.value_comp());
return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), lhs.value_comp());
}
//*************************************************************************
/// Greater-than.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator >(const etl::iconst_set<TKey, TKeyCompare>& lhs,
const etl::iconst_set<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator>(const etl::iconst_set<TKey, TKeyCompare>& lhs, const etl::iconst_set<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return (rhs < lhs);
}
@ -531,8 +532,7 @@ namespace etl
/// Less-than-equal.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator <=(const etl::iconst_set<TKey, TKeyCompare>& lhs,
const etl::iconst_set<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator<=(const etl::iconst_set<TKey, TKeyCompare>& lhs, const etl::iconst_set<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return !(rhs < lhs);
}
@ -541,11 +541,10 @@ namespace etl
/// Greater-than-equal.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator >=(const etl::iconst_set<TKey, TKeyCompare>& lhs,
const etl::iconst_set<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator>=(const etl::iconst_set<TKey, TKeyCompare>& lhs, const etl::iconst_set<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return !(lhs < rhs);
}
}
} // namespace etl
#endif

2
include/etl/constant.h
View File

@ -52,6 +52,6 @@ namespace etl
template <typename T, const T VALUE>
const T constant<T, VALUE>::value;
}
} // namespace etl
#endif

1
include/etl/container.h
View File

@ -37,4 +37,3 @@ SOFTWARE.
#include <stddef.h>
#endif

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