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

Squashed commit of the following:

Browse Source 
commit c5dc331004b4d9611ab996935bedada203676c71
Author: John Wellbelove <john.wellbelove@etlcpp.com>
Date:   Sat Jul 11 12:32:20 2026 +0100

    Updated release notes

commit 4bf6ed6ce8d79857658d763e368ee56617542b2c
Author: vcoselev <145198867+vcoselev@users.noreply.github.com>
Date:   Sat Jul 11 12:05:39 2026 +0100

    Fix for 1405: etl::exchange doesn't work with unique_ptr (#1477)

    * Separate bit order and endianness in bit_stream.h (#1495)

    * Factor out ranges tests from test_algorithm.cpp to test_algorithm_ranges.cpp (#1497)

    * Fix exchange to use forwarding reference (U&&) and move

    - etl::exchange was using the copy constructor. Changed for etl::move.
    - The assignment to the new object is now done with forward.
    - Added a test with unique_ptr.

    ---------

    Co-authored-by: Roland Reichwein <Roland.Reichwein@bmw.de>
    Co-authored-by: John Wellbelove <jwellbelove@users.noreply.github.com>

commit 2ed9019df04d470530c41c1f27d35adc30b9a32d
Author: Moritz Pflanzer <moritz@pflanzer.eu>
Date:   Fri Jul 10 11:42:32 2026 +0200

    Update operator[] docs for map class (#1499)

    * Separate bit order and endianness in bit_stream.h (#1495)

    * Update operator[] docs for map class

    No const variant is implemented for the operator[].

    ---------

    Co-authored-by: Roland Reichwein <Roland.Reichwein@bmw.de>

commit 423e18d96dc645f1c733cb0d8ae6b675b9eb7e83
Author: Roland Reichwein <Roland.Reichwein@bmw.de>
Date:   Fri Jul 10 11:14:08 2026 +0200

    Factor out ranges tests from test_algorithm.cpp to test_algorithm_ranges.cpp (#1497)

commit 338bfdbb1f4df3c5c08a68a9038f13b8dae1c28b
Author: John Wellbelove <jwellbelove@users.noreply.github.com>
Date:   Fri Jul 10 10:12:04 2026 +0100

    Add coverage report to docs (#1498)

    * Updated release notes

    * Added link to coverage report

    ---------

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

commit 269025424f4c6f61cebac090f4df82985fb3b239
Merge: c004cc9d faa4c15b
Author: John Wellbelove <john.wellbelove@etlcpp.com>
Date:   Thu Jul 9 14:18:32 2026 +0100

    Merge branch 'development' of https://github.com/ETLCPP/etl into development

commit c004cc9d508efcf398630758a47aae95b37a7eb8
Author: John Wellbelove <john.wellbelove@etlcpp.com>
Date:   Thu Jul 9 10:06:17 2026 +0100

    Updated release notes

commit faa4c15b49c8ad15475c83ae23e00f5a46f803ca
Author: John Wellbelove <john.wellbelove@etlcpp.com>
Date:   Thu Jul 9 10:06:17 2026 +0100

    Updated release notes

commit 1523e63e35a15cfd1fa72d230a3c79efa7b9c3e0
Author: Roland Reichwein <Roland.Reichwein@bmw.de>
Date:   Wed Jul 8 20:48:33 2026 +0200

    Support non-assignable alternatives in variant (#1496)

commit 878a0ba5a28f6b0dcae9f472a6a6a1f107de0a74
Author: John Wellbelove <john.wellbelove@etlcpp.com>
Date:   Wed Jul 8 11:07:01 2026 +0100

    Updated version and release notes

commit 5287fe4b3b9f58330881d2a62abf6ce8e1159b8d
Author: John Wellbelove <jwellbelove@users.noreply.github.com>
Date:   Wed Jul 8 09:06:50 2026 +0100

    Allow etl::vector to store pointers to functions and member functions (#1492)

    * Refactored vector.h

    Deleted ivectorpointer.h

    * Minor changes

    * Fixed code incompatible with C++03

    * Clang-format changes

    * Removed redundant double-qualified name

    * Fixed is_is_object_pointer_v to is_object_pointer_v

    * Added new test files to meson.build

    * Added overflow checks to vector_ext copy and move constructors and assignments

    Added assert throw tests.

    * Added diagnostic pushes to eliminate GCC warning false positives

    * Changed the GCC C++23 Github action to use GCC14

    * Applied clang-format

    * Added guard to pop_heap

    * Added guard to adjust_heap

    * Attempt to fix GCC diagnostic

    * Attempt to fix GCC diagnostic

    Re-enable ranges algorithm tests

    * Attempt to fix GCC diagnostic

    Re-enable ranges algorithm tests

    * clang-format

    * Attempt to fix GCC diagnostic

    Re-enable ranges algorithm tests

    * Attempt to fix GCC diagnostic

    Re-enable ranges algorithm tests

    * Attempt to fix GCC diagnostic

    Re-enable ranges algorithm tests

    * Missing newline at end of file

    * Attempt to fix GCC diagnostic

    Re-enable ranges algorithm tests

    * Attempt to fix GCC diagnostic

    Re-enable ranges algorithm tests

    * Attempt to fix GCC diagnostic

    Re-enable ranges algorithm tests

    * Attempt to fix GCC diagnostic

    Re-enable ranges algorithm tests

    * Attempt to fix GCC diagnostic

    * clang-format

    * Changed gcc --version to gcc-14 --version

    ---------

    Co-authored-by: John Wellbelove <john.wellbelove@etlcpp.com>
    Co-authored-by: Roland Reichwein <Roland.Reichwein@bmw.de>

commit 40dddd7f9601985ae7350e60a404af9028bc9fe9
Author: Roland Reichwein <Roland.Reichwein@bmw.de>
Date:   Tue Jul 7 23:41:17 2026 +0200

    Add optional etl_profile label_flag for Bazel profile injection (#1491)

    Co-authored-by: John Wellbelove <jwellbelove@users.noreply.github.com>

commit 84fca4cd62f72c382c062376ca934803116a20d5
Author: Roland Reichwein <Roland.Reichwein@bmw.de>
Date:   Tue Jul 7 21:45:47 2026 +0200

    Add missing memory functions, according the standard (#1490)

    Adding:

    - etl::align
    - etl::assume_aligned
    - etl::is_sufficiently_aligned
    - etl::launder
    - etl::pointer_traits
    - etl::start_lifetime_as

    Co-authored-by: John Wellbelove <jwellbelove@users.noreply.github.com>

commit dca6653b3759b2cdc79307fec7425589feea478d
Author: Roland Reichwein <Roland.Reichwein@bmw.de>
Date:   Tue Jul 7 21:00:09 2026 +0200

    Add missing interfaces to etl::chrono (#1489)

    Co-authored-by: John Wellbelove <jwellbelove@users.noreply.github.com>

commit c52b2ac7b1f675e6b1d34052239423b7f3634033
Author: Roland Reichwein <Roland.Reichwein@bmw.de>
Date:   Tue Jul 7 18:06:05 2026 +0200

    Fix etl::mem_cast cross-size copy constructor and assignment (#1488)

    The templated cross-size copy constructor and assignment operator were
    broken in two ways:

    - They accessed other.buffer / rhs.buffer, which is private in a
      different mem_cast instantiation, so the cross-size overloads failed
      to compile whenever they were actually instantiated.
    - They copied Size_ (the destination size) bytes from a source buffer
      that is only Other_Size bytes large, reading past the end of the
      source when the destination was larger.

    Use the public data() accessor and copy Other_Size bytes. The existing
    static_assert(Size >= Other_Size) guarantees the destination is big
    enough.

    Add test_mem_cast_copy_and_assign_from_smaller regression test.

    Co-authored-by: John Wellbelove <jwellbelove@users.noreply.github.com>

commit 165674cb23dda1fd4f7e5a1182f49554a796bfe8
Author: Roland Reichwein <Roland.Reichwein@bmw.de>
Date:   Tue Jul 7 16:41:50 2026 +0200

    Fix etl::pearson::reset() not resetting the first-byte flag (#1487)

    reset() cleared the hash array but left the `first` flag false, so a
    calculator reused after reset() took the XOR update path on its next
    add() instead of the initialisation path. This produced an incorrect
    hash for any pearson object that was reset and reused.

    Reset `first` to true in reset() so a reset calculator behaves like a
    freshly constructed one.

    Add test_pearson_reset regression test.

    Co-authored-by: John Wellbelove <jwellbelove@users.noreply.github.com>

commit 032ec4cc80f1c0f1baa0383bdbc5f9239b68f268
Author: Roland Reichwein <Roland.Reichwein@bmw.de>
Date:   Tue Jul 7 13:40:04 2026 +0200

    Fix etl::bitset single-element from_string shift on empty string (#1486)

    The single-element from_string overloads (char, wchar_t, char16_t,
    char32_t) computed element_type(1) << (string_length - 1U) before the
    copy loop. For an empty string, or when active_bits is 0, string_length
    is 0, so the shift count underflows to SIZE_MAX. Shifting by more than
    the element width is undefined behaviour, which also breaks constexpr
    evaluation.

    Guard the mask with a zero-length check so the shift is only performed
    when string_length > 0. The multi-element from_string overloads were
    already safe.

    Add test_construct_from_empty_string regression test.

    Co-authored-by: John Wellbelove <jwellbelove@users.noreply.github.com>

commit 98cb365d4c28e7b72f8547b734a03a4068acd3f5
Author: Roland Reichwein <Roland.Reichwein@bmw.de>
Date:   Tue Jul 7 12:32:56 2026 +0200

    Fix etl::histogram copy/move not preserving start_index (#1485)

    The run-time-offset specialization of etl::histogram stores a start_index
    member used to map keys to bins (accumulator[key - start_index]). Its copy
    constructor, move constructor, copy assignment, and move assignment copied
    only the accumulator and left start_index uninitialized, so a copied or
    moved histogram indexed the wrong bin in operator[]/add(), causing
    out-of-bounds access (undefined behavior).

    All four special member functions now also copy start_index. The
    compile-time-offset specialization is unaffected, as its start index is a
    template constant rather than a data member.

    Add regression tests covering copy/move construction and assignment.

    Co-authored-by: John Wellbelove <jwellbelove@users.noreply.github.com>

commit 5cd2f28cd54e4019f7be126bcf7394a6a8318eb9
Author: Drew Rife <darife@jlg.com>
Date:   Tue Jul 7 03:14:48 2026 -0400

    Refactor variant::emplace to perfect forward args instead of copy/move construct (#1494)

    * refactor: emplace logic to use do_emplace for in-place construction with forwarded arguments #1493

    * Add test for variant_variadic

    ---------

    Co-authored-by: Roland Reichwein <Roland.Reichwein@bmw.de>

commit a47c0aae81b886259918961d5fcee20faa06fdd0
Author: Roland Reichwein <Roland.Reichwein@bmw.de>
Date:   Mon Jul 6 17:32:26 2026 +0200

    Fix etl::message_timer firing following timers early on unregister (#1484)

    active_list.remove(id, has_expired) adjusts the next timer's delta only
    when has_expired is false. When unregistering an active, non-expired timer,
    unregister_timer() incorrectly passed true, skipping that adjustment, so
    every timer after the removed one in the active list fired early by the
    removed timer's delta.

    Pass false instead, matching the etl::callback_timer family. tick() still
    passes true, since the timer has genuinely expired there. The bug affected
    all four variants: message_timer, message_timer_interrupt,
    message_timer_atomic and message_timer_locked. Existing tests missed it
    because they only ever unregistered the tail timer, where the delta
    adjustment is a no-op.

    Add a regression test that unregisters a non-tail active timer and checks
    the following timer still fires at its original absolute time.
This commit is contained in:
John Wellbelove 2026-07-11 13:02:42 +01:00
parent c707428cc4
commit afa17c5042
60 changed files with 7767 additions and 1569 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -21,10 +21,10 @@ jobs:
- name: Build
run: |
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
export CC=gcc
export CXX=g++
export CC=gcc-14
export CXX=g++-14
cmake -DBUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=23 -DETL_OPTIMISATION=-O3 ./
gcc --version
gcc-14 --version
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
@ -43,10 +43,10 @@ jobs:
- name: Build
run: |
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
export CC=gcc
export CXX=g++
export CC=gcc-14
export CXX=g++-14
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=23 -DETL_OPTIMISATION=-O3 ./
gcc --version
gcc-14 --version
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
@ -65,10 +65,10 @@ jobs:
- name: Build
run: |
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
export CC=gcc
export CXX=g++
export CC=gcc-14
export CXX=g++-14
cmake -DBUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=23 -DETL_OPTIMISATION=-O3 ./
gcc --version
gcc-14 --version
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
@ -87,10 +87,10 @@ jobs:
- name: Build
run: |
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
export CC=gcc
export CXX=g++
export CC=gcc-14
export CXX=g++-14
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=23 -DETL_OPTIMISATION=-O3 ./
gcc --version
gcc-14 --version
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests

27
BUILD.bazel
View File

@ -2,8 +2,35 @@ load("@rules_cc//cc:defs.bzl", "cc_library")
package(default_visibility = ["//visibility:public"])
# ETL can be tailored to a project through an `etl_profile.h` header (see
# `include/etl/platform.h`). When no such header is on the include path, ETL
# falls back to its built-in defaults via `ETL_NO_PROFILE_HEADER`.
#
# This label_flag lets a consumer inject that profile as a Bazel target, without
# patching this BUILD file:
#
# bazel build @etl//:etl --@etl//:etl_profile=//path/to:my_etl_profile
#
# The injected target is a cc_library that exposes a single `etl_profile.h` on
# its include path, for example:
#
# cc_library(
# name = "my_etl_profile",
# hdrs = ["etl_profile.h"],
# strip_include_prefix = ".",
# )
#
# The default is empty, so ETL's built-in defaults are used unless overridden.
label_flag(
name = "etl_profile",
build_setting_default = ":no_profile",
)
cc_library(name = "no_profile")
cc_library(
name = "etl",
hdrs = glob(["include/**/*.h"]),
includes = ["include"],
deps = [":etl_profile"],
)

2
arduino/library-arduino.json
View File

@ -1,6 +1,6 @@
{
"name": "Embedded Template Library ETL",
"version": "20.48.0",
"version": "20.48.1",
"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.48.0
version=20.48.1
author= John Wellbelove <john.wellbelove@etlcpp.com>
maintainer=John Wellbelove <john.wellbelove@etlcpp.com>
license=MIT

3
docs/_index.md
View File

@ -39,14 +39,13 @@ type: hextra-home
</div>
<div>
<a href="https://github.com/ETLCPP/etl/actions/workflows/coverage.yml"><img src="https://github.com/ETLCPP/etl/actions/workflows/coverage.yml/badge.svg" alt="coverage"></a>
<a href="https://etlcpp.github.io/etl/"><img src="https://github.com/ETLCPP/etl/actions/workflows/coverage.yml/badge.svg" alt="coverage"">
<a href="https://www.codacy.com/manual/jwellbelove/etl"><img src="https://api.codacy.com/project/badge/Grade/3c14cd918ccf40008d0bcd7b083d5946" alt="Codacy"></a>
</div>
<div>
<a href="https://www.etlcpp.com/sponsor.html"><img src="https://img.shields.io/static/v1?label=Sponsor&message=%E2%9D%A4&logo=GitHub&color=%23fe8e86" alt="Sponsor"></a>
</div>
</div>
## Version

45
docs/chrono/hh_mm_ss.md
View File

@ -136,3 +136,48 @@ ETL_NOEXCEPT
A specialisation of absolute for `etl::chrono::duration`.
**Return**
The absolute duration value.
## 12/24 hour functions
```cpp
ETL_NODISCARD
inline ETL_CONSTEXPR14
bool is_am(const etl::chrono::hours& h)
ETL_NOEXCEPT
```
**Description**
Returns `true` if `h` is in the range [0h, 11h] (an am hour).
---
```cpp
ETL_NODISCARD
inline ETL_CONSTEXPR14
bool is_pm(const etl::chrono::hours& h)
ETL_NOEXCEPT
```
**Description**
Returns `true` if `h` is in the range [12h, 23h] (a pm hour).
---
```cpp
ETL_NODISCARD
inline ETL_CONSTEXPR14
etl::chrono::hours make12(const etl::chrono::hours& h)
ETL_NOEXCEPT
```
**Description**
Returns the 12-hour equivalent of `h` in the range [1h, 12h].
If `h` is not in the range [0h, 23h], the value returned is unspecified.
---
```cpp
ETL_NODISCARD
inline ETL_CONSTEXPR14
etl::chrono::hours make24(const etl::chrono::hours& h, bool is_pm)
ETL_NOEXCEPT
```
**Description**
Returns the 24-hour equivalent of `h`, which is assumed to represent the hour with the indicated am/pm.
If `h` is not in the range [1h, 12h], the value returned is unspecified.

94
docs/chrono/time_point.md
View File

@ -100,6 +100,41 @@ ETL_NOEXCEPT
**Description**
Subtracts a duration.
## Increment/decrement
```cpp
ETL_CONSTEXPR14 time_point& operator ++()
ETL_NOEXCEPT
```
**Description**
Pre-increments the stored duration by one tick.
---
```cpp
ETL_CONSTEXPR14 time_point operator ++(int)
ETL_NOEXCEPT
```
**Description**
Post-increments the stored duration by one tick.
---
```cpp
ETL_CONSTEXPR14 time_point& operator --()
ETL_NOEXCEPT
```
**Description**
Pre-decrements the stored duration by one tick.
---
```cpp
ETL_CONSTEXPR14 time_point operator --(int)
ETL_NOEXCEPT
```
**Description**
Post-decrements the stored duration by one tick.
## Constants
```cpp
ETL_NODISCARD
@ -180,6 +215,65 @@ If time_point < other, returns -1
else if time_point > other, returns 1
else returns 0
## Non-member mathematical operators
```cpp
template <typename TClock, typename TDuration1, typename TRep2, typename TPeriod2>
ETL_CONSTEXPR14
etl::chrono::time_point<TClock, typename etl::common_type<TDuration1, etl::chrono::duration<TRep2, TPeriod2> >::type>
operator +(const time_point<TClock, TDuration1>& lhs,
const etl::chrono::duration<TRep2, TPeriod2>& rhs)
ETL_NOEXCEPT
```
**Description**
Adds a duration to a time_point.
**Return**
A time_point whose duration is the common type of the two.
---
```cpp
template <typename TRep1, typename TPeriod1, typename TClock, typename TDuration2>
ETL_CONSTEXPR14
etl::chrono::time_point<TClock, typename etl::common_type<etl::chrono::duration<TRep1, TPeriod1>, TDuration2>::type>
operator +(const etl::chrono::duration<TRep1, TPeriod1>& lhs,
const time_point<TClock, TDuration2>& rhs)
ETL_NOEXCEPT
```
**Description**
Adds a duration to a time_point.
**Return**
A time_point whose duration is the common type of the two.
---
```cpp
template <typename TClock, typename TDuration1, typename TRep2, typename TPeriod2>
ETL_CONSTEXPR14
etl::chrono::time_point<TClock, typename etl::common_type<TDuration1, etl::chrono::duration<TRep2, TPeriod2> >::type>
operator -(const time_point<TClock, TDuration1>& lhs,
const etl::chrono::duration<TRep2, TPeriod2>& rhs)
ETL_NOEXCEPT
```
**Description**
Subtracts a duration from a time_point.
**Return**
A time_point whose duration is the common type of the two.
---
```cpp
template <typename TClock, typename TDuration1, typename TDuration2>
ETL_CONSTEXPR14
typename etl::common_type<TDuration1, TDuration2>::type
operator -(const time_point<TClock, TDuration1>& lhs,
const time_point<TClock, TDuration2>& rhs)
ETL_NOEXCEPT
```
**Description**
Subtracts one time_point from another.
**Return**
The duration between them as the common type of the two durations.
## Non-member comparison operators
```cpp
template <typename TClock, typename TDuration1, typename TDuration2>

3
docs/containers/maps/map.md
View File

@ -96,10 +96,9 @@ If assert or exceptions are not enabled then undefined behaviour occurs.
```cpp
TMapped& operator[](key_parameter_t key)
const TMapped& operator[](key_parameter_t key) const
```
**Description**
Returns a reference or const reference to the indexed element.
Returns a reference to the indexed element.
If the key does not exist then one is created using the default constructor.
If the map is full then asserts an `etl::map_full`. If asserts or exceptions are not enabled then undefined behaviour occurs.

18
docs/releases/_index.md
View File

@ -5,6 +5,24 @@ weight: 2002
Click on the links to see the original Github page.
## 20.48.1
**Pull requests:**
[#1477](https://github.com/ETLCPP/etl/pull/1477) Fix for 1405: etl::exchange doesn't work with unique_ptr
[#1484](https://github.com/ETLCPP/etl/pull/1484) Fix `etl::message_timer` firing following timers early on unregister
[#1485](https://github.com/ETLCPP/etl/pull/1485) Fix `etl::histogram` copy/move not preserving start_index
[#1486](https://github.com/ETLCPP/etl/pull/1486) Fix `etl::bitset` single-element `from_string` shift on empty string
[#1487](https://github.com/ETLCPP/etl/pull/1487) Fix `etl::pearson::reset()` not resetting the first-byte flag
[#1488](https://github.com/ETLCPP/etl/pull/1488) Fix `etl::mem_cast` cross-size copy constructor and assignment
[#1489](https://github.com/ETLCPP/etl/pull/1489) Add missing interfaces to `etl::chrono`
[#1490](https://github.com/ETLCPP/etl/pull/1490) Add missing memory functions, according the standard
[#1491](https://github.com/ETLCPP/etl/pull/1491) Add optional `etl_profile` `label_flag` for Bazel profile injection
[#1492](https://github.com/ETLCPP/etl/pull/1492) Allow `etl::vector` to store pointers to functions and member functions
[#1494](https://github.com/ETLCPP/etl/pull/1494) Refactor `variant::emplace` to perfect forward args instead of copy/move construct
[#1495](https://github.com/ETLCPP/etl/pull/1495) Separate bit order and endianness in `bit_stream.h`
[#1496](https://github.com/ETLCPP/etl/pull/1496) Fix non-assignable alternatives in variant
## 20.48.0
**Pull requests:**

34
docs/source/bazel.md
View File

@ -296,3 +296,37 @@ Then use them with `--config`:
```sh
bazel test //test:etl_tests --config=clang --config=c++20 --config=release
```
### Injecting a Custom Profile Header
Instead of passing many individual `--copt=-D...` flags, ETL can be configured in bulk through a user-provided `etl_profile.h` header. When such a header is reachable on the include path, `include/etl/platform.h` includes it automatically; otherwise ETL falls back to its built-in defaults (`ETL_NO_PROFILE_HEADER`).
Because the header must sit on ETL's include path, `BUILD.bazel` exposes an `etl_profile` [`label_flag`](https://bazel.build/extending/config) so you can inject it as a Bazel target — without patching ETL's `BUILD.bazel`.
First, wrap your profile header in a `cc_library` that places `etl_profile.h` on its include path:
```python
# path/to/BUILD.bazel
cc_library(
name = "my_etl_profile",
hdrs = ["etl_profile.h"],
strip_include_prefix = ".",
)
```
Then point the `etl_profile` flag at that target when building:
```sh
bazel build @etl//:etl --@etl//:etl_profile=//path/to:my_etl_profile
```
The flag defaults to an empty library (`:no_profile`), so ETL uses its built-in defaults unless you override it. As with any flag, the override can be made permanent in `.bazelrc`:
```
# .bazelrc
build --@etl//:etl_profile=//path/to:my_etl_profile
```
> **Note:** Use the repository-qualified form `--@etl//:etl_profile=...` when consuming ETL as an
> external dependency. When building from within the ETL repository itself, drop the repository
> prefix: `--//:etl_profile=...`.

19
docs/types/type-traits.md
View File

@ -3,7 +3,7 @@ title: "type_traits"
---
Reverse engineered types traits classes from C++11 plus several ETL extensions.
This file is generated from type_traits_generator.h. See Generators
This file is generated from `type_traits_generator.h`. See Generators
Not all traits have been defined as some rely on compiler intrinsics that are not available on all compiler platforms.
`integral_constant`
@ -459,3 +459,20 @@ template <typename T, template <typename...> class Template>
inline constexpr bool is_specialization_v = etl::is_specialization<T, Template>::value;
```
C++17
## is_object_pointer
From: `20.49.0`
```cpp
template <typename T>
struct is_object_pointer
```
Checks if `T` is a pointer to an object.
Pointers to functions and member functions return `false`.
The result is found in the member `value`.
```cpp
template <typename T>
inline constexpr bool is_object_pointer_v = etl::is_object_pointer<T>::value;
```
C++17

2
hugo/assets/version.txt
View File

@ -1 +1 @@
20.48.0
20.48.1

19
include/etl/algorithm.h
View File

@ -914,6 +914,7 @@ namespace etl
TDistance top_index = value_index;
TDistance child2nd = (2 * value_index) + 2;
#include "etl/private/diagnostic_array_bounds_push.h"
while (child2nd < length)
{
if (compare(*(first + child2nd), *(first + (child2nd - 1))))
@ -931,6 +932,7 @@ namespace etl
*(first + value_index) = ETL_MOVE(*(first + (child2nd - 1)));
value_index = child2nd - 1;
}
#include "etl/private/diagnostic_pop.h"
push_heap(first, value_index, top_index, ETL_MOVE(value), compare);
}
@ -965,6 +967,12 @@ namespace etl
typedef typename etl::iterator_traits<TIterator>::value_type value_t;
typedef typename etl::iterator_traits<TIterator>::difference_type distance_t;
const distance_t n = last - first;
if (n <= 1)
{
return;
}
value_t value = ETL_MOVE(*(last - 1));
*(last - 1) = ETL_MOVE(*first);
@ -5844,6 +5852,8 @@ namespace etl
{
ETL_STATIC_ASSERT(etl::is_random_access_iterator<I>::value, "partial_sort requires random access iterators");
#include "etl/private/diagnostic_array_bounds_push.h"
I last_it = ranges::next(first, last);
if (first == middle || first == last_it)
@ -5880,6 +5890,8 @@ namespace etl
}
return last_it;
#include "etl/private/diagnostic_pop.h"
}
template <class R, class Comp = ranges::less, class Proj = etl::identity, typename = etl::enable_if_t<etl::is_range_v<R>>>
@ -5933,6 +5945,8 @@ namespace etl
{
ETL_STATIC_ASSERT(etl::is_random_access_iterator<I2>::value, "partial_sort_copy requires the output to be random access iterators");
#include "etl/private/diagnostic_array_bounds_push.h"
I1 in_last = ranges::next(first, last);
I2 out_last = ranges::next(result_first, result_last);
@ -5970,7 +5984,6 @@ namespace etl
}
}
#include "etl/private/diagnostic_array_bounds_push.h"
// Sort the heap to produce a sorted output range
for (auto heap_end = heap_size - 1; heap_end > 0; --heap_end)
{
@ -7025,6 +7038,8 @@ namespace etl
{
ETL_STATIC_ASSERT(etl::is_random_access_iterator<I>::value, "pop_heap requires random access iterators");
#include "etl/private/diagnostic_array_bounds_push.h"
I last_it = ranges::next(first, last);
auto length = etl::distance(first, last_it);
@ -7041,6 +7056,8 @@ namespace etl
sift_down(first, decltype(length)(0), etl::distance(first, last_it), comp, proj);
return ranges::next(first, last);
#include "etl/private/diagnostic_pop.h"
}
template <class R, class Comp = ranges::less, class Proj = etl::identity, typename = etl::enable_if_t<etl::is_range_v<R>>>

4
include/etl/histogram.h
View File

@ -296,6 +296,7 @@ namespace etl
histogram(const histogram& other)
{
this->accumulator = other.accumulator;
start_index = other.start_index;
}
#if ETL_USING_CPP11
@ -305,6 +306,7 @@ namespace etl
histogram(histogram&& other)
{
this->accumulator = etl::move(other.accumulator);
start_index = other.start_index;
}
#endif
@ -314,6 +316,7 @@ namespace etl
histogram& operator=(const histogram& rhs)
{
this->accumulator = rhs.accumulator;
start_index = rhs.start_index;
return *this;
}
@ -325,6 +328,7 @@ namespace etl
histogram& operator=(histogram&& rhs)
{
this->accumulator = etl::move(rhs.accumulator);
start_index = rhs.start_index;
return *this;
}

2
include/etl/intrusive_avl_tree.h
View File

@ -227,11 +227,13 @@ namespace etl
return ETL_NULLPTR == base::etl_parent;
}
#include "private/diagnostic_null_dereference_push.h"
ETL_NODISCARD
link_type* get_parent()
{
return static_cast<link_type*>(base::etl_parent);
}
#include "private/diagnostic_pop.h"
ETL_NODISCARD
const link_type* get_parent() const

4
include/etl/mem_cast.h
View File

@ -115,7 +115,7 @@ namespace etl
{
ETL_STATIC_ASSERT(Size >= Other_Size, "Other size is too large");
memcpy(buffer, other.buffer, Size_);
memcpy(buffer, other.data(), Other_Size);
}
//***********************************
@ -126,7 +126,7 @@ namespace etl
{
ETL_STATIC_ASSERT(Size >= Other_Size, "RHS size is too large");
memcpy(buffer, rhs.buffer, Size_);
memcpy(buffer, rhs.data(), Other_Size);
return *this;
}

317
include/etl/memory.h
View File

@ -74,6 +74,323 @@ namespace etl
return etl::to_address(itr.operator->());
}
#if ETL_USING_STL && ETL_USING_CPP17 && defined(__cpp_lib_launder)
using std::launder;
#else
//*****************************************************************************
/// Obtains a pointer to the object created in the storage pointed to by p.
/// Prevents the compiler from making invalid assumptions when the lifetime of
/// an object has ended and a new object has been created in the same storage.
/// T must not be a function type nor a (possibly cv-qualified) void type.
/// https://en.cppreference.com/w/cpp/utility/launder
///\ingroup memory
//*****************************************************************************
template <typename T>
ETL_NODISCARD ETL_CONSTEXPR17 T* launder(T* p) ETL_NOEXCEPT
{
#if ETL_USING_CPP11
// etl::is_function is only defined for C++11 and later.
ETL_STATIC_ASSERT(!etl::is_function<T>::value, "etl::launder argument must not be a function type");
#endif
ETL_STATIC_ASSERT(!etl::is_void<T>::value, "etl::launder argument must not be a void type");
#if defined(__has_builtin) && !defined(ETL_COMPILER_MICROSOFT)
#if __has_builtin(__builtin_launder)
return __builtin_launder(p);
#else
return p;
#endif
#elif ETL_USING_GCC_COMPILER && (ETL_COMPILER_FULL_VERSION >= 70000)
// GCC 7, 8 and 9 provide __builtin_launder but not __has_builtin.
return __builtin_launder(p);
#else
return p;
#endif
}
#endif
#if ETL_USING_STL && ETL_USING_CPP23 && defined(__cpp_lib_start_lifetime_as)
using std::start_lifetime_as;
using std::start_lifetime_as_array;
#else
namespace private_memory
{
//*************************************************************************
/// Implicitly create the objects in [p, p + n) and return a usable pointer
/// to the first one. Used by start_lifetime_as / start_lifetime_as_array.
//*************************************************************************
template <typename T>
ETL_NODISCARD
inline T* start_lifetime_as_impl(void* p, size_t n) ETL_NOEXCEPT
{
if (n == 0U)
{
// No objects are created, so there is nothing to launder.
// Return the original pointer to preserve pointer identity.
return static_cast<T*>(p);
}
#if ETL_USING_BUILTIN_MEMMOVE
void* const q = __builtin_memmove(p, p, sizeof(T) * n);
#else
void* const q = ::memmove(p, p, sizeof(T) * n);
#endif
return etl::launder(static_cast<T*>(q));
}
} // namespace private_memory
//*****************************************************************************
/// Implicitly creates an object of type T in the storage pointed to by p and
/// starts its lifetime. T must be a trivially copyable (implicit-lifetime)
/// type. The storage must be suitably sized and aligned for T.
/// https://en.cppreference.com/w/cpp/memory/start_lifetime_as
///\ingroup memory
//*****************************************************************************
template <typename T>
ETL_NODISCARD
T* start_lifetime_as(void* p) ETL_NOEXCEPT
{
ETL_STATIC_ASSERT(etl::is_trivially_copyable<T>::value, "T must be trivially copyable");
return etl::private_memory::start_lifetime_as_impl<T>(p, 1U);
}
template <typename T>
ETL_NODISCARD
const T* start_lifetime_as(const void* p) ETL_NOEXCEPT
{
ETL_STATIC_ASSERT(etl::is_trivially_copyable<T>::value, "T must be trivially copyable");
return etl::private_memory::start_lifetime_as_impl<const T>(const_cast<void*>(p), 1U);
}
template <typename T>
ETL_NODISCARD
volatile T* start_lifetime_as(volatile void* p) ETL_NOEXCEPT
{
ETL_STATIC_ASSERT(etl::is_trivially_copyable<T>::value, "T must be trivially copyable");
return etl::private_memory::start_lifetime_as_impl<volatile T>(const_cast<void*>(p), 1U);
}
template <typename T>
ETL_NODISCARD
const volatile T* start_lifetime_as(const volatile void* p) ETL_NOEXCEPT
{
ETL_STATIC_ASSERT(etl::is_trivially_copyable<T>::value, "T must be trivially copyable");
return etl::private_memory::start_lifetime_as_impl<const volatile T>(const_cast<void*>(p), 1U);
}
//*****************************************************************************
/// Implicitly creates an array of n objects of type T in the storage pointed
/// to by p and starts their lifetimes. T must be a trivially copyable
/// (implicit-lifetime) type. Returns a pointer to the first element, or a
/// pointer comparing equal to p when n is zero.
/// https://en.cppreference.com/w/cpp/memory/start_lifetime_as
///\ingroup memory
//*****************************************************************************
template <typename T>
ETL_NODISCARD
T* start_lifetime_as_array(void* p, size_t n) ETL_NOEXCEPT
{
ETL_STATIC_ASSERT(etl::is_trivially_copyable<T>::value, "T must be trivially copyable");
return etl::private_memory::start_lifetime_as_impl<T>(p, n);
}
template <typename T>
ETL_NODISCARD
const T* start_lifetime_as_array(const void* p, size_t n) ETL_NOEXCEPT
{
ETL_STATIC_ASSERT(etl::is_trivially_copyable<T>::value, "T must be trivially copyable");
return etl::private_memory::start_lifetime_as_impl<const T>(const_cast<void*>(p), n);
}
template <typename T>
ETL_NODISCARD
volatile T* start_lifetime_as_array(volatile void* p, size_t n) ETL_NOEXCEPT
{
ETL_STATIC_ASSERT(etl::is_trivially_copyable<T>::value, "T must be trivially copyable");
return etl::private_memory::start_lifetime_as_impl<volatile T>(const_cast<void*>(p), n);
}
template <typename T>
ETL_NODISCARD
const volatile T* start_lifetime_as_array(const volatile void* p, size_t n) ETL_NOEXCEPT
{
ETL_STATIC_ASSERT(etl::is_trivially_copyable<T>::value, "T must be trivially copyable");
return etl::private_memory::start_lifetime_as_impl<const volatile T>(const_cast<void*>(p), n);
}
#endif
#if ETL_USING_STL && ETL_USING_CPP11
using std::pointer_traits;
#else
#if ETL_USING_CPP11
namespace private_memory
{
//*************************************************************************
/// Decomposes a pointer-like class template of the form
/// Pointer<Element, Args...> to recover its first template parameter and
/// to rebind it to a different first parameter. Left undefined for types
/// that are not such a template instantiation.
//*************************************************************************
template <typename T>
struct pointer_traits_template;
template <template <typename, typename...> class Pointer, typename Element, typename... Args>
struct pointer_traits_template<Pointer<Element, Args...> >
{
typedef Element type;
template <typename U>
struct rebind
{
typedef Pointer<U, Args...> type;
};
};
//*************************************************************************
/// Deduces the element_type of a pointer-like type. Prefers a nested
/// T::element_type, otherwise falls back to the first template parameter.
//*************************************************************************
template <typename T, typename = void>
struct pointer_traits_element_type
{
typedef typename pointer_traits_template<T>::type type;
};
template <typename T>
struct pointer_traits_element_type<T, etl::void_t<typename T::element_type> >
{
typedef typename T::element_type type;
};
} // namespace private_memory
#endif
//*****************************************************************************
/// Provides information about pointer-like types. General case where the
/// type itself models the pointer (fancy / smart pointers).
/// https://en.cppreference.com/w/cpp/memory/pointer_traits
///\ingroup memory
//*****************************************************************************
template <typename T>
struct pointer_traits
{
typedef T pointer;
#if ETL_USING_CPP11
typedef typename private_memory::pointer_traits_element_type<T>::type element_type;
#else
typedef typename T::element_type element_type;
#endif
typedef ptrdiff_t difference_type;
#if ETL_USING_CPP11
template <typename U>
using rebind = typename private_memory::pointer_traits_template<T>::template rebind<U>::type;
#endif
ETL_NODISCARD
static ETL_CONSTEXPR pointer pointer_to(element_type& r) ETL_NOEXCEPT
{
return T::pointer_to(r);
}
};
//*****************************************************************************
/// Provides information about pointer-like types. Raw pointer specialisation.
/// https://en.cppreference.com/w/cpp/memory/pointer_traits
///\ingroup memory
//*****************************************************************************
template <typename T>
struct pointer_traits<T*>
{
typedef T* pointer;
typedef T element_type;
typedef ptrdiff_t difference_type;
#if ETL_USING_CPP11
template <typename U>
using rebind = U*;
#endif
ETL_NODISCARD
static ETL_CONSTEXPR pointer pointer_to(element_type& r) ETL_NOEXCEPT
{
return etl::addressof(r);
}
};
#endif
#if ETL_USING_STL && ETL_USING_CPP11
using std::align;
#else
//*****************************************************************************
/// Aligns a pointer within a buffer. Advances 'ptr' to the next address with
/// the given 'alignment' that can hold 'size' bytes within 'space' bytes,
/// shrinking 'space' by the consumed padding. Returns the aligned pointer, or
/// ETL_NULLPTR when the buffer is too small. 'alignment' must be a power of 2;
/// the behaviour is undefined if it is not.
/// https://en.cppreference.com/w/cpp/memory/align
///\ingroup memory
//*****************************************************************************
inline void* align(size_t alignment, size_t size, void*& ptr, size_t& space) ETL_NOEXCEPT
{
const uintptr_t p = reinterpret_cast<uintptr_t>(ptr);
const uintptr_t aligned = (p + (alignment - 1U)) & ~(static_cast<uintptr_t>(alignment) - 1U);
const size_t padding = static_cast<size_t>(aligned - p);
if ((padding > space) || (size > (space - padding)))
{
return ETL_NULLPTR;
}
space -= padding;
ptr = reinterpret_cast<void*>(aligned);
return ptr;
}
#endif
#if ETL_USING_STL && ETL_USING_CPP20 && defined(__cpp_lib_assume_aligned)
using std::assume_aligned;
#else
//*****************************************************************************
/// Informs the compiler that the pointer 'ptr' is aligned to at least N bytes
/// and returns it. N must be a power of 2. Behaviour is undefined if 'ptr' is
/// not actually aligned to N.
/// https://en.cppreference.com/w/cpp/memory/assume_aligned
///\ingroup memory
//*****************************************************************************
template <size_t N, typename T>
ETL_NODISCARD ETL_CONSTEXPR T* assume_aligned(T* ptr) ETL_NOEXCEPT
{
#if defined(__has_builtin) && !defined(ETL_COMPILER_MICROSOFT)
#if __has_builtin(__builtin_assume_aligned)
return static_cast<T*>(__builtin_assume_aligned(ptr, N));
#else
return ptr;
#endif
#else
return ptr;
#endif
}
#endif
#if ETL_USING_STL && ETL_USING_CPP26 && defined(__cpp_lib_is_sufficiently_aligned)
using std::is_sufficiently_aligned;
#else
//*****************************************************************************
/// Checks whether 'ptr' is aligned to at least Alignment bytes.
/// Alignment must be a power of 2.
/// https://en.cppreference.com/w/cpp/memory/is_sufficiently_aligned
///\ingroup memory
//*****************************************************************************
template <size_t Alignment, typename T>
ETL_NODISCARD
bool is_sufficiently_aligned(T* ptr) ETL_NOEXCEPT
{
return (reinterpret_cast<uintptr_t>(ptr) % Alignment) == 0U;
}
#endif
#if ETL_USING_STL
//*****************************************************************************
/// Fills uninitialised memory range with a value.

2
include/etl/message_timer.h
View File

@ -379,7 +379,7 @@ namespace etl
if (timer.is_active())
{
ETL_DISABLE_TIMER_UPDATES;
active_list.remove(timer.id, true);
active_list.remove(timer.id, false);
remove_callback.call_if(timer.id);
ETL_ENABLE_TIMER_UPDATES;
}

2
include/etl/message_timer_atomic.h
View File

@ -108,7 +108,7 @@ namespace etl
if (timer.is_active())
{
++process_semaphore;
active_list.remove(timer.id, true);
active_list.remove(timer.id, false);
remove_callback.call_if(timer.id);
--process_semaphore;
}

2
include/etl/message_timer_interrupt.h
View File

@ -114,7 +114,7 @@ namespace etl
TInterruptGuard guard;
(void)guard; // Silence 'unused variable warnings.
active_list.remove(timer.id, true);
active_list.remove(timer.id, false);
remove_callback.call_if(timer.id);
}

2
include/etl/message_timer_locked.h
View File

@ -111,7 +111,7 @@ namespace etl
if (timer.is_active())
{
lock();
active_list.remove(timer.id, true);
active_list.remove(timer.id, false);
remove_callback.call_if(timer.id);
unlock();
}

1
include/etl/pearson.h
View File

@ -93,6 +93,7 @@ namespace etl
void reset()
{
hash.fill(0);
first = true;
}
//*************************************************************************

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

@ -311,6 +311,11 @@ namespace etl
// Build from the string.
string_length = etl::min(active_bits, string_length);
if (string_length == 0U)
{
return;
}
element_type mask = element_type(element_type(1) << (string_length - 1U));
for (size_t i = 0U; i < string_length; ++i)
@ -339,6 +344,11 @@ namespace etl
// Build from the string.
string_length = etl::min(active_bits, string_length);
if (string_length == 0U)
{
return;
}
element_type mask = element_type(element_type(1) << (string_length - 1U));
for (size_t i = 0U; i < string_length; ++i)
@ -367,6 +377,11 @@ namespace etl
// Build from the string.
string_length = etl::min(active_bits, string_length);
if (string_length == 0U)
{
return;
}
element_type mask = element_type(element_type(1) << (string_length - 1U));
for (size_t i = 0U; i < string_length; ++i)
@ -395,6 +410,11 @@ namespace etl
// Build from the string.
string_length = etl::min(active_bits, string_length);
if (string_length == 0U)
{
return;
}
element_type mask = element_type(element_type(1) << (string_length - 1U));
for (size_t i = 0U; i < string_length; ++i)

59
include/etl/private/chrono/hh_mm_ss.h
View File

@ -184,5 +184,64 @@ namespace etl
template <typename TDuration>
constexpr int etl::chrono::hh_mm_ss<TDuration>::fractional_width;
//***********************************************************************
/// 12/24 hours functions
//***********************************************************************
//***********************************************************************
/// Returns true if h is in the range [0h, 11h] (an am hour).
//***********************************************************************
ETL_NODISCARD
inline ETL_CONSTEXPR14 bool is_am(const etl::chrono::hours& h) ETL_NOEXCEPT
{
return (h >= etl::chrono::hours(0)) && (h <= etl::chrono::hours(11));
}
//***********************************************************************
/// Returns true if h is in the range [12h, 23h] (a pm hour).
//***********************************************************************
ETL_NODISCARD
inline ETL_CONSTEXPR14 bool is_pm(const etl::chrono::hours& h) ETL_NOEXCEPT
{
return (h >= etl::chrono::hours(12)) && (h <= etl::chrono::hours(23));
}
//***********************************************************************
/// Returns the 12-hour equivalent of h in the range [1h, 12h].
/// If h is not in the range [0h, 23h], the value returned is unspecified.
//***********************************************************************
ETL_NODISCARD
inline ETL_CONSTEXPR14 etl::chrono::hours make12(const etl::chrono::hours& h) ETL_NOEXCEPT
{
if (h == etl::chrono::hours(0))
{
return etl::chrono::hours(12);
}
else if (h > etl::chrono::hours(12))
{
return h - etl::chrono::hours(12);
}
return h;
}
//***********************************************************************
/// Returns the 24-hour equivalent of h, which is assumed to represent the
/// hour with the indicated am/pm.
/// If h is not in the range [1h, 12h], the value returned is unspecified.
//***********************************************************************
ETL_NODISCARD
inline ETL_CONSTEXPR14 etl::chrono::hours make24(const etl::chrono::hours& h, bool is_pm) ETL_NOEXCEPT
{
if (is_pm)
{
return (h == etl::chrono::hours(12)) ? h : (h + etl::chrono::hours(12));
}
else
{
return (h == etl::chrono::hours(12)) ? etl::chrono::hours(0) : h;
}
}
} // namespace chrono
} // namespace etl

95
include/etl/private/chrono/time_point.h
View File

@ -122,6 +122,48 @@ namespace etl
return *this;
}
//***************************************************************************
/// Pre-increments the stored duration by one tick.
//***************************************************************************
ETL_CONSTEXPR14 time_point& operator++() ETL_NOEXCEPT
{
++dur;
return *this;
}
//***************************************************************************
/// Post-increments the stored duration by one tick.
//***************************************************************************
ETL_CONSTEXPR14 time_point operator++(int) ETL_NOEXCEPT
{
time_point temp(*this);
++dur;
return temp;
}
//***************************************************************************
/// Pre-decrements the stored duration by one tick.
//***************************************************************************
ETL_CONSTEXPR14 time_point& operator--() ETL_NOEXCEPT
{
--dur;
return *this;
}
//***************************************************************************
/// Post-decrements the stored duration by one tick.
//***************************************************************************
ETL_CONSTEXPR14 time_point operator--(int) ETL_NOEXCEPT
{
time_point temp(*this);
--dur;
return temp;
}
//***************************************************************************
/// Returns a time_point with the smallest possible duration.
//***************************************************************************
@ -200,6 +242,59 @@ namespace etl
return etl::chrono::time_point<TClock, TToDuration>(dur);
}
//***************************************************************************
/// Adds a duration to a time_point.
/// Returns a time_point whose duration is the common type of the two.
//***************************************************************************
template <typename TClock, typename TDuration1, typename TRep2, typename TPeriod2>
ETL_CONSTEXPR14 etl::chrono::time_point<TClock, typename etl::common_type<TDuration1, etl::chrono::duration<TRep2, TPeriod2> >::type>
operator+(const time_point<TClock, TDuration1>& lhs, const etl::chrono::duration<TRep2, TPeriod2>& rhs) ETL_NOEXCEPT
{
using common_duration = typename etl::common_type<TDuration1, etl::chrono::duration<TRep2, TPeriod2> >::type;
using result_time_point = etl::chrono::time_point<TClock, common_duration>;
return result_time_point(lhs.time_since_epoch() + rhs);
}
//***************************************************************************
/// Adds a time_point to a duration.
/// Returns a time_point whose duration is the common type of the two.
//***************************************************************************
template <typename TRep1, typename TPeriod1, typename TClock, typename TDuration2>
ETL_CONSTEXPR14 etl::chrono::time_point<TClock, typename etl::common_type<etl::chrono::duration<TRep1, TPeriod1>, TDuration2>::type>
operator+(const etl::chrono::duration<TRep1, TPeriod1>& lhs, const time_point<TClock, TDuration2>& rhs) ETL_NOEXCEPT
{
using common_duration = typename etl::common_type<etl::chrono::duration<TRep1, TPeriod1>, TDuration2>::type;
using result_time_point = etl::chrono::time_point<TClock, common_duration>;
return result_time_point(lhs + rhs.time_since_epoch());
}
//***************************************************************************
/// Subtracts a duration from a time_point.
/// Returns a time_point whose duration is the common type of the two.
//***************************************************************************
template <typename TClock, typename TDuration1, typename TRep2, typename TPeriod2>
ETL_CONSTEXPR14 etl::chrono::time_point<TClock, typename etl::common_type<TDuration1, etl::chrono::duration<TRep2, TPeriod2> >::type>
operator-(const time_point<TClock, TDuration1>& lhs, const etl::chrono::duration<TRep2, TPeriod2>& rhs) ETL_NOEXCEPT
{
using common_duration = typename etl::common_type<TDuration1, etl::chrono::duration<TRep2, TPeriod2> >::type;
using result_time_point = etl::chrono::time_point<TClock, common_duration>;
return result_time_point(lhs.time_since_epoch() - rhs);
}
//***************************************************************************
/// Subtracts one time_point from another.
/// Returns the duration between them as the common type of the two durations.
//***************************************************************************
template <typename TClock, typename TDuration1, typename TDuration2>
ETL_CONSTEXPR14 typename etl::common_type<TDuration1, TDuration2>::type operator-(const time_point<TClock, TDuration1>& lhs,
const time_point<TClock, TDuration2>& rhs) ETL_NOEXCEPT
{
return lhs.time_since_epoch() - rhs.time_since_epoch();
}
//***************************************************************************
/// Equality operator
//***************************************************************************

1140
include/etl/private/ivectorpointer.h
View File

File diff suppressed because it is too large Load Diff

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

@ -715,7 +715,7 @@ namespace etl
using type = etl::remove_cvref_t<T>;
do_destroy();
do_construct<type>(type(etl::forward<TArgs>(args)...));
do_emplace<type>(etl::forward<TArgs>(args)...);
type_id = index_of_type<T>::value;
@ -735,7 +735,7 @@ namespace etl
using type = etl::remove_cvref_t<T>;
do_destroy();
do_construct<type>(type(il, etl::forward<TArgs>(args)...));
do_emplace<type>(il, etl::forward<TArgs>(args)...);
type_id = index_of_type<T>::value;
@ -755,7 +755,7 @@ namespace etl
using type = type_from_index<Index>;
do_destroy();
do_construct<type>(type(etl::forward<TArgs>(args)...));
do_emplace<type>(etl::forward<TArgs>(args)...);
type_id = Index;
@ -775,7 +775,7 @@ namespace etl
using type = type_from_index<Index>;
do_destroy();
do_construct<type>(type(il, etl::forward<TArgs>(args)...));
do_emplace<type>(il, etl::forward<TArgs>(args)...);
type_id = Index;
@ -1096,6 +1096,32 @@ namespace etl
private_variant::variant_operations<0, TTypes...>::destroy(data, type_id);
}
//***************************************************************************
/// Emplace-construct the alternative in place from forwarded args.
/// No temporary, so no move/copy is required (works for move-hostile types).
//***************************************************************************
template <typename T, typename... TArgs>
void do_emplace(TArgs&&... args)
{
do_emplace_impl<T>(etl::integral_constant<bool, Is_Trivially_Destructible_Suite>{}, etl::forward<TArgs>(args)...);
}
// Trivially destructible suite: storage is a variadic_union. The old member is
// trivially destructible, so placement-new of the new member is well-defined at
// runtime (emplace is not constexpr, so placement-new is permitted here).
template <typename T, typename... TArgs>
void do_emplace_impl(etl::integral_constant<bool, true>, TArgs&&... args)
{
::new (static_cast<void*>(etl::addressof(private_variant::variadic_union_get<index_of_type<T>::value>(data)))) T(etl::forward<TArgs>(args)...);
}
// Non-trivially destructible suite: storage is an uninitialized_buffer.
template <typename T, typename... TArgs>
void do_emplace_impl(etl::integral_constant<bool, false>, TArgs&&... args)
{
::new (static_cast<char*>(data)) T(etl::forward<TArgs>(args)...);
}
//***************************************************************************
/// Construct a value in the union or buffer storage.
//***************************************************************************
@ -1108,8 +1134,12 @@ namespace etl
template <typename T, typename U>
void do_construct_impl(U&& value, etl::integral_constant<bool, true>)
{
// Trivially destructible: assign directly into the variadic_union.
private_variant::variadic_union_get<index_of_type<T>::value>(data) = etl::forward<U>(value);
// Begin the lifetime of the new alternative via placement new. The target
// union member is not alive after do_destroy(), and the alternative may be
// non-assignable (e.g. reference or const members), so assignment would be
// both undefined behaviour and ill-formed for such types. Use etl::addressof
// so the raw storage address is used even for types that overload operator&.
::new (static_cast<void*>(etl::addressof(private_variant::variadic_union_get<index_of_type<T>::value>(data)))) T(etl::forward<U>(value));
}
template <typename T, typename U>

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

@ -167,6 +167,15 @@ SOFTWARE.
#endif
#endif
#if defined(ETL_COMPILER_MICROSOFT) // The Microsoft compiler supports the __is_trivially_copyable
// intrinsic directly. __has_builtin is not used for Microsoft
// (see above) to avoid a VS2022 intellisense issue, so the
// intrinsic is enabled here for the no-STL configuration.
#if !defined(ETL_USING_BUILTIN_IS_TRIVIALLY_COPYABLE)
#define ETL_USING_BUILTIN_IS_TRIVIALLY_COPYABLE 1
#endif
#endif
// The default. Set to 0, if not already set.
#if !defined(ETL_USING_BUILTIN_IS_ASSIGNABLE)
#define ETL_USING_BUILTIN_IS_ASSIGNABLE 0

10
include/etl/span.h
View File

@ -1491,14 +1491,14 @@ namespace etl
span(const etl::array<T, Size>&) -> span<const T, Size>;
// Forward declaration of etl::ivector
template <typename T>
template <typename T, typename Enable>
class ivector;
template <typename T>
span(etl::ivector<T>&) -> span<T>;
template <typename T, typename Enable>
span(etl::ivector<T, Enable>&) -> span<T>;
template <typename T>
span(const etl::ivector<T>&) -> span<const T>;
template <typename T, typename Enable>
span(const etl::ivector<T, Enable>&) -> span<const T>;
#if ETL_USING_STL && ETL_USING_CPP11
template <typename T, size_t Size>

93
include/etl/type_traits.h
View File

@ -1144,8 +1144,8 @@ namespace etl
inline constexpr bool is_class_v = is_class<T>::value;
#endif
//***************************************************************************
/// is_base_of
//***************************************************************************
/// is_base_of
#if ETL_USING_CPP11
namespace private_type_traits
{
@ -1358,9 +1358,9 @@ namespace etl
};
#endif
//***************************************************************************
/// is_convertible
///\ingroup type_traits
//***************************************************************************
/// is_convertible
///\ingroup type_traits
#if ETL_USING_CPP11
namespace private_type_traits
{
@ -2149,9 +2149,9 @@ namespace etl
#endif
//***************************************************************************
/// is_convertible
///\ingroup type_traits
//***************************************************************************
/// is_convertible
///\ingroup type_traits
#if ETL_USING_CPP11
template <typename TFrom, typename TTo>
struct is_convertible : std::is_convertible<TFrom, TTo>
@ -3909,6 +3909,32 @@ namespace etl
#endif
}
//***************************************************************************
/// Is T a member pointer
//***************************************************************************
namespace private_type_traits
{
template <typename T>
struct is_member_pointer_helper : etl::false_type
{
};
template <typename T, typename TObject>
struct is_member_pointer_helper<T TObject::*> : etl::true_type
{
};
} // namespace private_type_traits
template <typename T>
struct is_member_pointer : private_type_traits::is_member_pointer_helper< typename etl::remove_cv<T>::type>
{
};
#if ETL_USING_CPP17
template <typename T>
inline constexpr bool is_member_pointer_v = etl::is_member_pointer<T>::value;
#endif
#if ETL_USING_CPP11
//*********************************
/// Check if T is a function type
@ -4008,6 +4034,15 @@ namespace etl
inline constexpr bool is_function_v = etl::is_function<T>::value;
#endif
#else
template <typename T>
struct is_function : etl::bool_constant<!etl::is_member_pointer<T>::value && !etl::is_const<const T>::value && !etl::is_reference<T>::value>
{
};
#endif
//***************************************************************************
/// is_object
//***************************************************************************
@ -4016,10 +4051,22 @@ namespace etl
{
};
#if ETL_USING_CPP17
#if ETL_USING_CPP17
template <typename T>
inline constexpr bool is_object_v = etl::is_object<T>::value;
#endif
#endif
//***************************************************************************
/// is_object_pointer
//***************************************************************************
template <typename T>
struct is_object_pointer : etl::bool_constant<etl::is_pointer<T>::value && etl::is_object<typename etl::remove_pointer<T>::type>::value>
{
};
#if ETL_USING_CPP17
template <typename T>
inline constexpr bool is_object_pointer_v = etl::is_object_pointer<T>::value;
#endif
#if ETL_USING_CPP11
@ -4075,32 +4122,6 @@ namespace etl
#endif
#endif
//***************************************************************************
/// Is T a member pointer
//***************************************************************************
namespace private_type_traits
{
template <typename T>
struct is_member_pointer_helper : etl::false_type
{
};
template <typename T, typename TObject>
struct is_member_pointer_helper<T TObject::*> : etl::true_type
{
};
} // namespace private_type_traits
template <typename T>
struct is_member_pointer : private_type_traits::is_member_pointer_helper< typename etl::remove_cv<T>::type>
{
};
#if ETL_USING_CPP17
template <typename T>
inline constexpr bool is_member_pointer_v = etl::is_member_pointer<T>::value;
#endif
#if ETL_USING_CPP11
//***************************************************************************
/// Is T a member function pointer

26
include/etl/utility.h
View File

@ -490,6 +490,7 @@ namespace etl
};
#if ETL_NOT_USING_STL || ETL_CPP14_NOT_SUPPORTED
#if ETL_CPP11_NOT_SUPPORTED
//***************************************************************************
/// exchange (const)
//***************************************************************************
@ -500,7 +501,6 @@ namespace etl
object = new_value;
return old_value;
}
template <typename T, typename U>
T exchange(T& object, const U& new_value)
{
@ -508,16 +508,30 @@ namespace etl
object = new_value;
return old_value;
}
#else
#else
//***************************************************************************
/// exchange (const)
/// exchange
//***************************************************************************
template <typename T, typename U = T>
T exchange(T& object, const U& new_value)
ETL_CONSTEXPR14 T exchange(T& object, U&& new_value)
ETL_NOEXCEPT_IF((etl::is_nothrow_move_constructible<T>::value && etl::is_nothrow_assignable<T&, U>::value))
{
return std::exchange(object, new_value);
T old_value = etl::move(object);
object = etl::forward<U>(new_value);
return old_value;
}
#endif
#endif // ETL_CPP11_NOT_SUPPORTED
#else
//***************************************************************************
/// exchange
//***************************************************************************
template <typename T, typename U = T>
ETL_CONSTEXPR14 T exchange(T& object, U&& new_value)
ETL_NOEXCEPT_IF((etl::is_nothrow_move_constructible<T>::value && etl::is_nothrow_assignable<T&, U>::value))
{
return std::exchange(object, etl::forward<U>(new_value));
}
#endif // ETL_NOT_USING_STL || ETL_CPP14_NOT_SUPPORTED
//***************************************************************************
/// as_const

902
include/etl/vector.h
View File

File diff suppressed because it is too large Load Diff

2
include/etl/version.h
View File

@ -40,7 +40,7 @@ SOFTWARE.
#define ETL_VERSION_MAJOR 20
#define ETL_VERSION_MINOR 48
#define ETL_VERSION_PATCH 0
#define ETL_VERSION_PATCH 1
#define ETL_VERSION \
ETL_STRING(ETL_VERSION_MAJOR) \

2
library.json
View File

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

2
library.properties
View File

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

17
support/Release notes.txt
View File

@ -1,4 +1,21 @@
===============================================================================
20.48.1
#1477 Fix for 1405: etl::exchange doesn't work with unique_ptr
#1484 Fix etl::message_timer firing following timers early on unregister
#1485 Fix etl::histogram copy/move not preserving start_index
#1486 Fix etl::bitset single-element from_string shift on empty string
#1487 Fix etl::pearson::reset() not resetting the first-byte flag
#1488 Fix etl::mem_cast cross-size copy constructor and assignment
#1489 Add missing interfaces to etl::chrono
#1490 Add missing memory functions, according the standard
#1491 Add optional etl_profile label_flag for Bazel profile injection
#1492 Allow etl::vector to store pointers to functions and member functions
#1494 Refactor variant::emplace to perfect forward args instead of copy/move construct
#1495 Separate bit order and endianness in bit_stream.h
#1496 Fix non-assignable alternatives in variant
===============================================================================
20.48.0
#1375 Support for C++26

4
test/CMakeLists.txt
View File

@ -375,6 +375,10 @@ add_executable(etl_tests
test_vector_non_trivial.cpp
test_vector_pointer.cpp
test_vector_pointer_external_buffer.cpp
test_vector_function_pointer.cpp
test_vector_function_pointer_external_buffer.cpp
test_vector_member_function_pointer.cpp
test_vector_member_function_pointer_external_buffer.cpp
test_visitor.cpp
test_xor_checksum.cpp
test_xor_rotate_checksum.cpp

4
test/meson.build
View File

@ -363,6 +363,10 @@ etl_test_sources = files(
'test_vector_non_trivial.cpp',
'test_vector_pointer.cpp',
'test_vector_pointer_external_buffer.cpp',
'test_vector_function_pointer.cpp',
'test_vector_function_pointer_external_buffer.cpp',
'test_vector_member_function_pointer.cpp',
'test_vector_member_function_pointer_external_buffer.cpp',
'test_visitor.cpp',
'test_xor_checksum.cpp',
'test_xor_rotate_checksum.cpp'

16
test/test_bitset_new_explicit_single_element_type.cpp
View File

@ -398,6 +398,22 @@ namespace
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
// Empty strings exercise the string_length == 0 path in from_string,
// which must not shift by (0 - 1U).
TEST(test_construct_from_empty_string)
{
etl::bitset<64, uint64_t> data_char("");
etl::bitset<64, uint64_t> data_wchar(L"");
etl::bitset<64, uint64_t> data_u16(u"");
etl::bitset<64, uint64_t> data_u32(U"");
CHECK_EQUAL(0U, data_char.count());
CHECK_EQUAL(0U, data_wchar.count());
CHECK_EQUAL(0U, data_u16.count());
CHECK_EQUAL(0U, data_u32.count());
}
//*************************************************************************
TEST(test_construct_from_excess_string)
{

81
test/test_chrono_hh_mm_ss.cpp
View File

@ -286,5 +286,86 @@ namespace
CHECK_EQUAL(0, time.fractional_width);
CHECK_TRUE((std::is_same<duration_type, Chrono::hh_mm_ss<duration_type>::precision>::value));
}
//*************************************************************************
TEST(test_is_am)
{
for (int h = 0; h <= 11; ++h)
{
CHECK_TRUE(Chrono::is_am(Chrono::hours(h)));
}
for (int h = 12; h <= 23; ++h)
{
CHECK_FALSE(Chrono::is_am(Chrono::hours(h)));
}
}
//*************************************************************************
TEST(test_is_pm)
{
for (int h = 0; h <= 11; ++h)
{
CHECK_FALSE(Chrono::is_pm(Chrono::hours(h)));
}
for (int h = 12; h <= 23; ++h)
{
CHECK_TRUE(Chrono::is_pm(Chrono::hours(h)));
}
}
//*************************************************************************
TEST(test_make12)
{
// Midnight (0h) maps to 12h.
CHECK_EQUAL(12, Chrono::make12(Chrono::hours(0)).count());
// 1h..12h are unchanged.
for (int h = 1; h <= 12; ++h)
{
CHECK_EQUAL(h, Chrono::make12(Chrono::hours(h)).count());
}
// 13h..23h map to 1h..11h.
for (int h = 13; h <= 23; ++h)
{
CHECK_EQUAL(h - 12, Chrono::make12(Chrono::hours(h)).count());
}
}
//*************************************************************************
TEST(test_make24)
{
// am: 12h maps to 0h, 1h..11h are unchanged.
CHECK_EQUAL(0, Chrono::make24(Chrono::hours(12), false).count());
for (int h = 1; h <= 11; ++h)
{
CHECK_EQUAL(h, Chrono::make24(Chrono::hours(h), false).count());
}
// pm: 12h stays 12h, 1h..11h map to 13h..23h.
CHECK_EQUAL(12, Chrono::make24(Chrono::hours(12), true).count());
for (int h = 1; h <= 11; ++h)
{
CHECK_EQUAL(h + 12, Chrono::make24(Chrono::hours(h), true).count());
}
}
//*************************************************************************
TEST(test_make12_make24_round_trip)
{
// For every 24-hour value, make12 plus its am/pm flag round-trips via make24.
for (int h = 0; h <= 23; ++h)
{
Chrono::hours h24(h);
bool pm = Chrono::is_pm(h24);
Chrono::hours h12 = Chrono::make12(h24);
CHECK_EQUAL(h, Chrono::make24(h12, pm).count());
}
}
}
} // namespace

93
test/test_chrono_time_point.cpp
View File

@ -185,6 +185,99 @@ namespace
}
}
//*************************************************************************
TEST(test_operator_plus_time_point_duration)
{
TimePoint tp{Chrono::hours(10)};
// Same duration type.
auto result = tp + Chrono::hours(5);
CHECK_EQUAL(15, result.time_since_epoch().count());
// Mixed duration types resolve to the common (finer) type.
auto result_mixed = tp + Chrono::days(1); // 10 hours + 24 hours
CHECK_EQUAL(34, result_mixed.time_since_epoch().count());
CHECK_TRUE((std::is_same<decltype(result_mixed)::duration, Chrono::hours>::value));
}
//*************************************************************************
TEST(test_operator_plus_duration_time_point)
{
TimePoint tp{Chrono::hours(10)};
// Same duration type.
auto result = Chrono::hours(5) + tp;
CHECK_EQUAL(15, result.time_since_epoch().count());
// Mixed duration types resolve to the common (finer) type.
auto result_mixed = Chrono::days(1) + tp; // 24 hours + 10 hours
CHECK_EQUAL(34, result_mixed.time_since_epoch().count());
CHECK_TRUE((std::is_same<decltype(result_mixed)::duration, Chrono::hours>::value));
}
//*************************************************************************
TEST(test_operator_minus_time_point_duration)
{
TimePoint tp{Chrono::hours(50)};
// Same duration type.
auto result = tp - Chrono::hours(5);
CHECK_EQUAL(45, result.time_since_epoch().count());
// Mixed duration types resolve to the common (finer) type.
auto result_mixed = tp - Chrono::days(1); // 50 hours - 24 hours
CHECK_EQUAL(26, result_mixed.time_since_epoch().count());
CHECK_TRUE((std::is_same<decltype(result_mixed)::duration, Chrono::hours>::value));
}
//*************************************************************************
TEST(test_operator_minus_time_point_time_point)
{
TimePoint tp1{Chrono::hours(50)};
TimePoint tp2{Chrono::hours(20)};
// Subtracting two time_points yields the duration between them.
auto diff = tp1 - tp2;
CHECK_EQUAL(30, diff.count());
CHECK_TRUE((std::is_same<decltype(diff), Chrono::hours>::value));
// Mixed duration types resolve to the common (finer) duration.
Chrono::time_point<test_clock, Chrono::days> tp_days{Chrono::days(2)}; // 48 hours
auto diff_mixed = tp1 - tp_days; // 50 hours - 48 hours
CHECK_EQUAL(2, diff_mixed.count());
CHECK_TRUE((std::is_same<decltype(diff_mixed), Chrono::hours>::value));
// The reverse difference is negative.
auto diff_negative = tp2 - tp1;
CHECK_EQUAL(-30, diff_negative.count());
}
//*************************************************************************
TEST(test_increment_decrement_operators)
{
TimePoint tp{Chrono::hours(10)};
// Pre-increment.
auto& pre_inc = ++tp;
CHECK_EQUAL(11, tp.time_since_epoch().count());
CHECK_EQUAL(11, pre_inc.time_since_epoch().count());
// Post-increment returns the previous value.
TimePoint post_inc = tp++;
CHECK_EQUAL(11, post_inc.time_since_epoch().count());
CHECK_EQUAL(12, tp.time_since_epoch().count());
// Pre-decrement.
auto& pre_dec = --tp;
CHECK_EQUAL(11, tp.time_since_epoch().count());
CHECK_EQUAL(11, pre_dec.time_since_epoch().count());
// Post-decrement returns the previous value.
TimePoint post_dec = tp--;
CHECK_EQUAL(11, post_dec.time_since_epoch().count());
CHECK_EQUAL(10, tp.time_since_epoch().count());
}
#if ETL_USING_ETL_CHRONO
//*************************************************************************
TEST(test_min_max_time_point)

2
test/test_circular_iterator.cpp
View File

@ -593,6 +593,7 @@ namespace
//*************************************************************************
TEST(test_conversion_operator_for_forward_iterator)
{
#include "etl/private/diagnostic_null_dereference_push.h"
DataF data = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
etl::circular_iterator<DataF::const_iterator> ci(std::begin(data), std::end(data));
@ -607,6 +608,7 @@ namespace
++itr;
++ci;
CHECK(itr == ci.current());
#include "etl/private/diagnostic_pop.h"
}
//*************************************************************************

4
test/test_deque.cpp
View File

@ -2306,7 +2306,9 @@ namespace
data.fill(N999);
#include "etl/private/diagnostic_uninitialized_push.h"
CHECK(std::equal(blank_data.begin(), blank_data.end(), data.begin()));
#include "etl/private/diagnostic_pop.h"
}
//*************************************************************************
@ -2319,6 +2321,7 @@ namespace
// Access via const_iterator operator[]
DataNDC::const_iterator cit = cdata.begin();
#include "etl/private/diagnostic_uninitialized_push.h"
// Verify operator[] returns values matching sequential access
for (size_t i = 0; i < cdata.size(); ++i)
{
@ -2330,6 +2333,7 @@ namespace
// the type would be non-const reference which is incorrect for const_iterator)
const NDC& ref = cit[0];
CHECK(ref == cdata[0]);
#include "etl/private/diagnostic_pop.h"
}
}
} // namespace

62
test/test_histogram.cpp
View File

@ -248,6 +248,68 @@ namespace
CHECK_EQUAL(0U, histogram2.count());
}
//*************************************************************************
// operator[] of the run time offset histogram uses the stored start index,
// so copying/moving must preserve it. Regression test: the copy/move
// constructors and assignment operators used to forget to copy start_index.
//*************************************************************************
TEST(test_int_runtime_offset_copy_constructor_preserves_start_index)
{
IntRuntimeOffsetHistogram histogram1(Start, input2.begin(), input2.end());
IntRuntimeOffsetHistogram histogram2(histogram1);
for (int key = Start; key < Start + static_cast<int>(Size); ++key)
{
CHECK_EQUAL(static_cast<int>(histogram1[key]), static_cast<int>(histogram2[key]));
}
}
//*************************************************************************
TEST(test_int_runtime_offset_copy_assignment_preserves_start_index)
{
IntRuntimeOffsetHistogram histogram1(Start, input2.begin(), input2.end());
IntRuntimeOffsetHistogram histogram2(Start);
histogram2 = histogram1;
for (int key = Start; key < Start + static_cast<int>(Size); ++key)
{
CHECK_EQUAL(static_cast<int>(histogram1[key]), static_cast<int>(histogram2[key]));
}
}
#if ETL_USING_CPP11
//*************************************************************************
TEST(test_int_runtime_offset_move_constructor_preserves_start_index)
{
IntRuntimeOffsetHistogram histogram1(Start, input2.begin(), input2.end());
IntRuntimeOffsetHistogram histogram_source(Start, input2.begin(), input2.end());
IntRuntimeOffsetHistogram histogram2(etl::move(histogram_source));
for (int key = Start; key < Start + static_cast<int>(Size); ++key)
{
CHECK_EQUAL(static_cast<int>(histogram1[key]), static_cast<int>(histogram2[key]));
}
}
//*************************************************************************
TEST(test_int_runtime_offset_move_assignment_preserves_start_index)
{
IntRuntimeOffsetHistogram histogram1(Start, input2.begin(), input2.end());
IntRuntimeOffsetHistogram histogram_source(Start, input2.begin(), input2.end());
IntRuntimeOffsetHistogram histogram2(Start);
histogram2 = etl::move(histogram_source);
for (int key = Start; key < Start + static_cast<int>(Size); ++key)
{
CHECK_EQUAL(static_cast<int>(histogram1[key]), static_cast<int>(histogram2[key]));
}
}
#endif
//*************************************************************************
TEST(test_string_histogram_constructor)
{

4
test/test_map.cpp
View File

@ -1720,6 +1720,7 @@ namespace
{
using Pair = std::pair<const std::string, int>;
#include "etl/private/diagnostic_null_dereference_push.h"
etl::map data{Pair{"0", 0}, Pair{"1", 1}, Pair{"2", 2}, Pair{"3", 3}, Pair{"4", 4}, Pair{"5", 5}};
auto v = *data.begin();
@ -1732,6 +1733,7 @@ namespace
CHECK_EQUAL(3, data.at("3"));
CHECK_EQUAL(4, data.at("4"));
CHECK_EQUAL(5, data.at("5"));
#include "etl/private/diagnostic_pop.h"
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
@ -1743,6 +1745,7 @@ namespace
{
using Pair = ETL_OR_STD::pair<const std::string, int>;
#include "etl/private/diagnostic_null_dereference_push.h"
auto data = etl::make_map<const std::string, int, std::less<std::string>>(Pair{"0", 0}, Pair{"1", 1}, Pair{"2", 2}, Pair{"3", 3}, Pair{"4", 4},
Pair{"5", 5});
@ -1756,6 +1759,7 @@ namespace
CHECK_EQUAL(3, data.at("3"));
CHECK_EQUAL(4, data.at("4"));
CHECK_EQUAL(5, data.at("5"));
#include "etl/private/diagnostic_pop.h"
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}

18
test/test_mem_cast.cpp
View File

@ -152,6 +152,24 @@ namespace
CHECK_EQUAL(3, memCast.ref<Data>().a[2]);
}
//*************************************************************************
// Cross-size copy/assignment must copy only the source's bytes and must
// not read past the end of the (smaller) source buffer.
TEST(test_mem_cast_copy_and_assign_from_smaller)
{
etl::mem_cast<sizeof(uint32_t), alignof(uint32_t)> smaller;
smaller.assign<uint32_t>(0x12345678UL);
// Cross-size copy construct (destination larger than source).
etl::mem_cast<sizeof(uint32_t) * 2U, alignof(uint32_t)> larger_copy(smaller);
CHECK_EQUAL(0x12345678UL, larger_copy.ref<uint32_t>());
// Cross-size assignment (destination larger than source).
etl::mem_cast<sizeof(uint32_t) * 2U, alignof(uint32_t)> larger_assign;
larger_assign = smaller;
CHECK_EQUAL(0x12345678UL, larger_assign.ref<uint32_t>());
}
//*************************************************************************
TEST(test_mem_cast_assign_type_at_dynamic_offset)
{

178
test/test_memory.cpp
View File

@ -158,6 +158,33 @@ namespace
{
}
};
//***********************************
// A minimal fancy pointer with a nested element_type and a static
// pointer_to. Used to exercise etl::pointer_traits' primary template.
template <typename T>
struct fancy_pointer
{
typedef T element_type;
T* raw;
static fancy_pointer pointer_to(T& r)
{
fancy_pointer p;
p.raw = etl::addressof(r);
return p;
}
};
//***********************************
// A fancy pointer without a nested element_type, so pointer_traits must
// deduce the element type from the first template parameter.
template <typename T>
struct bare_pointer
{
T* raw;
};
} // namespace
namespace
@ -1808,6 +1835,157 @@ namespace
CHECK_EQUAL(plist_item, etl::to_address(itr));
}
//*************************************************************************
TEST(test_launder)
{
int i = 42;
int* p = etl::launder(&i);
CHECK_EQUAL(&i, p);
CHECK_EQUAL(42, *p);
// Launder a new object created in reused storage.
struct quad_t
{
uint8_t a;
uint8_t b;
uint8_t c;
uint8_t d;
};
alignas(quad_t) unsigned char buffer[sizeof(quad_t)];
quad_t* q = ::new (buffer) quad_t{1, 2, 3, 4};
quad_t* lq = etl::launder(q);
CHECK(reinterpret_cast<unsigned char*>(lq) == buffer);
CHECK_EQUAL(1, lq->a);
CHECK_EQUAL(2, lq->b);
CHECK_EQUAL(3, lq->c);
CHECK_EQUAL(4, lq->d);
}
//*************************************************************************
TEST(test_start_lifetime_as)
{
struct quad_t
{
uint8_t a;
uint8_t b;
uint8_t c;
uint8_t d;
};
alignas(quad_t) unsigned char buffer[sizeof(quad_t)] = {1, 2, 3, 4};
quad_t* p = etl::start_lifetime_as<quad_t>(buffer);
CHECK(reinterpret_cast<unsigned char*>(p) == buffer);
CHECK_EQUAL(1, p->a);
CHECK_EQUAL(2, p->b);
CHECK_EQUAL(3, p->c);
CHECK_EQUAL(4, p->d);
const void* cbuffer = buffer;
const quad_t* cp = etl::start_lifetime_as<quad_t>(cbuffer);
CHECK(reinterpret_cast<const unsigned char*>(cp) == buffer);
CHECK_EQUAL(1, cp->a);
CHECK_EQUAL(4, cp->d);
}
//*************************************************************************
TEST(test_start_lifetime_as_array)
{
alignas(uint16_t) unsigned char buffer[sizeof(uint16_t) * 3] = {0, 0, 0, 0, 0, 0};
uint16_t* p = etl::start_lifetime_as_array<uint16_t>(buffer, 3);
CHECK(reinterpret_cast<unsigned char*>(p) == buffer);
p[0] = 1;
p[2] = 2;
CHECK_EQUAL(1, p[0]);
CHECK_EQUAL(2, p[2]);
// n == 0 returns a pointer comparing equal to p.
uint16_t* p0 = etl::start_lifetime_as_array<uint16_t>(buffer, 0);
CHECK(reinterpret_cast<unsigned char*>(p0) == buffer);
}
//*************************************************************************
TEST(test_pointer_traits)
{
typedef etl::pointer_traits<int*> traits;
CHECK((std::is_same<int*, traits::pointer>::value));
CHECK((std::is_same<int, traits::element_type>::value));
CHECK((std::is_same<ptrdiff_t, traits::difference_type>::value));
#if ETL_USING_CPP11
CHECK((std::is_same<char*, traits::rebind<char> >::value));
#endif
int i = 42;
int* p = traits::pointer_to(i);
CHECK_EQUAL(&i, p);
}
//*************************************************************************
TEST(test_pointer_traits_fancy_pointer)
{
typedef etl::pointer_traits<fancy_pointer<int> > traits;
CHECK((std::is_same<fancy_pointer<int>, traits::pointer>::value));
CHECK((std::is_same<int, traits::element_type>::value));
CHECK((std::is_same<ptrdiff_t, traits::difference_type>::value));
CHECK((std::is_same<fancy_pointer<char>, traits::rebind<char> >::value));
int i = 42;
fancy_pointer<int> p = traits::pointer_to(i);
CHECK_EQUAL(&i, p.raw);
// element_type and rebind are deduced from the first template parameter
// when there is no nested element_type.
CHECK((std::is_same<int, etl::pointer_traits<bare_pointer<int> >::element_type>::value));
CHECK((std::is_same<bare_pointer<char>, etl::pointer_traits<bare_pointer<int> >::rebind<char> >::value));
}
//*************************************************************************
TEST(test_align)
{
alignas(16) unsigned char buffer[64];
void* ptr = buffer + 1; // Deliberately misaligned.
size_t space = sizeof(buffer) - 1;
void* aligned = etl::align(16, 8, ptr, space);
// 'buffer' is 16-aligned, so aligning 'buffer + 1' to 16 skips 15 bytes of
// padding, landing on 'buffer + 16' and shrinking 'space' by that padding.
CHECK(aligned != ETL_NULLPTR);
CHECK(reinterpret_cast<unsigned char*>(aligned) == buffer + 16);
CHECK(reinterpret_cast<unsigned char*>(ptr) == buffer + 16);
CHECK_EQUAL(sizeof(buffer) - 1 - 15, space);
// Not enough space returns nullptr.
void* small_ptr = buffer + 1;
size_t small_space = 2;
CHECK(etl::align(16, 8, small_ptr, small_space) == ETL_NULLPTR);
}
//*************************************************************************
TEST(test_assume_aligned)
{
alignas(16) int data[4] = {1, 2, 3, 4};
int* p = etl::assume_aligned<16>(&data[0]);
CHECK_EQUAL(&data[0], p);
CHECK_EQUAL(1, *p);
}
//*************************************************************************
TEST(test_is_sufficiently_aligned)
{
alignas(16) unsigned char buffer[32];
CHECK(etl::is_sufficiently_aligned<16>(buffer));
CHECK(etl::is_sufficiently_aligned<8>(buffer));
CHECK(!etl::is_sufficiently_aligned<16>(buffer + 1));
}
#if ETL_USING_CPP17
//*************************************************************************
TEST(test_ranges_uninitialized_copy_iterator_trivial)

46
test/test_message_timer.cpp
View File

@ -433,6 +433,52 @@ namespace
CHECK_ARRAY_EQUAL(compare3.data(), router1.message3.data(), compare3.size());
}
//*************************************************************************
// Unregistering an active timer that is not at the tail of the active list
// must preserve the absolute timeout of the timers that follow it.
// Regression test: unregister_timer used to pass has_expired = true, which
// skipped the delta adjustment of the next timer, making it fire early.
//*************************************************************************
TEST(message_timer_unregister_active_timer_preserves_following_timer_timing)
{
etl::message_timer<2> timer_controller;
// id1 (period 10) becomes the active list head, id2 (period 20) follows it.
etl::timer::id::type id1 = timer_controller.register_timer(message1, router1, 10, etl::timer::mode::Single_Shot);
etl::timer::id::type id2 = timer_controller.register_timer(message2, router1, 20, etl::timer::mode::Single_Shot);
router1.clear();
timer_controller.start(id1);
timer_controller.start(id2);
timer_controller.enable(true);
ticks = 0;
const uint32_t step = 1UL;
while (ticks <= 30U)
{
if (ticks == 5U)
{
// id1 is the active head and still has a 'next' (id2).
timer_controller.unregister_timer(id1);
}
ticks += step;
timer_controller.tick(step);
}
// id1 was unregistered before it could fire.
CHECK_EQUAL(0U, router1.message1.size());
// id2 must still fire at its original absolute time of 20, not earlier.
std::vector<uint64_t> compare2 = {20ULL};
CHECK_EQUAL(compare2.size(), router1.message2.size());
CHECK_ARRAY_EQUAL(compare2.data(), router1.message2.data(), compare2.size());
}
//*************************************************************************
TEST(message_timer_repeating_clear)
{

19
test/test_pearson.cpp
View File

@ -144,6 +144,25 @@ namespace
CHECK(compare == hash);
}
//*************************************************************************
TEST(test_pearson_reset)
{
std::string data("123456789");
etl::pearson<HASH_SIZE> pearson_calculator;
// Use the calculator, then reset it and reuse it for the same data.
pearson_calculator.add(data.begin(), data.end());
pearson_calculator.reset();
pearson_calculator.add(data.begin(), data.end());
hash_t compare = Pearson_Compare(data);
hash_t hash = pearson_calculator.value();
// A reset calculator must produce the same hash as a fresh one.
CHECK(compare == hash);
}
//*************************************************************************
TEST(test_pearson_add_range_endian)
{

27
test/test_utility.cpp
View File

@ -28,6 +28,7 @@ SOFTWARE.
#include "unit_test_framework.h"
#include "etl/memory.h"
#include "etl/utility.h"
#include <algorithm>
@ -315,6 +316,32 @@ namespace
CHECK_EQUAL(1, c);
}
//*************************************************************************
TEST(test_exchange_unique_ptr)
{
etl::unique_ptr<int> p1(new int(1));
etl::unique_ptr<int> p2 = etl::exchange(p1, nullptr);
CHECK_FALSE(p1);
CHECK_TRUE(p2);
CHECK_EQUAL(*p2, 1);
}
//*************************************************************************
TEST(test_exchange_unique_ptr_move_in)
{
etl::unique_ptr<int> a(new int(10));
etl::unique_ptr<int> b(new int(20));
etl::unique_ptr<int> old = etl::exchange(a, etl::move(b));
CHECK_TRUE(old);
CHECK_EQUAL(*old, 10);
CHECK_TRUE(a);
CHECK_EQUAL(*a, 20);
CHECK_FALSE(b);
}
//*************************************************************************
TEST(test_as_const)
{

313
test/test_variant_variadic.cpp
View File

@ -320,6 +320,106 @@ namespace
bool moved_to;
bool copied_to;
};
//*********************************************
// Trivially destructible, but non-copyable and non-movable.
// Exercises the trivially-destructible (variadic_union) emplace path.
struct TrivialNonMovable
{
TrivialNonMovable(int a_, int b_)
: a(a_)
, b(b_)
{
}
TrivialNonMovable(const TrivialNonMovable&) = delete;
TrivialNonMovable(TrivialNonMovable&&) = delete;
TrivialNonMovable& operator=(const TrivialNonMovable&) = delete;
TrivialNonMovable& operator=(TrivialNonMovable&&) = delete;
int a;
int b;
};
//*********************************************
// Non-trivially destructible, non-copyable and non-movable.
// Exercises the non-trivially-destructible (uninitialized_buffer) emplace path,
// including the initializer_list overload.
struct NonTrivialNonMovable
{
NonTrivialNonMovable(int a_, int b_)
: a(a_)
, b(b_)
, sum_of_list(0)
{
}
NonTrivialNonMovable(std::initializer_list<int> il, int b_)
: a(0)
, b(b_)
, sum_of_list(0)
{
for (int value : il)
{
sum_of_list += value;
}
}
~NonTrivialNonMovable() // Makes it non-trivially destructible.
{
}
NonTrivialNonMovable(const NonTrivialNonMovable&) = delete;
NonTrivialNonMovable(NonTrivialNonMovable&&) = delete;
NonTrivialNonMovable& operator=(const NonTrivialNonMovable&) = delete;
NonTrivialNonMovable& operator=(NonTrivialNonMovable&&) = delete;
int a;
int b;
int sum_of_list;
};
// Trivially destructible but not assignable (deleted copy and move
// assignment). Constructing an alternative of this type exercises the
// trivially-destructible-suite path, which must begin the alternative's
// lifetime with placement new rather than assigning into the union member.
struct NonAssignable
{
explicit NonAssignable(int value_)
: value(value_)
{
}
NonAssignable(const NonAssignable&) = default;
NonAssignable(NonAssignable&&) = default;
NonAssignable& operator=(const NonAssignable&) = delete;
NonAssignable& operator=(NonAssignable&&) = delete;
int value;
};
//*********************************************
// Trivially destructible type that overloads operator& (here by deleting it).
// Constructing an alternative of this type must obtain the placement-new
// target with etl::addressof, not the built-in unary operator&: taking the
// address with & would be ill-formed (deleted) or, for an operator& that
// returns something other than the object's address, would construct into the
// wrong storage.
struct NonAddressable
{
explicit NonAddressable(int value_)
: value(value_)
{
}
NonAddressable(const NonAddressable&) = default;
NonAddressable(NonAddressable&&) = default;
NonAddressable* operator&() = delete;
const NonAddressable* operator&() const = delete;
int value;
};
} // namespace
// Moved from the top of the file otherwise clang has issues with
@ -418,6 +518,48 @@ struct etl::is_copy_constructible<MoveableCopyable> : public etl::true_type
template <>
struct etl::is_move_constructible<MoveableCopyable> : public etl::true_type
{
};
//*************************
template <>
struct etl::is_copy_constructible<TrivialNonMovable> : public etl::false_type
{
};
template <>
struct etl::is_copy_constructible<NonAssignable> : public etl::true_type
{
};
template <>
struct etl::is_move_constructible<TrivialNonMovable> : public etl::false_type
{
};
template <>
struct etl::is_move_constructible<NonAssignable> : public etl::true_type
{
};
//*************************
template <>
struct etl::is_copy_constructible<NonTrivialNonMovable> : public etl::false_type
{
};
template <>
struct etl::is_copy_constructible<NonAddressable> : public etl::true_type
{
};
template <>
struct etl::is_move_constructible<NonTrivialNonMovable> : public etl::false_type
{
};
template <>
struct etl::is_move_constructible<NonAddressable> : public etl::true_type
{
};
#endif
@ -732,6 +874,86 @@ namespace
CHECK_EQUAL(text, etl::get<std::string>(variant_text_etl));
}
//*************************************************************************
// emplace must construct the alternative in place from the forwarded
// arguments, without requiring the alternative to be copyable or movable
// (see issue #1493).
TEST(test_emplace_non_movable_type)
{
// Trivially destructible suite (variadic_union storage).
{
etl::variant<int, TrivialNonMovable> v;
TrivialNonMovable& r1 = v.emplace<TrivialNonMovable>(3, 4);
CHECK(etl::holds_alternative<TrivialNonMovable>(v));
CHECK_EQUAL(3, r1.a);
CHECK_EQUAL(4, r1.b);
CHECK_EQUAL(&r1, &etl::get<TrivialNonMovable>(v));
// Emplace by index over the existing alternative.
TrivialNonMovable& r2 = v.emplace<1>(5, 6);
CHECK_EQUAL(5, r2.a);
CHECK_EQUAL(6, r2.b);
// Switch to the trivial alternative and back again.
v.emplace<int>(42);
CHECK(etl::holds_alternative<int>(v));
CHECK_EQUAL(42, etl::get<int>(v));
TrivialNonMovable& r3 = v.emplace<TrivialNonMovable>(7, 8);
CHECK(etl::holds_alternative<TrivialNonMovable>(v));
CHECK_EQUAL(7, r3.a);
CHECK_EQUAL(8, r3.b);
}
// Non-trivially destructible suite (uninitialized_buffer storage).
{
etl::variant<std::string, NonTrivialNonMovable> v;
NonTrivialNonMovable& r1 = v.emplace<NonTrivialNonMovable>(1, 2);
CHECK(etl::holds_alternative<NonTrivialNonMovable>(v));
CHECK_EQUAL(1, r1.a);
CHECK_EQUAL(2, r1.b);
CHECK_EQUAL(&r1, &etl::get<NonTrivialNonMovable>(v));
// Emplace by index over the existing alternative.
NonTrivialNonMovable& r2 = v.emplace<1>(9, 10);
CHECK_EQUAL(9, r2.a);
CHECK_EQUAL(10, r2.b);
// Switch to the std::string alternative and back again.
v.emplace<std::string>("Some Text");
CHECK(etl::holds_alternative<std::string>(v));
CHECK_EQUAL(std::string("Some Text"), etl::get<std::string>(v));
NonTrivialNonMovable& r3 = v.emplace<NonTrivialNonMovable>(11, 12);
CHECK(etl::holds_alternative<NonTrivialNonMovable>(v));
CHECK_EQUAL(11, r3.a);
CHECK_EQUAL(12, r3.b);
}
}
#if ETL_HAS_INITIALIZER_LIST
//*************************************************************************
// The initializer_list emplace overloads must also construct in place,
// without requiring the alternative to be copyable or movable (#1493).
TEST(test_emplace_non_movable_type_with_initializer_list)
{
etl::variant<std::string, NonTrivialNonMovable> v;
// By type.
NonTrivialNonMovable& r1 = v.emplace<NonTrivialNonMovable>({10, 20, 30}, 99);
CHECK(etl::holds_alternative<NonTrivialNonMovable>(v));
CHECK_EQUAL(60, r1.sum_of_list);
CHECK_EQUAL(99, r1.b);
// By index.
NonTrivialNonMovable& r2 = v.emplace<1>({1, 2, 3, 4}, 7);
CHECK_EQUAL(10, r2.sum_of_list);
CHECK_EQUAL(7, r2.b);
}
#endif
//*************************************************************************
TEST(test_copy_constructor)
{
@ -896,6 +1118,81 @@ namespace
CHECK_EQUAL(D4("1", "2", "3", "4"), etl::get<D4>(variant_etl));
}
//*************************************************************************
// Constructing an alternative must begin the object's lifetime with
// placement new, not assign into the (inactive) union member. A trivially
// destructible but non-assignable type would fail to compile (deleted
// assignment) or invoke undefined behaviour if assignment were used.
// (The trivially-destructible-suite union path is taken when the STL or the
// compiler type-trait built-ins are available; otherwise construction goes
// through the buffer path, which is exercised here just the same.)
TEST(test_construct_trivially_destructible_non_assignable_type)
{
using variant_type = etl::variant<int, NonAssignable>;
// Emplace by type.
variant_type variant_by_type;
variant_by_type.emplace<NonAssignable>(42);
CHECK(etl::holds_alternative<NonAssignable>(variant_by_type));
CHECK_EQUAL(42, etl::get<NonAssignable>(variant_by_type).value);
// Emplace by index.
variant_type variant_by_index;
variant_by_index.emplace<1>(43);
CHECK(etl::holds_alternative<NonAssignable>(variant_by_index));
CHECK_EQUAL(43, etl::get<NonAssignable>(variant_by_index).value);
// Assignment from a value (operator=(T&&)).
variant_type variant_by_assignment;
variant_by_assignment = NonAssignable(44);
CHECK(etl::holds_alternative<NonAssignable>(variant_by_assignment));
CHECK_EQUAL(44, etl::get<NonAssignable>(variant_by_assignment).value);
// Re-emplace over an already-active alternative (do_destroy then
// placement new into the same union member).
variant_by_assignment.emplace<NonAssignable>(45);
CHECK(etl::holds_alternative<NonAssignable>(variant_by_assignment));
CHECK_EQUAL(45, etl::get<NonAssignable>(variant_by_assignment).value);
}
//*************************************************************************
// Constructing an alternative must take the raw storage address for
// placement new via etl::addressof, not the built-in unary operator&.
// NonAddressable deletes operator&, so the old `&variadic_union_get(...)`
// form would be ill-formed. Read-back uses by-index etl::get (which returns
// a reference) and the reference returned by emplace, so it never invokes
// operator&. (The trivially-destructible-suite union path is taken when the
// STL or the compiler built-ins are available; otherwise construction goes
// through the buffer path, which is exercised here just the same.)
TEST(test_construct_type_with_overloaded_address_of_operator)
{
using variant_type = etl::variant<int, NonAddressable>;
// Emplace by type (returns a reference, so no operator& on read-back).
variant_type variant_by_type;
NonAddressable& by_type = variant_by_type.emplace<NonAddressable>(42);
CHECK(etl::holds_alternative<NonAddressable>(variant_by_type));
CHECK_EQUAL(42, by_type.value);
CHECK_EQUAL(42, etl::get<1>(variant_by_type).value);
// Emplace by index.
variant_type variant_by_index;
variant_by_index.emplace<1>(43);
CHECK(etl::holds_alternative<NonAddressable>(variant_by_index));
CHECK_EQUAL(43, etl::get<1>(variant_by_index).value);
// Assignment from a value (operator=(T&&)).
variant_type variant_by_assignment;
variant_by_assignment = NonAddressable(44);
CHECK(etl::holds_alternative<NonAddressable>(variant_by_assignment));
CHECK_EQUAL(44, etl::get<1>(variant_by_assignment).value);
// Re-emplace over an already-active alternative.
variant_by_assignment.emplace<1>(45);
CHECK(etl::holds_alternative<NonAddressable>(variant_by_assignment));
CHECK_EQUAL(45, etl::get<1>(variant_by_assignment).value);
}
//*************************************************************************
TEST(test_variant_accept_visitor)
{
@ -1007,6 +1304,7 @@ namespace
}
//*************************************************************************
#include "etl/private/diagnostic_uninitialized_push.h"
TEST(test_const_variant_accept_visitor)
{
struct Visitor : public etl::visitor<const char&, const int&, const std::string&>
@ -1057,8 +1355,10 @@ namespace
const_variant_etl3.accept(visitor);
CHECK_EQUAL("3", visitor.result_s);
}
#include "etl/private/diagnostic_pop.h"
//*************************************************************************
#include "etl/private/diagnostic_uninitialized_push.h"
TEST(test_const_variant_accept_visitor_deprecated)
{
struct Visitor : public etl::visitor<char, int, const std::string&>
@ -1111,6 +1411,7 @@ namespace
const_variant_etl3.accept(visitor);
CHECK_EQUAL("3", visitor.result_s);
}
#include "etl/private/diagnostic_pop.h"
//*************************************************************************
TEST(test_variant_accept_functor_with_functor_class)
@ -1218,6 +1519,7 @@ namespace
}
//*************************************************************************
#include "etl/private/diagnostic_uninitialized_push.h"
TEST(test_const_variant_accept_functor_with_functor_class)
{
struct Visitor
@ -1268,8 +1570,10 @@ namespace
const_variant_etl3.accept(visitor);
CHECK_EQUAL("3", visitor.result_s);
}
#include "etl/private/diagnostic_pop.h"
//*************************************************************************
#include "etl/private/diagnostic_uninitialized_push.h"
TEST(test_const_variant_accept_functor_with_functor_class_deprecated)
{
struct Visitor
@ -1320,6 +1624,7 @@ namespace
const_variant_etl3.accept(visitor);
CHECK_EQUAL("3", visitor.result_s);
}
#include "etl/private/diagnostic_pop.h"
//*************************************************************************
#if ETL_USING_CPP17
@ -1389,7 +1694,8 @@ namespace
CHECK_EQUAL("3", result_s);
}
//*************************************************************************
//*************************************************************************
#include "etl/private/diagnostic_uninitialized_push.h"
TEST(test_const_variant_accept_functor_with_overload)
{
char result_c;
@ -1416,8 +1722,10 @@ namespace
const_variant_etl3.accept(visitor);
CHECK_EQUAL("3", result_s);
}
#include "etl/private/diagnostic_pop.h"
//*************************************************************************
//*************************************************************************
#include "etl/private/diagnostic_uninitialized_push.h"
TEST(test_const_variant_accept_functor_with_overload_deprecated)
{
char result_c;
@ -1444,6 +1752,7 @@ namespace
const_variant_etl3.accept(visitor);
CHECK_EQUAL("3", result_s);
}
#include "etl/private/diagnostic_pop.h"
#endif
//*************************************************************************

30
test/test_vector.cpp
View File

@ -1077,13 +1077,15 @@ namespace
Compare_Data compare_data(initial_data.begin(), initial_data.end());
Data data(initial_data.begin(), initial_data.end());
Compare_Data::iterator const_cdi = compare_data.begin() + 2U;
int compare_value = *(const_cdi + 1U);
Compare_Data::iterator cdi = compare_data.erase(const_cdi);
Compare_Data::iterator const_cdi = compare_data.begin() + 2U;
#include "etl/private/diagnostic_null_dereference_push.h"
int compare_value = compare_data[3];
#include "etl/private/diagnostic_pop.h"
Compare_Data::iterator cdi = compare_data.erase(const_cdi);
CHECK_EQUAL(compare_value, *cdi);
Data::iterator const_di = data.begin() + 2U;
int data_value = *(const_di + 1U);
int data_value = data[3];
Data::iterator di = data.erase(const_di);
CHECK_EQUAL(data_value, *di);
@ -1108,13 +1110,15 @@ namespace
Compare_Data compare_data(initial_data.begin(), initial_data.end());
Data data(initial_data.begin(), initial_data.end());
Compare_Data::const_iterator const_cdi = compare_data.cbegin() + 2U;
int compare_value = *(const_cdi + 1U);
Compare_Data::iterator cdi = compare_data.erase(const_cdi);
Compare_Data::const_iterator const_cdi = compare_data.cbegin() + 2U;
#include "etl/private/diagnostic_null_dereference_push.h"
int compare_value = compare_data[3];
#include "etl/private/diagnostic_pop.h"
Compare_Data::iterator cdi = compare_data.erase(const_cdi);
CHECK_EQUAL(compare_value, *cdi);
Data::const_iterator const_di = data.cbegin() + 2U;
int data_value = *(const_di + 1U);
int data_value = data[3];
Data::iterator di = data.erase(const_di);
CHECK_EQUAL(data_value, *di);
@ -1139,15 +1143,9 @@ namespace
Compare_Data compare_data(initial_data.begin(), initial_data.end());
Data data(initial_data.begin(), initial_data.end());
Compare_Data::const_iterator const_cdi = compare_data.cbegin() + 2U;
int compare_value = *(const_cdi + 2U);
Compare_Data::iterator cdi = compare_data.erase(const_cdi, const_cdi + 2U);
CHECK_EQUAL(compare_value, *cdi);
compare_data.erase(compare_data.begin() + 2, compare_data.begin() + 4);
Data::const_iterator const_di = data.cbegin() + 2U;
int data_value = *(const_di + 2U);
Data::iterator di = data.erase(const_di, const_di + 2U);
CHECK_EQUAL(data_value, *di);
data.erase(data.begin() + 2, data.begin() + 4);
CHECK_EQUAL(compare_data.size(), data.size());

18
test/test_vector_external_buffer.cpp
View File

@ -46,6 +46,8 @@ namespace
int buffer4[SIZE];
int buffer5[SIZE];
int bufferLarger[SIZE + 1];
SUITE(test_vector_external_buffer)
{
typedef etl::vector_ext<int> Data;
@ -183,6 +185,14 @@ namespace
CHECK(data2 != data);
}
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_copy_construct_from_larger_vector_ext)
{
Data data(initial_data.begin(), initial_data.end(), bufferLarger, SIZE + 1);
data.resize(SIZE + 1, 0);
CHECK_THROW(Data data2(data, buffer1, SIZE), etl::vector_full);
}
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_move_constructor)
{
@ -193,6 +203,14 @@ namespace
CHECK(data2 != data);
}
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_move_construct_from_larger_vector_ext)
{
Data data(initial_data.begin(), initial_data.end(), bufferLarger, SIZE + 1);
data.resize(SIZE + 1, 0);
CHECK_THROW(Data data2(etl::move(data), buffer1, SIZE), etl::vector_full);
}
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_assignment)
{

1321
test/test_vector_function_pointer.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

1301
test/test_vector_function_pointer_external_buffer.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

1330
test/test_vector_member_function_pointer.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

1329
test/test_vector_member_function_pointer_external_buffer.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

18
test/vs2022/etl.vcxproj
View File

@ -3700,7 +3700,6 @@
<ClInclude Include="..\..\include\etl\mutex\mutex_std.h" />
<ClInclude Include="..\..\include\etl\packet.h" />
<ClInclude Include="..\..\include\etl\permutations.h" />
<ClInclude Include="..\..\include\etl\private\ivectorpointer.h" />
<ClInclude Include="..\..\include\etl\private\minmax_pop.h" />
<ClInclude Include="..\..\include\etl\private\minmax_push.h" />
<ClInclude Include="..\..\include\etl\profiles\arduino_arm.h" />
@ -11463,6 +11462,10 @@
<ClCompile Include="..\test_variant_pool.cpp" />
<ClCompile Include="..\test_vector.cpp" />
<ClCompile Include="..\test_vector_external_buffer.cpp" />
<ClCompile Include="..\test_vector_function_pointer.cpp" />
<ClCompile Include="..\test_vector_function_pointer_external_buffer.cpp" />
<ClCompile Include="..\test_vector_member_function_pointer.cpp" />
<ClCompile Include="..\test_vector_member_function_pointer_external_buffer.cpp" />
<ClCompile Include="..\test_vector_non_trivial.cpp" />
<ClCompile Include="..\test_vector_pointer.cpp" />
<ClCompile Include="..\test_vector_pointer_external_buffer.cpp" />
@ -11498,19 +11501,32 @@
<None Include="..\..\.clang-format" />
<None Include="..\..\.coderabbit.yaml" />
<None Include="..\..\.gitattributes" />
<None Include="..\..\.github\workflows\bazel-gcc-c++23-no-stl.yml" />
<None Include="..\..\.github\workflows\clang-c++11.yml" />
<None Include="..\..\.github\workflows\clang-c++14.yml" />
<None Include="..\..\.github\workflows\clang-c++17.yml" />
<None Include="..\..\.github\workflows\clang-c++20.yml" />
<None Include="..\..\.github\workflows\clang-c++23.yml" />
<None Include="..\..\.github\workflows\clang-c++26.yml" />
<None Include="..\..\.github\workflows\clang-format.yaml" />
<None Include="..\..\.github\workflows\clang-format_update.yaml" />
<None Include="..\..\.github\workflows\clang-syntax-checks.yml" />
<None Include="..\..\.github\workflows\clang-tidy.yaml" />
<None Include="..\..\.github\workflows\coverage.yml" />
<None Include="..\..\.github\workflows\deploy-etl-documentation.yml" />
<None Include="..\..\.github\workflows\gcc-c++11.yml" />
<None Include="..\..\.github\workflows\gcc-c++14.yml" />
<None Include="..\..\.github\workflows\gcc-c++17.yml" />
<None Include="..\..\.github\workflows\gcc-c++20.yml" />
<None Include="..\..\.github\workflows\gcc-c++23-armhf.yml" />
<None Include="..\..\.github\workflows\gcc-c++23-i386.yml" />
<None Include="..\..\.github\workflows\gcc-c++23-powerpc.yml" />
<None Include="..\..\.github\workflows\gcc-c++23-riscv64.yml" />
<None Include="..\..\.github\workflows\gcc-c++23-s390x.yml" />
<None Include="..\..\.github\workflows\gcc-c++23.yml" />
<None Include="..\..\.github\workflows\gcc-c++26.yml" />
<None Include="..\..\.github\workflows\generator.yml" />
<None Include="..\..\.github\workflows\meson-gcc-c++23-no-stl.yml" />
<None Include="..\..\.github\workflows\msvc.yml" />
<None Include="..\..\.github\workflows\gcc-syntax-checks.yml" />
<None Include="..\..\.github\workflows\platformio-update.yml" />

57
test/vs2022/etl.vcxproj.filters
View File

@ -597,9 +597,6 @@
<ClInclude Include="..\..\include\etl\bit_stream.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\include\etl\private\ivectorpointer.h">
<Filter>ETL\Private</Filter>
</ClInclude>
<ClInclude Include="..\..\include\etl\private\minmax_pop.h">
<Filter>ETL\Private</Filter>
</ClInclude>
@ -1569,6 +1566,9 @@
<ClInclude Include="..\..\include\etl\generators\message_router_cpp03_generator.h">
<Filter>ETL\Messaging\Generators</Filter>
</ClInclude>
<ClInclude Include="..\..\include\etl\format.h">
<Filter>UnitTest++\Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\test_string_char.cpp">
@ -3818,6 +3818,18 @@
<ClCompile Include="..\test_closure_with_inplace_function.cpp">
<Filter>Tests\Callbacks &amp; Delegates</Filter>
</ClCompile>
<ClCompile Include="..\test_vector_function_pointer.cpp">
<Filter>Tests\Containers</Filter>
</ClCompile>
<ClCompile Include="..\test_vector_member_function_pointer.cpp">
<Filter>Tests\Containers</Filter>
</ClCompile>
<ClCompile Include="..\test_vector_function_pointer_external_buffer.cpp">
<Filter>Tests\Containers</Filter>
</ClCompile>
<ClCompile Include="..\test_vector_member_function_pointer_external_buffer.cpp">
<Filter>Tests\Containers</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<None Include="..\..\library.properties">
@ -4002,6 +4014,45 @@
<None Include="..\run-coverage.sh">
<Filter>Tests\Scripts</Filter>
</None>
<None Include="..\..\.github\workflows\bazel-gcc-c++23-no-stl.yml">
<Filter>Resource Files\CI\Github</Filter>
</None>
<None Include="..\..\.github\workflows\clang-c++26.yml">
<Filter>Resource Files\CI\Github</Filter>
</None>
<None Include="..\..\.github\workflows\clang-tidy.yaml">
<Filter>Resource Files\CI\Github</Filter>
</None>
<None Include="..\..\.github\workflows\coverage.yml">
<Filter>Resource Files\CI\Github</Filter>
</None>
<None Include="..\..\.github\workflows\deploy-etl-documentation.yml">
<Filter>Resource Files\CI\Github</Filter>
</None>
<None Include="..\..\.github\workflows\gcc-c++23-armhf.yml">
<Filter>Resource Files\CI\Github</Filter>
</None>
<None Include="..\..\.github\workflows\gcc-c++23-i386.yml">
<Filter>Resource Files\CI\Github</Filter>
</None>
<None Include="..\..\.github\workflows\gcc-c++23-powerpc.yml">
<Filter>Resource Files\CI\Github</Filter>
</None>
<None Include="..\..\.github\workflows\gcc-c++23-riscv64.yml">
<Filter>Resource Files\CI\Github</Filter>
</None>
<None Include="..\..\.github\workflows\gcc-c++23-s390x.yml">
<Filter>Resource Files\CI\Github</Filter>
</None>
<None Include="..\..\.github\workflows\gcc-c++26.yml">
<Filter>Resource Files\CI\Github</Filter>
</None>
<None Include="..\..\.github\workflows\generator.yml">
<Filter>Resource Files\CI\Github</Filter>
</None>
<None Include="..\..\.github\workflows\meson-gcc-c++23-no-stl.yml">
<Filter>Resource Files\CI\Github</Filter>
</None>
</ItemGroup>
<ItemGroup>
<Text Include="..\..\support\Release notes.txt">

2
version.txt
View File

@ -1 +1 @@
20.48.0
20.48.1