coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-11-09 14:49:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'pull-request/#1144-Add-support-for-CRC8-NRSC5' into development

Browse Source
This commit is contained in:
John Wellbelove 2025-07-09 10:22:12 +01:00
commit 7535d9b63a
29 changed files with 13415 additions and 233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
include/etl/const_map.h
View File

@ -55,18 +55,14 @@ namespace etl
{
public:
using key_type = TKey;
using value_type = ETL_OR_STD::pair<const TKey, TMapped>;
using mapped_type = TMapped ;
using key_compare = TKeyCompare;
using const_reference = const value_type&;
using const_pointer = const value_type*;
using const_iterator = const value_type*;
using size_type = size_t;
/// Defines the parameter types
using const_key_reference = const key_type&;
using const_mapped_reference = const mapped_type&;
using key_type = TKey;
using value_type = ETL_OR_STD::pair<const TKey, TMapped>;
using mapped_type = TMapped ;
using key_compare = TKeyCompare;
using const_reference = const value_type&;
using const_pointer = const value_type*;
using const_iterator = const value_type*;
using size_type = size_t;
//*********************************************************************
/// How to compare elements and keys.
@ -82,7 +78,7 @@ namespace etl
}
// Compare value type and key.
ETL_CONSTEXPR14 bool operator ()(const value_type& element, const_key_reference key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator ()(const value_type& element, const key_type& key) const ETL_NOEXCEPT
{
return kcompare(element.first, key);
}
@ -96,7 +92,7 @@ namespace etl
}
// Compare key and value type.
ETL_CONSTEXPR14 bool operator ()(const_key_reference key, const value_type& element) const ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator ()(const key_type& key, const value_type& element) const ETL_NOEXCEPT
{
return kcompare(key, element.first);
}
@ -165,10 +161,10 @@ namespace etl
//*************************************************************************
///\brief Index operator.
///\param key The key of the element to return.
///\return A <code>const_mapped_reference</code> to the mapped value at the index.
///\return A <code>const mapped_type&</code> to the mapped value at the index.
/// Undefined behaviour if the key is not in the map.
//*************************************************************************
ETL_CONSTEXPR14 const_mapped_reference operator[](const_key_reference key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 const mapped_type& operator[](const key_type& key) const ETL_NOEXCEPT
{
const_iterator itr = find(key);
@ -179,11 +175,11 @@ namespace etl
///\brief Key index operator.
/// Enabled for transparent comparators.
///\param key The key of the element to return.
///\return A <code>const_mapped_reference</code> to the mapped value at the key index.
///\return A <code>const mapped_type&</code> to the mapped value at the key index.
/// Undefined behaviour if the key is not in the map.
//*************************************************************************
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 const_mapped_reference operator[](const K& key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 const mapped_type& operator[](const K& key) const ETL_NOEXCEPT
{
const_iterator itr = find(key);
@ -193,10 +189,10 @@ namespace etl
//*************************************************************************
///\brief Gets the mapped value at the key index.
///\param key The key of the element to return.
///\return A <code>const_mapped_reference</code> to the mapped value at the index.
///\return A <code>const mapped_type&</code> to the mapped value at the index.
/// Undefined behaviour if the key is not in the map.
//*************************************************************************
ETL_CONSTEXPR14 const_mapped_reference at(const_key_reference key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 const mapped_type& at(const key_type& key) const ETL_NOEXCEPT
{
const_iterator itr = find(key);
@ -207,11 +203,11 @@ namespace etl
///\brief Gets the mapped value at the key index.
/// Enabled if the comparator is transparent.
///\param key The key of the element to return.
///\return A <code>const_mapped_reference</code> to the mapped value at the index.
///\return A <code>const mapped_type&</code> to the mapped value at the index.
/// Undefined behaviour if the key is not in the map.
//*************************************************************************
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 const_mapped_reference at(const K& key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 const mapped_type& at(const K& key) const ETL_NOEXCEPT
{
const_iterator itr = find(key);
@ -224,7 +220,7 @@ namespace etl
///\return A <code>const_iterator</code> to the mapped value at the index,
/// or end() if not found.
//*************************************************************************
ETL_CONSTEXPR14 const_iterator find(const_key_reference key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 const_iterator find(const key_type& key) const ETL_NOEXCEPT
{
const_iterator itr = lower_bound(key);
@ -234,7 +230,6 @@ namespace etl
}
return end();
}
//*************************************************************************
@ -262,7 +257,7 @@ namespace etl
///\param key The key of the element to check.
///\return <b>true</b> if the map contains an element with key.
//*************************************************************************
ETL_CONSTEXPR14 bool contains(const_key_reference key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 bool contains(const key_type& key) const ETL_NOEXCEPT
{
return find(key) != end();
}
@ -284,7 +279,7 @@ namespace etl
///\param key The key of the element to count.
///\return 0 or 1
//*************************************************************************
ETL_CONSTEXPR14 size_type count(const_key_reference key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 size_type count(const key_type& key) const ETL_NOEXCEPT
{
return contains(key) ? 1 : 0;
}
@ -309,7 +304,7 @@ namespace etl
///\param key The key of the element
///\return etl::pair or std::pair containing a pair of iterators.
//*************************************************************************
ETL_CONSTEXPR14 ETL_OR_STD::pair<const_iterator, const_iterator> equal_range(const_key_reference key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 ETL_OR_STD::pair<const_iterator, const_iterator> equal_range(const key_type& key) const ETL_NOEXCEPT
{
return etl::equal_range(begin(), end(), key, vcompare);
}
@ -335,7 +330,7 @@ namespace etl
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
ETL_CONSTEXPR14 const_iterator lower_bound(const_key_reference key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 const_iterator lower_bound(const key_type& key) const ETL_NOEXCEPT
{
return etl::lower_bound(begin(), end(), key, vcompare);
}
@ -359,7 +354,7 @@ namespace etl
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
ETL_CONSTEXPR14 const_iterator upper_bound(const_key_reference key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 const_iterator upper_bound(const key_type& key) const ETL_NOEXCEPT
{
return etl::upper_bound(begin(), end(), key, vcompare);
}
@ -459,7 +454,7 @@ namespace etl
//*********************************************************************
/// Check to see if the keys are equal.
//*********************************************************************
ETL_CONSTEXPR14 bool keys_are_equal(const_key_reference key1, const_key_reference key2) const ETL_NOEXCEPT
ETL_CONSTEXPR14 bool keys_are_equal(const key_type& key1, const key_type& key2) const ETL_NOEXCEPT
{
return !key_compare()(key1, key2) && !key_compare()(key2, key1);
}
@ -500,10 +495,6 @@ namespace etl
using const_iterator = typename base_t::const_iterator;
using size_type = typename base_t::size_type;
/// Defines the parameter types
using const_key_reference = const key_type&;
using const_mapped_reference = const mapped_type&;
static_assert((etl::is_default_constructible<key_type>::value), "key_type must be default constructible");
static_assert((etl::is_default_constructible<mapped_type>::value), "mapped_type must be default constructible");
@ -555,10 +546,6 @@ namespace etl
using const_iterator = typename base_t::const_iterator;
using size_type = typename base_t::size_type;
/// Defines the parameter types
using const_key_reference = const key_type&;
using const_mapped_reference = const mapped_type&;
static_assert((etl::is_default_constructible<key_type>::value), "key_type must be default constructible");
static_assert((etl::is_default_constructible<mapped_type>::value), "mapped_type must be default constructible");
@ -607,7 +594,7 @@ namespace etl
ETL_CONSTEXPR14 bool operator ==(const etl::iconst_map<TKey, TMapped, TKeyCompare>& lhs,
const etl::iconst_map<TKey, TMapped, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return etl::equal(lhs.begin(), lhs.end(), rhs.begin());
return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//*************************************************************************

30
include/etl/const_multimap.h
View File

@ -64,10 +64,6 @@ namespace etl
using const_iterator = const value_type*;
using size_type = size_t;
/// Defines the parameter types
using const_key_reference = const key_type&;
using const_mapped_reference = const mapped_type&;
//*********************************************************************
/// How to compare elements and keys.
//*********************************************************************
@ -82,7 +78,7 @@ namespace etl
}
// Compare value type and key.
ETL_CONSTEXPR14 bool operator ()(const value_type& element, const_key_reference key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator ()(const value_type& element, const key_type& key) const ETL_NOEXCEPT
{
return kcompare(element.first, key);
}
@ -96,7 +92,7 @@ namespace etl
}
// Compare key and value type.
ETL_CONSTEXPR14 bool operator ()(const_key_reference key, const value_type& element) const ETL_NOEXCEPT
ETL_CONSTEXPR14 bool operator ()(const key_type& key, const value_type& element) const ETL_NOEXCEPT
{
return kcompare(key, element.first);
}
@ -173,7 +169,7 @@ namespace etl
///\return A <code>const_iterator</code> to the mapped value at the index,
/// or end() if not found.
//*************************************************************************
ETL_CONSTEXPR14 const_iterator find(const_key_reference key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 const_iterator find(const key_type& key) const ETL_NOEXCEPT
{
const_iterator itr = lower_bound(key);
@ -210,7 +206,7 @@ namespace etl
///\param key The key of the element to check.
///\return <b>true</b> if the map contains an element with key.
//*************************************************************************
ETL_CONSTEXPR14 bool contains(const_key_reference key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 bool contains(const key_type& key) const ETL_NOEXCEPT
{
return find(key) != end();
}
@ -232,7 +228,7 @@ namespace etl
///\param key The key of the element to count.
///\return 0 or 1
//*************************************************************************
ETL_CONSTEXPR14 size_type count(const_key_reference key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 size_type count(const key_type& key) const ETL_NOEXCEPT
{
auto range = equal_range(key);
@ -261,7 +257,7 @@ namespace etl
///\param key The key of the element
///\return etl::pair or std::pair containing a pair of iterators.
//*************************************************************************
ETL_CONSTEXPR14 ETL_OR_STD::pair<const_iterator, const_iterator> equal_range(const_key_reference key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 ETL_OR_STD::pair<const_iterator, const_iterator> equal_range(const key_type& key) const ETL_NOEXCEPT
{
return etl::equal_range(begin(), end(), key, vcompare);
}
@ -287,7 +283,7 @@ namespace etl
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
ETL_CONSTEXPR14 const_iterator lower_bound(const_key_reference key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 const_iterator lower_bound(const key_type& key) const ETL_NOEXCEPT
{
return etl::lower_bound(begin(), end(), key, vcompare);
}
@ -311,7 +307,7 @@ namespace etl
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
ETL_CONSTEXPR14 const_iterator upper_bound(const_key_reference key) const ETL_NOEXCEPT
ETL_CONSTEXPR14 const_iterator upper_bound(const key_type& key) const ETL_NOEXCEPT
{
return etl::upper_bound(begin(), end(), key, vcompare);
}
@ -411,7 +407,7 @@ namespace etl
//*********************************************************************
/// Check to see if the keys are equal.
//*********************************************************************
ETL_CONSTEXPR14 bool keys_are_equal(const_key_reference key1, const_key_reference key2) const ETL_NOEXCEPT
ETL_CONSTEXPR14 bool keys_are_equal(const key_type& key1, const key_type& key2) const ETL_NOEXCEPT
{
return !key_compare()(key1, key2) && !key_compare()(key2, key1);
}
@ -452,10 +448,6 @@ namespace etl
using const_iterator = typename base_t::const_iterator;
using size_type = typename base_t::size_type;
/// Defines the parameter types
using const_key_reference = const key_type&;
using const_mapped_reference = const mapped_type&;
static_assert((etl::is_default_constructible<key_type>::value), "key_type must be default constructible");
static_assert((etl::is_default_constructible<mapped_type>::value), "mapped_type must be default constructible");
@ -508,10 +500,6 @@ namespace etl
using const_iterator = typename base_t::const_iterator;
using size_type = typename base_t::size_type;
/// Defines the parameter types
using const_key_reference = const key_type&;
using const_mapped_reference = const mapped_type&;
static_assert((etl::is_default_constructible<key_type>::value), "key_type must be default constructible");
static_assert((etl::is_default_constructible<mapped_type>::value), "mapped_type must be default constructible");

574
include/etl/const_multiset.h Normal file
View File

@ -0,0 +1,574 @@
///\file
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2025 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#ifndef ETL_CONST_MULTISET_INCLUDED
#define ETL_CONST_MULTISET_INCLUDED
#include "platform.h"
#if ETL_NOT_USING_CPP11
#error NOT SUPPORTED FOR C++03 OR BELOW
#endif
#include "algorithm.h"
#include "type_traits.h"
#include "functional.h"
#include "nth_type.h"
#include "span.h"
#include "private/comparator_is_transparent.h"
///\defgroup const_multiset const_multiset
///\ingroup containers
namespace etl
{
template <typename TKey, typename TKeyCompare = etl::less<TKey>>
class iconst_multiset
{
public:
using key_type = TKey;
using value_type = TKey;
using key_compare = TKeyCompare;
using value_compare = TKeyCompare;
using const_reference = const value_type&;
using const_pointer = const value_type*;
using const_iterator = const value_type*;
using size_type = size_t;
//*************************************************************************
/// Check that the elements are valid for a multiset.
/// The elements must be sorted.
/// \return <b>true</b> if the elements are valid for the multiset.
//*************************************************************************
ETL_CONSTEXPR14 bool is_valid() const ETL_NOEXCEPT
{
return etl::is_sorted(begin(), end(), vcompare);
}
//*************************************************************************
///\brief Gets the beginning of the multiset.
///\return <code>const_iterator</code> to the beginning of the multiset.
//*************************************************************************
ETL_CONSTEXPR14 const_iterator begin() const ETL_NOEXCEPT
{
return element_list;
}
//*************************************************************************
///\brief Gets the beginning of the multiset.
///\return <code>const_iterator</code> to the beginning of the multiset.
//*************************************************************************
ETL_CONSTEXPR14 const_iterator cbegin() const ETL_NOEXCEPT
{
return element_list;
}
//*************************************************************************
///\brief Gets the end of the multiset.
///\return <code>const_iterator</code> to the end of the multiset.
//*************************************************************************
ETL_CONSTEXPR14 const_iterator end() const ETL_NOEXCEPT
{
return element_list_end;
}
//*************************************************************************
///\brief Gets the end of the multiset.
///\return <code>const_iterator</code> to the end of the multiset.
//*************************************************************************
ETL_CONSTEXPR14 const_iterator cend() const ETL_NOEXCEPT
{
return element_list_end;
}
//*************************************************************************
///\brief Gets the beginning of the multiset.
///\return <code>const_pointer</code> to the beginning of the multiset.
//*************************************************************************
ETL_CONSTEXPR14 const_pointer data() const ETL_NOEXCEPT
{
return element_list;
}
//*************************************************************************
///\brief Gets a const_iterator to the value at the key index.
///\param key The key of the element to find.
///\return A <code>const_iterator</code> to the value at the index,
/// or end() if not found.
//*************************************************************************
ETL_CONSTEXPR14 const_iterator find(const key_type& key) const ETL_NOEXCEPT
{
const_iterator itr = lower_bound(key);
if ((itr != end()) && (keys_are_equal(*itr, key)))
{
return itr;
}
return end();
}
//*************************************************************************
///\brief Gets a const_iterator to the value at the key index.
/// Enabled if the comparator is transparent.
///\param key The key of the element to find.
///\return A <code>const_iterator</code> to the value at the index,
/// or end() if not found.
//*************************************************************************
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 const_iterator find(const K& key) const ETL_NOEXCEPT
{
const_iterator itr = lower_bound(key);
if ((itr != end()) && (keys_are_equal(*itr, key)))
{
return itr;
}
return end();
}
//*************************************************************************
///\brief Checks if the multiset contains an element with key.
///\param key The key of the element to check.
///\return <b>true</b> if the multiset contains an element with key.
//*************************************************************************
ETL_CONSTEXPR14 bool contains(const key_type& key) const ETL_NOEXCEPT
{
return find(key) != end();
}
//*************************************************************************
///\brief Checks if the multiset contains an element with key.
/// Enabled if the comparator is transparent.
///\param key The key of the element to check.
///\return <b>true</b> if the multiset contains an element with key.
//*************************************************************************
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 bool contains(const K& key) const ETL_NOEXCEPT
{
return find(key) != end();
}
//*************************************************************************
///\brief Counts the numbeer elements with key.
///\param key The key of the element to count.
///\return 0 or 1
//*************************************************************************
ETL_CONSTEXPR14 size_type count(const key_type& key) const ETL_NOEXCEPT
{
auto range = equal_range(key);
return size_type(etl::distance(range.first, range.second));
}
//*************************************************************************
///\brief Counts the numbeer elements with key.
/// Enabled if the comparator is transparent.
///\param key The key of the element to count.
///\return 0 or 1
//*************************************************************************
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 size_type count(const K& key) const ETL_NOEXCEPT
{
auto range = equal_range(key);
return size_type(etl::distance(range.first, range.second));
}
//*************************************************************************
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
/// element greater than the key.
///\param key The key of the element
///\return etl::pair or std::pair containing a pair of iterators.
//*************************************************************************
ETL_CONSTEXPR14 ETL_OR_STD::pair<const_iterator, const_iterator> equal_range(const key_type& key) const ETL_NOEXCEPT
{
return etl::equal_range(begin(), end(), key, vcompare);
}
//*************************************************************************
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
/// element greater than the key.
/// Enabled if the comparator is transparent.
///\param key The key of the element
///\return etl::pair or std::pair containing a pair of iterators.
//*************************************************************************
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 ETL_OR_STD::pair<const_iterator, const_iterator> equal_range(const K& key) const ETL_NOEXCEPT
{
return etl::equal_range(begin(), end(), key, vcompare);
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is not less than the key.
/// Returns a const_iterator to the first element that is not less than the key.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
ETL_CONSTEXPR14 const_iterator lower_bound(const key_type& key) const ETL_NOEXCEPT
{
return etl::lower_bound(begin(), end(), key, vcompare);
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is not less than the key.
/// Returns a const_iterator to the first element that is not less than the key.
/// Enabled if the comparator is transparent.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 const_iterator lower_bound(const K& key) const ETL_NOEXCEPT
{
return etl::lower_bound(begin(), end(), key, vcompare);
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is greater than the key.
/// Returns a const_iterator to the first element that is greater than the key.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
ETL_CONSTEXPR14 const_iterator upper_bound(const key_type& key) const ETL_NOEXCEPT
{
return etl::upper_bound(begin(), end(), key, vcompare);
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is greater than the key.
/// Returns a const_iterator to the first element that is greater than the key.
/// Enabled if the comparator is transparent.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 const_iterator upper_bound(const K& key) const ETL_NOEXCEPT
{
return etl::upper_bound(begin(), end(), key, vcompare);
}
//*************************************************************************
/// Checks if the multiset is empty.
///\return <b>true</b> if the multiset is empty.
//*************************************************************************
ETL_CONSTEXPR14 size_type empty() const ETL_NOEXCEPT
{
return size() == 0U;
}
//*************************************************************************
/// Checks if the multiset is full.
///\return <b>true</b> if the multiset is full.
//*************************************************************************
ETL_CONSTEXPR14 size_type full() const ETL_NOEXCEPT
{
return (max_elements != 0) && (size() == max_elements);
}
//*************************************************************************
/// Gets the size of the multiset.
///\return The size of the multiset.
//*************************************************************************
ETL_CONSTEXPR14 size_type size() const ETL_NOEXCEPT
{
return size_type(element_list_end - element_list);
}
//*************************************************************************
/// Gets the maximum size of the multiset.
///\return The maximum size of the multiset.
//*************************************************************************
ETL_CONSTEXPR14 size_type max_size() const ETL_NOEXCEPT
{
return max_elements;
}
//*************************************************************************
/// Gets the capacity of the multiset.
/// This is always equal to max_size().
///\return The capacity of the multiset.
//*************************************************************************
ETL_CONSTEXPR14 size_type capacity() const ETL_NOEXCEPT
{
return max_elements;
}
//*************************************************************************
/// How to compare two key elements.
///\return An instance of the key_compare type.
//*************************************************************************
ETL_CONSTEXPR14 key_compare key_comp() const ETL_NOEXCEPT
{
return kcompare;
}
//*************************************************************************
/// How to compare two value elements.
///\return An instance of the value_compare type.
//*************************************************************************
ETL_CONSTEXPR14 value_compare value_comp() const ETL_NOEXCEPT
{
return vcompare;
}
protected:
//*************************************************************************
/// Constructor
//*************************************************************************
template <typename... TElements>
ETL_CONSTEXPR14 explicit iconst_multiset(const value_type* element_list_, size_type size_, size_type max_elements_) ETL_NOEXCEPT
: element_list(element_list_)
, element_list_end{element_list_ + size_}
, max_elements(max_elements_)
{
}
private:
//*********************************************************************
/// Check to see if the keys are equal.
//*********************************************************************
ETL_CONSTEXPR14 bool keys_are_equal(const key_type& key1, const key_type& key2) const ETL_NOEXCEPT
{
return !key_compare()(key1, key2) && !key_compare()(key2, key1);
}
//*********************************************************************
/// Check to see if the keys are equal.
/// Enabled if the comparator is transparent.
//*********************************************************************
template <typename K1, typename K2, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 bool keys_are_equal(const K1& key1, const K2& key2) const ETL_NOEXCEPT
{
return !key_compare()(key1, key2) && !key_compare()(key2, key1);
}
key_compare kcompare;
value_compare vcompare;
const value_type* element_list;
const value_type* element_list_end;
size_type max_elements;
};
//*************************************************************************
/// Multiset type designed for constexpr.
//*************************************************************************
template <typename TKey, size_t Size, typename TKeyCompare = etl::less<TKey>>
class const_multiset : public iconst_multiset<TKey, TKeyCompare>
{
public:
using base_t = iconst_multiset<TKey, TKeyCompare>;
using key_type = typename base_t::key_type;
using value_type = typename base_t::value_type;
using key_compare = typename base_t::key_compare;
using const_reference = typename base_t::const_reference;
using const_pointer = typename base_t::const_pointer;
using const_iterator = typename base_t::const_iterator;
using size_type = typename base_t::size_type;
static_assert((etl::is_default_constructible<key_type>::value), "key_type must be default constructible");
//*************************************************************************
///\brief Construct a const_set from a variadic list of elements.
/// Static asserts if the element type is not constructible.
/// Static asserts if the elements are not of type <code>value_type</code>.
/// Static asserts if the number of elements is greater than the capacity of the const_set.
//*************************************************************************
template <typename... TElements>
ETL_CONSTEXPR14 explicit const_multiset(TElements&&... elements) ETL_NOEXCEPT
: iconst_multiset<TKey, TKeyCompare>(element_list, sizeof...(elements), Size)
, element_list{etl::forward<TElements>(elements)...}
{
static_assert((etl::are_all_same<value_type, etl::decay_t<TElements>...>::value), "All elements must be value_type");
static_assert(sizeof...(elements) <= Size, "Number of elements exceeds capacity");
}
private:
value_type element_list[Size];
};
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
template <typename... TElements>
const_multiset(TElements...) -> const_multiset<etl::nth_type_t<0, TElements...>, sizeof...(TElements)>;
#endif
//*********************************************************************
/// Multiset type designed for constexpr.
//*********************************************************************
template <typename TKey, typename TKeyCompare = etl::less<TKey>>
class const_multiset_ext : public iconst_multiset<TKey, TKeyCompare>
{
public:
using base_t = iconst_multiset<TKey, TKeyCompare>;
using key_type = typename base_t::key_type;
using value_type = typename base_t::value_type;
using key_compare = typename base_t::key_compare;
using const_reference = typename base_t::const_reference;
using const_pointer = typename base_t::const_pointer;
using const_iterator = typename base_t::const_iterator;
using size_type = typename base_t::size_type;
static_assert((etl::is_default_constructible<key_type>::value), "key_type must be default constructible");
//*************************************************************************
///\brief Default construct a const_multiset.
//*************************************************************************
ETL_CONSTEXPR14 const_multiset_ext() ETL_NOEXCEPT
: iconst_multiset<TKey, TKeyCompare>(nullptr, 0, 0)
{
}
//*************************************************************************
///\brief Construct a const_multiset from a variadic list of elements.
//*************************************************************************
template <size_type Size>
ETL_CONSTEXPR14 explicit const_multiset_ext(const etl::span<const value_type, Size>& sp) ETL_NOEXCEPT
: iconst_multiset<TKey, TKeyCompare>(sp.data(), Size, Size)
{
}
//*************************************************************************
///\brief Construct a const_multiset from an array.
//*************************************************************************
template <size_type Size>
ETL_CONSTEXPR14 explicit const_multiset_ext(const value_type(&begin_)[Size]) ETL_NOEXCEPT
: iconst_multiset<TKey, TKeyCompare>(begin_, Size, Size)
{
}
};
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
template <typename TElements, size_t N>
const_multiset_ext(const etl::span<TElements, N>&) -> const_multiset_ext<typename TElements>;
template <typename TElements, size_t N>
const_multiset_ext(const TElements(&)[N]) -> const_multiset_ext<typename TElements>;
#endif
//*************************************************************************
/// Equality test.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator ==(const etl::iconst_multiset<TKey, TKeyCompare>& lhs,
const etl::iconst_multiset<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//*************************************************************************
/// Inequality test.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator !=(const etl::iconst_multiset<TKey, TKeyCompare>& lhs,
const etl::iconst_multiset<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return !(lhs == rhs);
}
//*************************************************************************
/// Less than operator.
///\param lhs Reference to the first list.
///\param rhs Reference to the second list.
///\return <b>true</b> if the first list is lexicographically less than the
/// second, otherwise <b>false</b>.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator <(const etl::iconst_multiset<TKey, TKeyCompare>& lhs,
const etl::iconst_multiset<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return etl::lexicographical_compare(lhs.begin(), lhs.end(),
rhs.begin(), rhs.end(),
lhs.value_comp());
}
//*************************************************************************
/// Greater than operator.
///\param lhs Reference to the first list.
///\param rhs Reference to the second list.
///\return <b>true</b> if the first list is lexicographically greater than the
/// second, otherwise <b>false</b>.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator >(const etl::iconst_multiset<TKey, TKeyCompare>& lhs,
const etl::iconst_multiset<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return (rhs < lhs);
}
//*************************************************************************
/// Less than or equal operator.
///\param lhs Reference to the first list.
///\param rhs Reference to the second list.
///\return <b>true</b> if the first list is lexicographically less than or equal
/// to the second, otherwise <b>false</b>.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator <=(const etl::iconst_multiset<TKey, TKeyCompare>& lhs,
const etl::iconst_multiset<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return !(rhs < lhs);
}
//*************************************************************************
/// Greater than or equal operator.
///\param lhs Reference to the first list.
///\param rhs Reference to the second list.
///\return <b>true</b> if the first list is lexicographically greater than or
/// equal to the second, otherwise <b>false</b>.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator >=(const etl::iconst_multiset<TKey, TKeyCompare>& lhs,
const etl::iconst_multiset<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return !(lhs < rhs);
}
}
#endif

554
include/etl/const_set.h Normal file
View File

@ -0,0 +1,554 @@
///\file
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2025 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#ifndef ETL_CONST_SET_INCLUDED
#define ETL_CONST_SET_INCLUDED
#include "platform.h"
#if ETL_NOT_USING_CPP11
#error NOT SUPPORTED FOR C++03 OR BELOW
#endif
#include "algorithm.h"
#include "type_traits.h"
#include "functional.h"
#include "nth_type.h"
#include "span.h"
#include "private/comparator_is_transparent.h"
///\defgroup const_set const_set
///\ingroup containers
namespace etl
{
template <typename TKey, typename TKeyCompare>
class iconst_set
{
public:
using key_type = TKey;
using value_type = TKey;
using key_compare = TKeyCompare;
using value_compare = TKeyCompare;
using const_reference = const value_type&;
using const_pointer = const value_type*;
using const_iterator = const value_type*;
using size_type = size_t;
//*************************************************************************
/// Check that the elements are valid for a set.
/// The elements must be sorted and contain no duplicates.
/// \return <b>true</b> if the elements are valid for the set.
//*************************************************************************
ETL_CONSTEXPR14 bool is_valid() const ETL_NOEXCEPT
{
return etl::is_unique_sorted(begin(), end(), vcompare);
}
//*************************************************************************
///\brief Returns a <code>const_iterator</code> to the beginning of the set.
//*************************************************************************
ETL_CONSTEXPR14 const_iterator begin() const ETL_NOEXCEPT
{
return element_list;
}
//*************************************************************************
///\brief Returns a <code>const_iterator</code> to the beginning of the set.
//*************************************************************************
ETL_CONSTEXPR14 const_iterator cbegin() const ETL_NOEXCEPT
{
return element_list;
}
//*************************************************************************
///\brief Returns a <code>const_iterator</code> to the end of the set.
//*************************************************************************
ETL_CONSTEXPR14 const_iterator end() const ETL_NOEXCEPT
{
return element_list_end;
}
//*************************************************************************
///\brief Returns a <code>const_iterator</code> to the end of the set.
//*************************************************************************
ETL_CONSTEXPR14 const_iterator cend() const ETL_NOEXCEPT
{
return element_list_end;
}
//*************************************************************************
///\brief Returns a <code>const_pointer</code> to the beginning of the set.
//*************************************************************************
ETL_CONSTEXPR14 const_pointer data() const ETL_NOEXCEPT
{
return element_list;
}
//*************************************************************************
///\brief Gets a const_iterator to the key.
///\param key The key of the element to find.
///\return A <code>const_iterator</code> to the key,
/// or end() if not found.
//*************************************************************************
ETL_CONSTEXPR14 const_iterator find(const key_type& key) const ETL_NOEXCEPT
{
const_iterator itr = lower_bound(key);
if ((itr != end()) && (keys_are_equal(*itr, key)))
{
return itr;
}
return end();
}
//*************************************************************************
///\brief Gets a const_iterator to the key.
/// Enabled if the comparator is transparent.
///\param key The key of the element to find.
///\return A <code>const_iterator</code> to the key,
/// or end() if not found.
//*************************************************************************
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 const_iterator find(const K& key) const ETL_NOEXCEPT
{
const_iterator itr = lower_bound(key);
if ((itr != end()) && (keys_are_equal(*itr, key)))
{
return itr;
}
return end();
}
//*************************************************************************
///\brief Checks if the set contains an element with key.
///\param key The key of the element to check.
///\return <b>true</b> if the set contains an element with key.
//*************************************************************************
ETL_CONSTEXPR14 bool contains(const key_type& key) const ETL_NOEXCEPT
{
return find(key) != end();
}
//*************************************************************************
///\brief Checks if the set contains an element with key.
/// Enabled if the comparator is transparent.
///\param key The key of the element to check.
///\return <b>true</b> if the set contains an element with key.
//*************************************************************************
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 bool contains(const K& key) const ETL_NOEXCEPT
{
return find(key) != end();
}
//*************************************************************************
///\brief Counts the numbeer elements with key.
///\param key The key of the element to count.
///\return 0 or 1
//*************************************************************************
ETL_CONSTEXPR14 size_type count(const key_type& key) const ETL_NOEXCEPT
{
return contains(key) ? 1 : 0;
}
//*************************************************************************
///\brief Counts the numbeer elements with key.
/// Enabled if the comparator is transparent.
///\param key The key of the element to count.
///\return 0 or 1
//*************************************************************************
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 size_type count(const K& key) const ETL_NOEXCEPT
{
return contains(key) ? 1 : 0;
}
//*************************************************************************
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
/// element greater than the key.
///\param key The key of the element
///\return etl::pair or std::pair containing a pair of iterators.
//*************************************************************************
ETL_CONSTEXPR14 ETL_OR_STD::pair<const_iterator, const_iterator> equal_range(const key_type& key) const ETL_NOEXCEPT
{
return etl::equal_range(begin(), end(), key, vcompare);
}
//*************************************************************************
///\brief Returns a range containing all elements with the key.
/// The range is defined by a pair of two iterators, one to the
/// first element that is not less than the key and second to the first
/// element greater than the key.
/// Enabled if the comparator is transparent.
///\param key The key of the element
///\return etl::pair or std::pair containing a pair of iterators.
//*************************************************************************
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 ETL_OR_STD::pair<const_iterator, const_iterator> equal_range(const K& key) const ETL_NOEXCEPT
{
return etl::equal_range(begin(), end(), key, vcompare);
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is not less than the key.
/// Returns a const_iterator to the first element that is not less than the key.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
ETL_CONSTEXPR14 const_iterator lower_bound(const key_type& key) const ETL_NOEXCEPT
{
return etl::lower_bound(begin(), end(), key, vcompare);
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is not less than the key.
/// Returns a const_iterator to the first element that is not less than the key.
/// Enabled if the comparator is transparent.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 const_iterator lower_bound(const K& key) const ETL_NOEXCEPT
{
return etl::lower_bound(begin(), end(), key, vcompare);
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is greater than the key.
/// Returns a const_iterator to the first element that is greater than the key.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
ETL_CONSTEXPR14 const_iterator upper_bound(const key_type& key) const ETL_NOEXCEPT
{
return etl::upper_bound(begin(), end(), key, vcompare);
}
//*************************************************************************
///\brief Returns a const_iterator to the first element that is greater than the key.
/// Returns a const_iterator to the first element that is greater than the key.
/// Enabled if the comparator is transparent.
///\param key The key of the element
///\return const_iterator to the element or end()
//*************************************************************************
template <typename K, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 const_iterator upper_bound(const K& key) const ETL_NOEXCEPT
{
return etl::upper_bound(begin(), end(), key, vcompare);
}
//*************************************************************************
/// Checks if the set is empty.
///\return <b>true</b> if the set is empty.
//*************************************************************************
ETL_CONSTEXPR14 size_type empty() const ETL_NOEXCEPT
{
return size() == 0U;
}
//*************************************************************************
/// Checks if the set is full.
///\return <b>true</b> if the set is full.
//*************************************************************************
ETL_CONSTEXPR14 size_type full() const ETL_NOEXCEPT
{
return (max_elements != 0) && (size() == max_elements);
}
//*************************************************************************
/// Gets the size of the set.
///\return The size of the set.
//*************************************************************************
ETL_CONSTEXPR14 size_type size() const ETL_NOEXCEPT
{
return size_type(element_list_end - element_list);
}
//*************************************************************************
/// Gets the maximum size of the set.
///\return The maximum size of the set.
//*************************************************************************
ETL_CONSTEXPR14 size_type max_size() const ETL_NOEXCEPT
{
return max_elements;
}
//*************************************************************************
/// Gets the capacity of the set.
/// This is always equal to max_size().
///\return The capacity of the set.
//*************************************************************************
ETL_CONSTEXPR14 size_type capacity() const ETL_NOEXCEPT
{
return max_elements;
}
//*************************************************************************
/// How to compare two key elements.
///\return An instance of the key_compare type.
//*************************************************************************
ETL_CONSTEXPR14 key_compare key_comp() const ETL_NOEXCEPT
{
return key_compare();
}
//*************************************************************************
/// How to compare two value elements.
///\return An instance of the value_compare type.
//*************************************************************************
ETL_CONSTEXPR14 value_compare value_comp() const ETL_NOEXCEPT
{
return value_compare();
}
protected:
//*************************************************************************
/// Constructor
//*************************************************************************
template <typename... TElements>
ETL_CONSTEXPR14 explicit iconst_set(const value_type* element_list_, size_type size_, size_type max_elements_) ETL_NOEXCEPT
: element_list(element_list_)
, element_list_end{element_list_ + size_}
, max_elements(max_elements_)
{
}
private:
//*********************************************************************
/// Check to see if the keys are equal.
//*********************************************************************
ETL_CONSTEXPR14 bool keys_are_equal(const_reference key1, const_reference key2) const ETL_NOEXCEPT
{
return !key_compare()(key1, key2) && !key_compare()(key2, key1);
}
//*********************************************************************
/// Check to see if the keys are equal.
/// Enabled if the comparator is transparent.
//*********************************************************************
template <typename K1, typename K2, typename KC = TKeyCompare, etl::enable_if_t<comparator_is_transparent<KC>::value, int> = 0>
ETL_CONSTEXPR14 bool keys_are_equal(const K1& key1, const K2& key2) const ETL_NOEXCEPT
{
return !key_compare()(key1, key2) && !key_compare()(key2, key1);
}
key_compare kcompare;
value_compare vcompare;
const value_type* element_list;
const value_type* element_list_end;
size_type max_elements;
};
//*********************************************************************
/// Map type designed for constexpr.
//*********************************************************************
template <typename TKey, size_t Size, typename TKeyCompare = etl::less<TKey>>
class const_set : public iconst_set<TKey, TKeyCompare>
{
public:
using base_t = iconst_set<TKey, TKeyCompare>;
using key_type = typename base_t::key_type;
using value_type = typename base_t::value_type;
using key_compare = typename base_t::key_compare;
using const_reference = typename base_t::const_reference;
using const_pointer = typename base_t::const_pointer;
using const_iterator = typename base_t::const_iterator;
using size_type = typename base_t::size_type;
/// Defines the parameter types
using const_key_reference = const key_type&;
static_assert((etl::is_default_constructible<key_type>::value), "key_type must be default constructible");
//*************************************************************************
///\brief Construct a const_set from a variadic list of elements.
/// Static asserts if the elements are not of type <code>value_type</code>.
/// Static asserts if the number of elements is greater than the capacity of the const_set.
//*************************************************************************
template <typename... TElements>
ETL_CONSTEXPR14 explicit const_set(TElements&&... elements) ETL_NOEXCEPT
: iconst_set<TKey, TKeyCompare>(element_list, sizeof...(elements), Size)
, element_list{etl::forward<TElements>(elements)...}
{
static_assert((etl::are_all_same<value_type, etl::decay_t<TElements>...>::value), "All elements must be key_type");
static_assert(sizeof...(elements) <= Size, "Number of elements exceeds capacity");
}
private:
value_type element_list[Size];
};
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
template <typename... TElements>
const_set(TElements...) -> const_set<etl::nth_type_t<0, TElements...>, sizeof...(TElements)>;
#endif
//*********************************************************************
/// Map type designed for constexpr.
//*********************************************************************
template <typename TKey, typename TKeyCompare = etl::less<TKey>>
class const_set_ext : public iconst_set<TKey, TKeyCompare>
{
public:
using base_t = iconst_set<TKey, TKeyCompare>;
using key_type = typename base_t::key_type;
using value_type = typename base_t::value_type;
using key_compare = typename base_t::key_compare;
using const_reference = typename base_t::const_reference;
using const_pointer = typename base_t::const_pointer;
using const_iterator = typename base_t::const_iterator;
using size_type = typename base_t::size_type;
/// Defines the parameter types
using const_reference = const key_type&;
static_assert((etl::is_default_constructible<key_type>::value), "key_type must be default constructible");
//*************************************************************************
///\brief Default construct a const_set.
//*************************************************************************
ETL_CONSTEXPR14 const_set_ext() ETL_NOEXCEPT
: iconst_set<TKey, TKeyCompare>(nullptr, 0, 0)
{
}
//*************************************************************************
///\brief Construct a const_set from a variadic list of elements.
//*************************************************************************
template <size_type Size>
ETL_CONSTEXPR14 explicit const_set_ext(const etl::span<const value_type, Size>& sp) ETL_NOEXCEPT
: iconst_set<TKey, TKeyCompare>(sp.data(), Size, Size)
{
}
//*************************************************************************
///\brief Construct a const_set from an array.
//*************************************************************************
template <size_type Size>
ETL_CONSTEXPR14 explicit const_set_ext(const value_type(&begin_)[Size]) ETL_NOEXCEPT
: iconst_set<TKey, TKeyCompare>(begin_, Size, Size)
{
}
};
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
template <typename TElements, size_t N>
const_set_ext(const etl::span<TElements, N>&) -> const_set_ext<TElements>;
template <typename TElements, size_t N>
const_set_ext(const TElements(&)[N]) -> const_set_ext<TElements>;
#endif
//*************************************************************************
/// Equality test.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator ==(const etl::iconst_set<TKey, TKeyCompare>& lhs,
const etl::iconst_set<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//*************************************************************************
/// Inequality test.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator !=(const etl::iconst_set<TKey, TKeyCompare>& lhs,
const etl::iconst_set<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return !(lhs == rhs);
}
//*************************************************************************
/// Less-than.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator <(const etl::iconst_set<TKey, TKeyCompare>& lhs,
const etl::iconst_set<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return etl::lexicographical_compare(lhs.begin(), lhs.end(),
rhs.begin(), rhs.end(),
lhs.value_comp());
}
//*************************************************************************
/// Greater-than.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator >(const etl::iconst_set<TKey, TKeyCompare>& lhs,
const etl::iconst_set<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return (rhs < lhs);
}
//*************************************************************************
/// Less-than-equal.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator <=(const etl::iconst_set<TKey, TKeyCompare>& lhs,
const etl::iconst_set<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return !(rhs < lhs);
}
//*************************************************************************
/// Greater-than-equal.
//*************************************************************************
template <typename TKey, typename TKeyCompare>
ETL_CONSTEXPR14 bool operator >=(const etl::iconst_set<TKey, TKeyCompare>& lhs,
const etl::iconst_set<TKey, TKeyCompare>& rhs) ETL_NOEXCEPT
{
return !(lhs < rhs);
}
}
#endif

1
include/etl/crc.h
View File

@ -45,6 +45,7 @@ SOFTWARE.
#include "crc8_maxim.h"
#include "crc8_rohc.h"
#include "crc8_wcdma.h"
#include "crc8_nrsc5.h"
#include "crc16.h"
#include "crc16_a.h"

76
include/etl/crc8_nrsc5.h Normal file
View File

@ -0,0 +1,76 @@
///\file
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2021 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#ifndef ETL_CRC8_NRSC5_INCLUDED
#define ETL_CRC8_NRSC5_INCLUDED
#include "platform.h"
#include "private/crc_implementation.h"
namespace etl
{
#if ETL_USING_CPP11 && !defined(ETL_CRC_FORCE_CPP03_IMPLEMENTATION)
template <size_t Table_Size>
using crc8_nrsc5_t = etl::crc_type<etl::private_crc::crc8_nrsc5_parameters, Table_Size>;
#else
template <size_t Table_Size>
class crc8_nrsc5_t : public etl::crc_type<etl::private_crc::crc8_nrsc5_parameters, Table_Size>
{
public:
//*************************************************************************
/// Default constructor.
//*************************************************************************
crc8_nrsc5_t()
{
this->reset();
}
//*************************************************************************
/// Constructor from range.
/// \param begin Start of the range.
/// \param end End of the range.
//*************************************************************************
template<typename TIterator>
crc8_nrsc5_t(TIterator begin, const TIterator end)
{
this->reset();
this->add(begin, end);
}
};
#endif
typedef crc8_nrsc5_t<256U> crc8_nrsc5_t256;
typedef crc8_nrsc5_t<16U> crc8_nrsc5_t16;
typedef crc8_nrsc5_t<4U> crc8_nrsc5_t4;
typedef crc8_nrsc5_t256 crc8_nrsc5;
}
#endif

1
include/etl/private/crc_parameters.h
View File

@ -81,6 +81,7 @@ namespace etl
typedef crc_parameters<uint8_t, 0x9BU, 0x00U, 0x00U, true> crc8_wcdma_parameters;
typedef crc_parameters<uint8_t, 0x1DU, 0xFFU, 0xFFU, false> crc8_j1850_parameters;
typedef crc_parameters<uint8_t, 0x1DU, 0x00U, 0x00U, false> crc8_j1850_zero_parameters;
typedef crc_parameters<uint8_t, 0x31U, 0xFFU, 0x00U, false> crc8_nrsc5_parameters;
// 16 bit.
typedef crc_parameters<uint16_t, 0x8005U, 0x0000U, 0x0000U, true> crc16_parameters;

8
test/CMakeLists.txt
View File

@ -139,8 +139,10 @@ add_executable(etl_tests
test_crc8_j1850.cpp
test_crc8_j1850_zero.cpp
test_crc8_maxim.cpp
test_crc8_nrsc5.cpp
test_crc8_rohc.cpp
test_crc8_wcdma.cpp
test_crc8_nrsc5.cpp
test_cyclic_value.cpp
test_debounce.cpp
test_delegate.cpp
@ -364,9 +366,11 @@ elseif (ETL_CXX_STANDARD MATCHES "17")
elseif (ETL_CXX_STANDARD MATCHES "20")
message(STATUS "Compiling for C++20")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 20)
else()
elseif (ETL_CXX_STANDARD MATCHES "23")
message(STATUS "Compiling for C++23")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 23)
else()
message(STATUS "Unsupported C++ standard")
endif()
if (NO_STL OR ETL_NO_STL)
@ -392,7 +396,7 @@ if (ETL_MESSAGES_ARE_NOT_VIRTUAL)
endif()
if (ETL_FORCE_TEST_CPP03_IMPLEMENTATION)
message(STATUS "Compiling for C++03 tests")
message(STATUS "Compiling for forced C++03 tests")
target_compile_definitions(etl_tests PRIVATE -DETL_FORCE_TEST_CPP03_IMPLEMENTATION)
endif()

29
test/test_const_map.cpp
View File

@ -5,7 +5,7 @@ Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2025 John Wellbelove, rlindeman
Copyright(c) 2025 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the 'Software'), to deal
@ -84,7 +84,7 @@ namespace
return (lhs < rhs.k);
}
// Greater-than operator for char > Key
// Equality operator for Key == Key
constexpr bool operator ==(const Key& lhs, const Key& rhs) noexcept
{
return (lhs.k == rhs.k);
@ -93,13 +93,17 @@ namespace
#define TEST_GREATER_THAN
#ifdef TEST_GREATER_THAN
using Data = etl::const_map<Key, int, Max_Size, etl::greater<Key>>;
using Data2 = etl::const_map<Key, int, Max_Size + 1, etl::greater<Key>>;
using IData = etl::iconst_map<Key, int, etl::greater<Key>>;
using DataTransparentComparator = etl::const_map<Key, int, Max_Size, etl::greater<>>;
using DataTransparentComparator2 = etl::const_map<Key, int, Max_Size + 1, etl::greater<>>;
using IDataTransparentComparator = etl::iconst_map<Key, int, etl::greater<>>;
#else
using Data = etl::const_map<Key, int, Max_Size, etl::less<Key>>;
using Data2 = etl::const_map<Key, int, Max_Size + 1, etl::less<Key>>;
using IData = etl::iconst_map<Key, int, etl::less<Key>>;
using DataTransparentComparator = etl::const_map<Key, int, Max_Size, etl::less<>>;
using DataTransparentComparator2 = etl::const_map<Key, int, Max_Size + 1, etl::less<>>;
using IDataTransparentComparator = etl::iconst_map<Key, int, etl::less<>>;
#endif
@ -1234,11 +1238,16 @@ namespace
static const Data data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const Data2 data4{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static const bool equal12 = (data1 == data2);
static const bool equal13 = (data1 == data3);
static const bool equal14 = (data1 == data4);
CHECK_TRUE(equal12);
CHECK_FALSE(equal13);
CHECK_FALSE(equal14);
}
//*************************************************************************
@ -1253,11 +1262,16 @@ namespace
static const DataTransparentComparator data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const DataTransparentComparator2 data4{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static const bool equal12 = (data1 == data2);
static const bool equal13 = (data1 == data3);
static const bool equal14 = (data1 == data4);
CHECK_TRUE(equal12);
CHECK_FALSE(equal13);
CHECK_FALSE(equal14);
}
//*************************************************************************
@ -1272,11 +1286,16 @@ namespace
static const Data data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const Data2 data4{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static const bool not_equal12 = (data1 != data2);
static const bool not_equal13 = (data1 != data3);
static const bool not_equal14 = (data1 != data4);
CHECK_FALSE(not_equal12);
CHECK_TRUE(not_equal13);
CHECK_TRUE(not_equal14);
}
//*************************************************************************
@ -1291,11 +1310,17 @@ namespace
static const DataTransparentComparator data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const DataTransparentComparator2 data4{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static const bool not_equal12 = (data1 != data2);
static const bool not_equal13 = (data1 != data3);
static const bool not_equal14 = (data1 != data4);
CHECK_FALSE(not_equal12);
CHECK_TRUE(not_equal13);
CHECK_TRUE(not_equal14);
}
//*************************************************************************

32
test/test_const_map_constexpr.cpp
View File

@ -5,7 +5,7 @@ Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2025 John Wellbelove, rlindeman
Copyright(c) 2025 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the 'Software'), to deal
@ -35,7 +35,6 @@ SOFTWARE.
#include <iterator>
#include <string>
#include <vector>
#include <span>
#include "etl/const_map.h"
#include "etl/map.h"
@ -87,7 +86,7 @@ namespace
return (lhs < rhs.k);
}
// Greater-than operator for char > Key
// Equality operator for Key == Key
constexpr bool operator ==(const Key& lhs, const Key& rhs) noexcept
{
return (lhs.k == rhs.k);
@ -96,13 +95,17 @@ namespace
#define TEST_GREATER_THAN
#ifdef TEST_GREATER_THAN
using Data = etl::const_map<Key, int, Max_Size, etl::greater<Key>>;
using Data2 = etl::const_map<Key, int, Max_Size + 1, etl::greater<Key>>;
using IData = etl::iconst_map<Key, int, etl::greater<Key>>;
using DataTransparentComparator = etl::const_map<Key, int, Max_Size, etl::greater<>>;
using DataTransparentComparator2 = etl::const_map<Key, int, Max_Size + 1, etl::greater<>>;
using IDataTransparentComparator = etl::iconst_map<Key, int, etl::greater<>>;
#else
using Data = etl::const_map<Key, int, Max_Size, etl::less<Key>>;
using Data2 = etl::const_map<Key, int, Max_Size + 1, etl::less<Key>>;
using IData = etl::iconst_map<Key, int, etl::less<Key>>;
using DataTransparentComparator = etl::const_map<Key, int, Max_Size, etl::less<>>;
using DataTransparentComparator2 = etl::const_map<Key, int, Max_Size + 1, etl::less<>>;
using IDataTransparentComparator = etl::iconst_map<Key, int, etl::less<>>;
#endif
@ -111,7 +114,7 @@ namespace
using mapped_type = Data::mapped_type;
using const_iterator = Data::const_iterator;
SUITE(test_const_map)
SUITE(test_const_map_constexpr)
{
//*************************************************************************
TEST(test_default_constructor)
@ -1237,11 +1240,16 @@ namespace
static constexpr Data data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static constexpr Data2 data4{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static constexpr bool equal12 = (data1 == data2);
static constexpr bool equal13 = (data1 == data3);
static constexpr bool equal14 = (data1 == data4);
CHECK_TRUE(equal12);
CHECK_FALSE(equal13);
CHECK_FALSE(equal14);
}
//*************************************************************************
@ -1256,11 +1264,16 @@ namespace
static constexpr DataTransparentComparator data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static constexpr DataTransparentComparator2 data4{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static constexpr bool equal12 = (data1 == data2);
static constexpr bool equal13 = (data1 == data3);
static constexpr bool equal14 = (data1 == data4);
CHECK_TRUE(equal12);
CHECK_FALSE(equal13);
CHECK_FALSE(equal14);
}
//*************************************************************************
@ -1275,11 +1288,16 @@ namespace
static constexpr Data data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static constexpr Data2 data4{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static constexpr bool not_equal12 = (data1 != data2);
static constexpr bool not_equal13 = (data1 != data3);
static constexpr bool not_equal14 = (data1 != data4);
CHECK_FALSE(not_equal12);
CHECK_TRUE(not_equal13);
CHECK_TRUE(not_equal14);
}
//*************************************************************************
@ -1294,11 +1312,17 @@ namespace
static constexpr DataTransparentComparator data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static constexpr DataTransparentComparator2 data4{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static constexpr bool not_equal12 = (data1 != data2);
static constexpr bool not_equal13 = (data1 != data3);
static constexpr bool not_equal14 = (data1 != data4);
CHECK_FALSE(not_equal12);
CHECK_TRUE(not_equal13);
CHECK_TRUE(not_equal14);
}
//*************************************************************************

34
test/test_const_map_ext.cpp
View File

@ -5,7 +5,7 @@ Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2025 John Wellbelove, rlindeman
Copyright(c) 2025 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the 'Software'), to deal
@ -83,7 +83,7 @@ namespace
return (lhs < rhs.k);
}
// Greater-than operator for char > Key
// Equality operator for Key == Key
constexpr bool operator ==(const Key& lhs, const Key& rhs) noexcept
{
return (lhs.k == rhs.k);
@ -96,9 +96,9 @@ namespace
using DataTransparentComparator = etl::const_map_ext<Key, int, etl::greater<>>;
using IDataTransparentComparator = etl::iconst_map<Key, int, etl::greater<>>;
#else
using Data = etl::const_map<Key, int, etl::less<Key>>;
using Data = etl::const_map_ext<Key, int, etl::less<Key>>;
using IData = etl::iconst_map<Key, int, etl::less<Key>>;
using DataTransparentComparator = etl::const_map<Key, int, etl::less<>>;
using DataTransparentComparator = etl::const_map_ext<Key, int, etl::less<>>;
using IDataTransparentComparator = etl::iconst_map<Key, int, etl::less<>>;
#endif
@ -108,7 +108,7 @@ namespace
using const_iterator = Data::const_iterator;
using span_type = etl::span<const value_type, Max_Size>;
SUITE(test_const_map)
SUITE(test_const_map_ext)
{
//*************************************************************************
TEST(test_default_constructor)
@ -1322,15 +1322,21 @@ namespace
static const value_type values3[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const value_type values4[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static const Data data1{values1};
static const Data data2{values2};
static const Data data3{values3};
static const Data data4{values4};
static const bool equal12 = (data1 == data2);
static const bool equal13 = (data1 == data3);
static const bool equal14 = (data1 == data4);
CHECK_TRUE(equal12);
CHECK_FALSE(equal13);
CHECK_FALSE(equal14);
}
//*************************************************************************
@ -1345,15 +1351,21 @@ namespace
static const value_type values3[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const value_type values4[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static const DataTransparentComparator data1{values1};
static const DataTransparentComparator data2{values2};
static const DataTransparentComparator data3{values3};
static const DataTransparentComparator data4{values4};
static const bool equal12 = (data1 == data2);
static const bool equal13 = (data1 == data3);
static const bool equal14 = (data1 == data4);
CHECK_TRUE(equal12);
CHECK_FALSE(equal13);
CHECK_FALSE(equal14);
}
//*************************************************************************
@ -1368,15 +1380,21 @@ namespace
static const value_type values3[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const value_type values4[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static const Data data1{values1};
static const Data data2{values2};
static const Data data3{values3};
static const Data data4{values4};
static const bool not_equal12 = (data1 != data2);
static const bool not_equal13 = (data1 != data3);
static const bool not_equal14 = (data1 != data4);
CHECK_FALSE(not_equal12);
CHECK_TRUE(not_equal13);
CHECK_TRUE(not_equal14);
}
//*************************************************************************
@ -1391,15 +1409,21 @@ namespace
static const value_type values3[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const value_type values4[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static const DataTransparentComparator data1{values1};
static const DataTransparentComparator data2{values2};
static const DataTransparentComparator data3{values3};
static const DataTransparentComparator data4{values4};
static const bool not_equal12 = (data1 != data2);
static const bool not_equal13 = (data1 != data3);
static const bool not_equal14 = (data1 != data4);
CHECK_FALSE(not_equal12);
CHECK_TRUE(not_equal13);
CHECK_TRUE(not_equal14);
}
//*************************************************************************

36
test/test_const_map_ext_constexpr.cpp
View File

@ -5,7 +5,7 @@ Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2025 John Wellbelove, rlindeman
Copyright(c) 2025 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the 'Software'), to deal
@ -83,7 +83,7 @@ namespace
return (lhs < rhs.k);
}
// Greater-than operator for char > Key
// Equality operator for Key == Key
constexpr bool operator ==(const Key& lhs, const Key& rhs) noexcept
{
return (lhs.k == rhs.k);
@ -96,9 +96,9 @@ namespace
using DataTransparentComparator = etl::const_map_ext<Key, int, etl::greater<>>;
using IDataTransparentComparator = etl::iconst_map<Key, int, etl::greater<>>;
#else
using Data = etl::const_map<Key, int, etl::less<Key>>;
using Data = etl::const_map_ext<Key, int, etl::less<Key>>;
using IData = etl::iconst_map<Key, int, etl::less<Key>>;
using DataTransparentComparator = etl::const_map<Key, int, etl::less<>>;
using DataTransparentComparator = etl::const_map_ext<Key, int, etl::less<>>;
using IDataTransparentComparator = etl::iconst_map<Key, int, etl::less<>>;
#endif
@ -108,7 +108,7 @@ namespace
using const_iterator = Data::const_iterator;
using span_type = etl::span<const value_type, Max_Size>;
SUITE(test_const_map)
SUITE(test_const_map_ext_constexpr)
{
//*************************************************************************
TEST(test_default_constructor)
@ -234,7 +234,7 @@ namespace
static constexpr Data data{ values };
static const constexpr IData& idata = data;
static constexpr const IData& idata = data;
static constexpr bool is_valid = idata.is_valid();
static constexpr size_t size = idata.size();
@ -1322,15 +1322,21 @@ namespace
static constexpr value_type values3[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static constexpr value_type values4[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static constexpr Data data1{values1};
static constexpr Data data2{values2};
static constexpr Data data3{values3};
static constexpr Data data4{values4};
static constexpr bool equal12 = (data1 == data2);
static constexpr bool equal13 = (data1 == data3);
static constexpr bool equal14 = (data1 == data4);
CHECK_TRUE(equal12);
CHECK_FALSE(equal13);
CHECK_FALSE(equal14);
}
//*************************************************************************
@ -1345,15 +1351,21 @@ namespace
static constexpr value_type values3[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static constexpr value_type values4[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static constexpr DataTransparentComparator data1{values1};
static constexpr DataTransparentComparator data2{values2};
static constexpr DataTransparentComparator data3{values3};
static constexpr DataTransparentComparator data4{values4};
static constexpr bool equal12 = (data1 == data2);
static constexpr bool equal13 = (data1 == data3);
static constexpr bool equal14 = (data1 == data4);
CHECK_TRUE(equal12);
CHECK_FALSE(equal13);
CHECK_FALSE(equal14);
}
//*************************************************************************
@ -1368,15 +1380,21 @@ namespace
static constexpr value_type values3[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static constexpr value_type values4[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static constexpr Data data1{values1};
static constexpr Data data2{values2};
static constexpr Data data3{values3};
static constexpr Data data4{values4};
static constexpr bool not_equal12 = (data1 != data2);
static constexpr bool not_equal13 = (data1 != data3);
static constexpr bool not_equal14 = (data1 != data4);
CHECK_FALSE(not_equal12);
CHECK_TRUE(not_equal13);
CHECK_TRUE(not_equal14);
}
//*************************************************************************
@ -1391,15 +1409,21 @@ namespace
static constexpr value_type values3[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static constexpr value_type values4[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static constexpr DataTransparentComparator data1{values1};
static constexpr DataTransparentComparator data2{values2};
static constexpr DataTransparentComparator data3{values3};
static constexpr DataTransparentComparator data4{values4};
static constexpr bool not_equal12 = (data1 != data2);
static constexpr bool not_equal13 = (data1 != data3);
static constexpr bool not_equal14 = (data1 != data4);
CHECK_FALSE(not_equal12);
CHECK_TRUE(not_equal13);
CHECK_TRUE(not_equal14);
}
//*************************************************************************

66
test/test_const_multimap.cpp
View File

@ -5,7 +5,7 @@ Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2025 John Wellbelove, rlindeman
Copyright(c) 2025 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the 'Software'), to deal
@ -83,7 +83,7 @@ namespace
return (lhs < rhs.k);
}
// Greater-than operator for char > Key
// Equality operator for Key == Key
constexpr bool operator ==(const Key& lhs, const Key& rhs) noexcept
{
return (lhs.k == rhs.k);
@ -92,13 +92,17 @@ namespace
#define TEST_GREATER_THAN
#ifdef TEST_GREATER_THAN
using Data = etl::const_multimap<Key, int, Max_Size, etl::greater<Key>>;
using Data2 = etl::const_multimap<Key, int, Max_Size + 1, etl::greater<Key>>;
using IData = etl::iconst_multimap<Key, int, etl::greater<Key>>;
using DataTransparentComparator = etl::const_multimap<Key, int, Max_Size, etl::greater<>>;
using DataTransparentComparator2 = etl::const_multimap<Key, int, Max_Size + 1, etl::greater<>>;
using IDataTransparentComparator = etl::iconst_multimap<Key, int, etl::greater<>>;
#else
using Data = etl::const_multimap<Key, int, Max_Size, etl::less<Key>>;
using Data2 = etl::const_multimap<Key, int, Max_Size + 1, etl::less<Key>>;
using IData = etl::iconst_multimap<Key, int, etl::less<Key>>;
using DataTransparentComparator = etl::const_multimap<Key, int, Max_Size, etl::less<>>;
using DataTransparentComparator2 = etl::const_multimap<Key, int, Max_Size + 1, etl::less<>>;
using IDataTransparentComparator = etl::iconst_multimap<Key, int, etl::less<>>;
#endif
@ -970,6 +974,54 @@ namespace
#endif
}
//*************************************************************************
TEST(test_equal)
{
static const Data data1{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const Data data2{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const Data data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const Data2 data4{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static const bool equal12 = (data1 == data2);
static const bool equal13 = (data1 == data3);
static const bool equal14 = (data1 == data4);
CHECK_TRUE(equal12);
CHECK_FALSE(equal13);
CHECK_FALSE(equal14);
}
//*************************************************************************
TEST(test_equal_with_transparent_comparator)
{
static const DataTransparentComparator data1{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const DataTransparentComparator data2{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const DataTransparentComparator data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const DataTransparentComparator2 data4{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static const bool equal12 = (data1 == data2);
static const bool equal13 = (data1 == data3);
static const bool equal14 = (data1 == data4);
CHECK_TRUE(equal12);
CHECK_FALSE(equal13);
CHECK_FALSE(equal14);
}
//*************************************************************************
TEST(test_not_equal)
{
@ -982,11 +1034,16 @@ namespace
static const Data data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const Data2 data4{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static const bool not_equal12 = (data1 != data2);
static const bool not_equal13 = (data1 != data3);
static const bool not_equal14 = (data1 != data4);
CHECK_FALSE(not_equal12);
CHECK_TRUE(not_equal13);
CHECK_TRUE(not_equal14);
}
//*************************************************************************
@ -1001,11 +1058,16 @@ namespace
static const DataTransparentComparator data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const DataTransparentComparator2 data4{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static const bool not_equal12 = (data1 != data2);
static const bool not_equal13 = (data1 != data3);
static const bool not_equal14 = (data1 != data4);
CHECK_FALSE(not_equal12);
CHECK_TRUE(not_equal13);
CHECK_TRUE(not_equal14);
}
//*************************************************************************

30
test/test_const_multimap_constexpr.cpp
View File

@ -5,7 +5,7 @@ Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2025 John Wellbelove, rlindeman
Copyright(c) 2025 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the 'Software'), to deal
@ -85,7 +85,7 @@ namespace
return (lhs < rhs.k);
}
// Greater-than operator for char > Key
// Equality operator for Key == Key
constexpr bool operator ==(const Key& lhs, const Key& rhs) noexcept
{
return (lhs.k == rhs.k);
@ -94,13 +94,17 @@ namespace
#define TEST_GREATER_THAN
#ifdef TEST_GREATER_THAN
using Data = etl::const_multimap<Key, int, Max_Size, etl::greater<Key>>;
using Data2 = etl::const_multimap<Key, int, Max_Size + 1, etl::greater<Key>>;
using IData = etl::iconst_multimap<Key, int, etl::greater<Key>>;
using DataTransparentComparator = etl::const_multimap<Key, int, Max_Size, etl::greater<>>;
using DataTransparentComparator2 = etl::const_multimap<Key, int, Max_Size + 1, etl::greater<>>;
using IDataTransparentComparator = etl::iconst_multimap<Key, int, etl::greater<>>;
#else
using Data = etl::const_multimap<Key, int, Max_Size, etl::less<Key>>;
using Data2 = etl::const_multimap<Key, int, Max_Size + 1, etl::less<Key>>;
using IData = etl::iconst_multimap<Key, int, etl::less<Key>>;
using DataTransparentComparator = etl::const_multimap<Key, int, Max_Size, etl::less<>>;
using DataTransparentComparator2 = etl::const_multimap<Key, int, Max_Size + 1, etl::less<>>;
using IDataTransparentComparator = etl::iconst_multimap<Key, int, etl::less<>>;
#endif
@ -109,7 +113,7 @@ namespace
using mapped_type = Data::mapped_type;
using const_iterator = Data::const_iterator;
SUITE(test_const_multimap)
SUITE(test_const_multimap_constexpr)
{
//*************************************************************************
TEST(test_default_constructor)
@ -915,11 +919,16 @@ namespace
static constexpr Data data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static constexpr Data2 data4{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static constexpr bool equal12 = (data1 == data2);
static constexpr bool equal13 = (data1 == data3);
static constexpr bool equal14 = (data1 == data4);
CHECK_TRUE(equal12);
CHECK_FALSE(equal13);
CHECK_FALSE(equal14);
}
//*************************************************************************
@ -934,11 +943,16 @@ namespace
static constexpr DataTransparentComparator data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static constexpr DataTransparentComparator2 data4{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static constexpr bool equal12 = (data1 == data2);
static constexpr bool equal13 = (data1 == data3);
static constexpr bool equal14 = (data1 == data4);
CHECK_TRUE(equal12);
CHECK_FALSE(equal13);
CHECK_FALSE(equal14);
}
//*************************************************************************
@ -953,11 +967,16 @@ namespace
static constexpr Data data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static constexpr Data2 data4{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static constexpr bool not_equal12 = (data1 != data2);
static constexpr bool not_equal13 = (data1 != data3);
static constexpr bool not_equal14 = (data1 != data4);
CHECK_FALSE(not_equal12);
CHECK_TRUE(not_equal13);
CHECK_TRUE(not_equal14);
}
//*************************************************************************
@ -972,11 +991,16 @@ namespace
static constexpr DataTransparentComparator data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static constexpr DataTransparentComparator2 data4{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static constexpr bool not_equal12 = (data1 != data2);
static constexpr bool not_equal13 = (data1 != data3);
static constexpr bool not_equal14 = (data1 != data4);
CHECK_FALSE(not_equal12);
CHECK_TRUE(not_equal13);
CHECK_TRUE(not_equal14);
}
//*************************************************************************

33
test/test_const_multimap_ext.cpp
View File

@ -5,7 +5,7 @@ Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2025 John Wellbelove, rlindeman
Copyright(c) 2025 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the 'Software'), to deal
@ -83,7 +83,7 @@ namespace
return (lhs < rhs.k);
}
// Greater-than operator for char > Key
// Equality operator for Key == Key
constexpr bool operator ==(const Key& lhs, const Key& rhs) noexcept
{
return (lhs.k == rhs.k);
@ -98,7 +98,7 @@ namespace
#else
using Data = etl::const_multimap_ext<Key, int, etl::less<Key>>;
using IData = etl::iconst_multimap<Key, int, etl::less<Key>>;
using DataTransparentComparator = etl::const_multimap_ext<Key, inte, etl::less<>>;
using DataTransparentComparator = etl::const_multimap_ext<Key, int, etl::less<>>;
using IDataTransparentComparator = etl::iconst_multimap<Key, int, etl::less<>>;
#endif
@ -108,7 +108,7 @@ namespace
using const_iterator = Data::const_iterator;
using span_type = etl::span<const value_type, Max_Size>;
SUITE(test_const_multimap)
SUITE(test_const_multimap_ext)
{
//*************************************************************************
TEST(test_default_constructor)
@ -1128,15 +1128,21 @@ namespace
static const value_type values3[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const value_type values4[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static const Data data1{values1};
static const Data data2{values2};
static const Data data3{values3};
static const Data data4{values4};
static const bool equal12 = (data1 == data2);
static const bool equal13 = (data1 == data3);
static const bool equal14 = (data1 == data4);
CHECK_TRUE(equal12);
CHECK_FALSE(equal13);
CHECK_FALSE(equal14);
}
//*************************************************************************
@ -1151,15 +1157,21 @@ namespace
static const value_type values3[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const value_type values4[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static const DataTransparentComparator data1{values1};
static const DataTransparentComparator data2{values2};
static const DataTransparentComparator data3{values3};
static const DataTransparentComparator data4{values4};
static const bool equal12 = (data1 == data2);
static const bool equal13 = (data1 == data3);
static const bool equal14 = (data1 == data4);
CHECK_TRUE(equal12);
CHECK_FALSE(equal13);
CHECK_FALSE(equal14);
}
//*************************************************************************
@ -1174,15 +1186,21 @@ namespace
static const value_type values3[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const value_type values4[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static const Data data1{values1};
static const Data data2{values2};
static const Data data3{values3};
static const Data data4{values4};
static const bool not_equal12 = (data1 != data2);
static const bool not_equal13 = (data1 != data3);
static const bool not_equal14 = (data1 != data4);
CHECK_FALSE(not_equal12);
CHECK_TRUE(not_equal13);
CHECK_TRUE(not_equal14);
}
//*************************************************************************
@ -1197,15 +1215,22 @@ namespace
static const value_type values3[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static const value_type values4[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static const DataTransparentComparator data1{values1};
static const DataTransparentComparator data2{values2};
static const DataTransparentComparator data3{values3};
static const DataTransparentComparator data4{values4};
static const bool not_equal12 = (data1 != data2);
static const bool not_equal13 = (data1 != data3);
static const bool not_equal14 = (data1 != data4);
CHECK_FALSE(not_equal12);
CHECK_TRUE(not_equal13);
CHECK_TRUE(not_equal14);
}
//*************************************************************************

63
test/test_const_multimap_ext_constexpr.cpp
View File

@ -5,7 +5,7 @@ Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2025 John Wellbelove, rlindeman
Copyright(c) 2025 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the 'Software'), to deal
@ -83,7 +83,7 @@ namespace
return (lhs < rhs.k);
}
// Greater-than operator for char > Key
// Equality operator for Key == Key
constexpr bool operator ==(const Key& lhs, const Key& rhs) noexcept
{
return (lhs.k == rhs.k);
@ -98,7 +98,7 @@ namespace
#else
using Data = etl::const_multimap_ext<Key, int, etl::less<Key>>;
using IData = etl::iconst_multimap<Key, int, etl::less<Key>>;
using DataTransparentComparator = etl::const_multimap_ext<Key, inte, etl::less<>>;
using DataTransparentComparator = etl::const_multimap_ext<Key, int, etl::less<>>;
using IDataTransparentComparator = etl::iconst_multimap<Key, int, etl::less<>>;
#endif
@ -108,7 +108,7 @@ namespace
using const_iterator = Data::const_iterator;
using span_type = etl::span<const value_type, Max_Size>;
SUITE(test_const_multimap)
SUITE(test_const_multimap_ext_constexpr)
{
//*************************************************************************
TEST(test_default_constructor)
@ -162,24 +162,24 @@ namespace
TEST(test_constructor_max_size_from_span)
{
#ifdef TEST_GREATER_THAN
static const value_type values[]{ value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, value_type{Key('F'), 5 },
value_type{Key('E'), 4 }, value_type{Key('D'), 3 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } };
static constexpr value_type values[]{ value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, value_type{Key('F'), 5 },
value_type{Key('E'), 4 }, value_type{Key('D'), 3 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } };
#else
static const value_type values[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static constexpr value_type values[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
#endif
static const span_type span(values);
static const Data data{ span };
static constexpr span_type span(values);
static constexpr Data data{ span };
static const bool is_valid = data.is_valid();
static const size_t size = data.size();
static const bool empty = data.empty();
static const bool full = data.full();
static const size_t capacity = data.capacity();
static const size_t max_size = data.max_size();
static const const_iterator begin = data.begin();
static const const_iterator end = data.end();
static constexpr bool is_valid = data.is_valid();
static constexpr size_t size = data.size();
static constexpr bool empty = data.empty();
static constexpr bool full = data.full();
static constexpr size_t capacity = data.capacity();
static constexpr size_t max_size = data.max_size();
static constexpr const_iterator begin = data.begin();
static constexpr const_iterator end = data.end();
CHECK_TRUE(is_valid);
CHECK_TRUE(size == Max_Size);
@ -190,6 +190,7 @@ namespace
CHECK_FALSE(begin == end);
}
#if ETL_USING_CPP17
//*************************************************************************
TEST(test_cpp17_deduced_constructor_from_span)
{
@ -229,6 +230,7 @@ namespace
CHECK_TRUE(data.max_size() == Max_Size);
CHECK_FALSE(data.begin() == data.end());
}
#endif
//*************************************************************************
TEST(test_constructor_min_size)
@ -1117,15 +1119,21 @@ namespace
static constexpr value_type values3[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static constexpr value_type values4[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static constexpr Data data1{values1};
static constexpr Data data2{values2};
static constexpr Data data3{values3};
static constexpr Data data4{values4};
static constexpr bool equal12 = (data1 == data2);
static constexpr bool equal13 = (data1 == data3);
static constexpr bool equal14 = (data1 == data4);
CHECK_TRUE(equal12);
CHECK_FALSE(equal13);
CHECK_FALSE(equal14);
}
//*************************************************************************
@ -1140,15 +1148,21 @@ namespace
static constexpr value_type values3[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static constexpr value_type values4[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static constexpr DataTransparentComparator data1{values1};
static constexpr DataTransparentComparator data2{values2};
static constexpr DataTransparentComparator data3{values3};
static constexpr DataTransparentComparator data4{values4};
static constexpr bool equal12 = (data1 == data2);
static constexpr bool equal13 = (data1 == data3);
static constexpr bool equal14 = (data1 == data4);
CHECK_TRUE(equal12);
CHECK_FALSE(equal13);
CHECK_FALSE(equal14);
}
//*************************************************************************
@ -1163,15 +1177,21 @@ namespace
static constexpr value_type values3[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static constexpr value_type values4[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static constexpr Data data1{values1};
static constexpr Data data2{values2};
static constexpr Data data3{values3};
static constexpr Data data4{values4};
static constexpr bool not_equal12 = (data1 != data2);
static constexpr bool not_equal13 = (data1 != data3);
static constexpr bool not_equal14 = (data1 != data4);
CHECK_FALSE(not_equal12);
CHECK_TRUE(not_equal13);
CHECK_TRUE(not_equal14);
}
//*************************************************************************
@ -1186,15 +1206,22 @@ namespace
static constexpr value_type values3[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } };
static constexpr value_type values4[]{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 },
value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } };
static constexpr DataTransparentComparator data1{values1};
static constexpr DataTransparentComparator data2{values2};
static constexpr DataTransparentComparator data3{values3};
static constexpr DataTransparentComparator data4{values4};
static constexpr bool not_equal12 = (data1 != data2);
static constexpr bool not_equal13 = (data1 != data3);
static constexpr bool not_equal14 = (data1 != data4);
CHECK_FALSE(not_equal12);
CHECK_TRUE(not_equal13);
CHECK_TRUE(not_equal14);
}
//*************************************************************************

1326
test/test_const_multiset.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

1326
test/test_const_multiset_constexpr.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

1423
test/test_const_multiset_ext.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

1423
test/test_const_multiset_ext_constexpr.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

1435
test/test_const_set.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

1434
test/test_const_set_constexpr.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

1570
test/test_const_set_ext.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

1570
test/test_const_set_ext_constexpr.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

296
test/test_crc8_nrsc5.cpp Normal file
View File

@ -0,0 +1,296 @@
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2021 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#include "unit_test_framework.h"
#include <iterator>
#include <string>
#include <vector>
#include <stdint.h>
#include "etl/crc8_nrsc5.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
//*****************************************************************************
namespace
{
SUITE(test_crc8_nrsc5)
{
//*************************************************************************
// Table size 4
//*************************************************************************
TEST(test_crc8_nrsc5_4_constructor)
{
std::string data("123456789");
uint8_t crc = etl::crc8_nrsc5_t4(data.begin(), data.end());
CHECK_EQUAL(0xF7U, int(crc));
}
#if ETL_USING_CPP14 && !defined(ETL_CRC_FORCE_CPP03_IMPLEMENTATION)
//*************************************************************************
TEST(test_crc8_nrsc5_4_constructor_constexpr)
{
constexpr char data[] = "123456789";
constexpr uint8_t crc = etl::crc8_nrsc5_t4(data, data + 9);
CHECK_EQUAL(0xF7U, int(crc));
}
#endif
//*************************************************************************
TEST(test_crc8_nrsc5_4_add_values)
{
std::string data("123456789");
etl::crc8_nrsc5_t4 crc_calculator;
for (size_t i = 0UL; i < data.size(); ++i)
{
crc_calculator.add(data[i]);
}
uint8_t crc = crc_calculator;
CHECK_EQUAL(0xF7U, int(crc));
}
//*************************************************************************
TEST(test_crc8_nrsc5_4_add_range)
{
std::string data("123456789");
etl::crc8_nrsc5_t4 crc_calculator;
crc_calculator.add(data.begin(), data.end());
uint8_t crc = crc_calculator.value();
CHECK_EQUAL(0xF7U, int(crc));
}
//*************************************************************************
TEST(test_crc8_nrsc5_4_add_range_via_iterator)
{
std::string data("123456789");
etl::crc8_nrsc5_t4 crc_calculator;
std::copy(data.begin(), data.end(), crc_calculator.input());
uint8_t crc = crc_calculator.value();
CHECK_EQUAL(0xF7U, int(crc));
}
//*************************************************************************
TEST(test_crc8_nrsc5_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_nrsc5_t4(data1.begin(), data1.end());
uint8_t crc2 = etl::crc8_nrsc5_t4((uint8_t*)&data2[0], (uint8_t*)(&data2[0] + data2.size()));
CHECK_EQUAL(int(crc1), int(crc2));
uint8_t crc3 = etl::crc8_nrsc5_t4(data3.rbegin(), data3.rend());
CHECK_EQUAL(int(crc1), int(crc3));
}
//*************************************************************************
// Table size 16
//*************************************************************************
TEST(test_crc8_nrsc5_16_constructor)
{
std::string data("123456789");
uint8_t crc = etl::crc8_nrsc5_t16(data.begin(), data.end());
CHECK_EQUAL(0xF7U, int(crc));
}
#if ETL_USING_CPP14 && !defined(ETL_CRC_FORCE_CPP03_IMPLEMENTATION)
//*************************************************************************
TEST(test_crc8_nrsc5_16_constructor_constexpr)
{
constexpr char data[] = "123456789";
constexpr uint8_t crc = etl::crc8_nrsc5_t16(data, data + 9);
CHECK_EQUAL(0xF7U, int(crc));
}
#endif
//*************************************************************************
TEST(test_crc8_nrsc5_16_add_values)
{
std::string data("123456789");
etl::crc8_nrsc5_t16 crc_calculator;
for (size_t i = 0UL; i < data.size(); ++i)
{
crc_calculator.add(data[i]);
}
uint8_t crc = crc_calculator;
CHECK_EQUAL(0xF7U, int(crc));
}
//*************************************************************************
TEST(test_crc8_nrsc5_16_add_range)
{
std::string data("123456789");
etl::crc8_nrsc5_t16 crc_calculator;
crc_calculator.add(data.begin(), data.end());
uint8_t crc = crc_calculator.value();
CHECK_EQUAL(0xF7U, int(crc));
}
//*************************************************************************
TEST(test_crc8_nrsc5_16_add_range_via_iterator)
{
std::string data("123456789");
etl::crc8_nrsc5_t16 crc_calculator;
std::copy(data.begin(), data.end(), crc_calculator.input());
uint8_t crc = crc_calculator.value();
CHECK_EQUAL(0xF7U, int(crc));
}
//*************************************************************************
TEST(test_crc8_nrsc5_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_nrsc5_t16(data1.begin(), data1.end());
uint8_t crc2 = etl::crc8_nrsc5_t16((uint8_t*)&data2[0], (uint8_t*)(&data2[0] + data2.size()));
CHECK_EQUAL(int(crc1), int(crc2));
uint8_t crc3 = etl::crc8_nrsc5_t16(data3.rbegin(), data3.rend());
CHECK_EQUAL(int(crc1), int(crc3));
}
//*************************************************************************
// Table size 256
//*************************************************************************
TEST(test_crc8_nrsc5_256_constructor)
{
std::string data("123456789");
uint8_t crc = etl::crc8_nrsc5(data.begin(), data.end());
CHECK_EQUAL(0xF7U, int(crc));
}
#if ETL_USING_CPP14 && !defined(ETL_CRC_FORCE_CPP03_IMPLEMENTATION)
//*************************************************************************
TEST(test_crc8_nrsc5_256_constructor_constexpr)
{
constexpr char data[] = "123456789";
constexpr uint8_t crc = etl::crc8_nrsc5(data, data + 9);
CHECK_EQUAL(0xF7U, int(crc));
}
#endif
//*************************************************************************
TEST(test_crc8_nrsc5_256_add_values)
{
std::string data("123456789");
etl::crc8_nrsc5 crc_calculator;
for (size_t i = 0UL; i < data.size(); ++i)
{
crc_calculator.add(data[i]);
}
uint8_t crc = crc_calculator;
CHECK_EQUAL(0xF7U, int(crc));
}
//*************************************************************************
TEST(test_crc8_nrsc5_256_add_range)
{
std::string data("123456789");
etl::crc8_nrsc5 crc_calculator;
crc_calculator.add(data.begin(), data.end());
uint8_t crc = crc_calculator.value();
CHECK_EQUAL(0xF7U, int(crc));
}
//*************************************************************************
TEST(test_crc8_nrsc5_256_add_range_via_iterator)
{
std::string data("123456789");
etl::crc8_nrsc5 crc_calculator;
std::copy(data.begin(), data.end(), crc_calculator.input());
uint8_t crc = crc_calculator.value();
CHECK_EQUAL(0xF7U, int(crc));
}
//*************************************************************************
TEST(test_crc8_nrsc5_256_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_nrsc5(data1.begin(), data1.end());
uint8_t crc2 = etl::crc8_nrsc5((uint8_t*)&data2[0], (uint8_t*)(&data2[0] + data2.size()));
CHECK_EQUAL(int(crc1), int(crc2));
uint8_t crc3 = etl::crc8_nrsc5(data3.rbegin(), data3.rend());
CHECK_EQUAL(int(crc1), int(crc3));
}
};
}

88
test/test_multiset.cpp
View File

@ -45,13 +45,13 @@ static const size_t MAX_SIZE = 10UL;
#define TEST_GREATER_THAN
#ifdef TEST_GREATER_THAN
using Data = etl::multiset<int, MAX_SIZE, std::greater<int>>;
using IData = etl::imultiset<int, std::greater<int>>;
using Compare_Data = std::multiset<int, std::greater<int>>;
using Data = etl::multiset<int, MAX_SIZE, std::greater<int>>;
using IData = etl::imultiset<int, std::greater<int>>;
using Compare_Data = std::multiset<int, std::greater<int>>;
#else
using Data = etl::multiset<int, MAX_SIZE, std::less<int>>;
using IData = etl::multiset<int, std::less<int>>;
using Compare_Data = std::multiset<int, std::less<int>>;
using Data = etl::multiset<int, MAX_SIZE, std::less<int>>;
using IData = etl::imultiset<int, std::less<int>>;
using Compare_Data = std::multiset<int, std::less<int>>;
#endif
using ItemM = TestDataM<int>;
@ -1151,30 +1151,17 @@ namespace
CHECK_EQUAL(*i_compare, *i_data);
#ifdef TEST_GREATER_THAN
i_compare = compare_data.lower_bound(-1);
CHECK(compare_data.end() == i_compare);
i_data = data.lower_bound(-1);
CHECK(data.end() == i_data);
i_compare = compare_data.lower_bound(99);
i_data = data.lower_bound(99);
CHECK(i_data != data.end());
if ((i_data != data.end()) && (i_compare != compare_data.end()))
{
CHECK(*i_compare == *i_data);
}
CHECK(i_data == data.begin());
#else
i_compare = compare_data.lower_bound(-1);
i_data = data.lower_bound(-1);
CHECK_EQUAL(*i_compare, *i_data);
i_compare = compare_data.lower_bound(99);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(data.begin() == i_data);
i_data = data.lower_bound(99);
CHECK_EQUAL(data.end(), i_data);
CHECK(i_data == data.end());
#endif
}
@ -1213,30 +1200,17 @@ namespace
CHECK_EQUAL(*i_compare, *i_data);
#ifdef TEST_GREATER_THAN
i_compare = compare_data.lower_bound(-1);
CHECK(compare_data.end() == i_compare);
i_data = data.lower_bound(-1);
CHECK(data.end() == i_data);
i_compare = compare_data.lower_bound(99);
i_data = data.lower_bound(99);
CHECK(i_data != data.end());
if ((i_data != data.end()) && (i_compare != compare_data.end()))
{
CHECK(*i_compare == *i_data);
}
CHECK(i_data == data.begin());
#else
i_compare = compare_data.lower_bound(-1);
i_data = data.lower_bound(-1);
CHECK_EQUAL(*i_compare, *i_data);
i_compare = compare_data.lower_bound(99);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(data.begin() == i_data);
i_data = data.lower_bound(99);
CHECK_EQUAL(data.end(), i_data);
CHECK(i_data == data.end());
#endif
}
@ -1275,30 +1249,17 @@ namespace
CHECK_EQUAL(*i_compare, *i_data);
#ifdef TEST_GREATER_THAN
i_compare = compare_data.upper_bound(-1);
CHECK(compare_data.end() == i_compare);
i_data = data.upper_bound(-1);
CHECK(data.end() == i_data);
i_compare = compare_data.upper_bound(99);
i_data = data.upper_bound(99);
CHECK(i_data != data.end());
if ((i_data != data.end()) && (i_compare != compare_data.end()))
{
CHECK(*i_compare == *i_data);
}
CHECK(i_data == data.begin());
#else
i_compare = compare_data.upper_bound(-1);
i_data = data.upper_bound(-1);
CHECK_EQUAL(*i_compare, *i_data);
i_compare = compare_data.upper_bound(99);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(data.begin() == i_data);
i_data = data.upper_bound(99);
CHECK_EQUAL(data.end(), i_data);
CHECK(i_data == data.end());
#endif
}
@ -1337,30 +1298,17 @@ namespace
CHECK_EQUAL(*i_compare, *i_data);
#ifdef TEST_GREATER_THAN
i_compare = compare_data.upper_bound(-1);
CHECK(compare_data.end() == i_compare);
i_data = data.upper_bound(-1);
CHECK(data.end() == i_data);
i_compare = compare_data.upper_bound(99);
i_data = data.upper_bound(99);
CHECK(i_data != data.end());
if ((i_data != data.end()) && (i_compare != compare_data.end()))
{
CHECK(*i_compare == *i_data);
}
CHECK(i_data == data.begin());
#else
i_compare = compare_data.upper_bound(-1);
i_data = data.upper_bound(-1);
CHECK_EQUAL(*i_compare, *i_data);
i_compare = compare_data.upper_bound(99);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(data.begin() == i_data);
i_data = data.upper_bound(99);
CHECK_EQUAL(data.end(), i_data);
CHECK(i_data == data.end());
#endif
}

77
test/test_set.cpp
View File

@ -1025,30 +1025,17 @@ namespace
CHECK_EQUAL(*i_compare, *i_data);
#ifdef TEST_GREATER_THAN
i_compare = compare_data.lower_bound(-1);
CHECK(compare_data.end() == i_compare);
i_data = data.lower_bound(-1);
CHECK(data.end() == i_data);
i_compare = compare_data.lower_bound(11);
i_data = data.lower_bound(11);
CHECK(i_data != data.end());
if ((i_data != data.end()) && (i_compare != compare_data.end()))
{
CHECK(*i_compare == *i_data);
}
i_data = data.lower_bound(99);
CHECK(i_data == data.begin());
#else
i_compare = compare_data.lower_bound(-1);
i_data = data.lower_bound(-1);
CHECK_EQUAL(*i_compare, *i_data);
CHECK(data.begin() == i_data);
i_compare = compare_data.lower_bound(11);
CHECK_EQUAL(compare_data.end(), i_compare);
i_data = data.lower_bound(11);
CHECK_EQUAL(data.end(), i_data);
i_data = data.lower_bound(99);
CHECK(i_data == data.end());
#endif
}
@ -1087,25 +1074,17 @@ namespace
CHECK_EQUAL(*i_compare, *i_data);
#ifdef TEST_GREATER_THAN
i_compare = compare_data.lower_bound(-1);
CHECK(compare_data.end() == i_compare);
i_data = data.lower_bound(-1);
CHECK(data.end() == i_data);
i_compare = compare_data.lower_bound(11);
i_data = data.lower_bound(11);
CHECK_EQUAL(*i_compare, *i_data);
i_data = data.lower_bound(99);
CHECK(i_data == data.begin());
#else
i_compare = compare_data.lower_bound(-1);
i_data = data.lower_bound(-1);
CHECK_EQUAL(*i_compare, *i_data);
CHECK(data.begin() == i_data);
i_compare = compare_data.lower_bound(11);
CHECK_EQUAL(compare_data.end(), i_compare);
i_data = data.lower_bound(11);
CHECK_EQUAL(data.end(), i_data);
i_data = data.lower_bound(99);
CHECK(i_data == data.end());
#endif
}
@ -1144,25 +1123,17 @@ namespace
CHECK_EQUAL(*i_compare, *i_data);
#ifdef TEST_GREATER_THAN
i_compare = compare_data.upper_bound(-1);
CHECK(compare_data.end() == i_compare);
i_data = data.upper_bound(-1);
CHECK(data.end() == i_data);
i_compare = compare_data.upper_bound(11);
i_data = data.upper_bound(11);
CHECK_EQUAL(*i_compare, *i_data);
i_data = data.upper_bound(99);
CHECK(i_data == data.begin());
#else
i_compare = compare_data.upper_bound(-1);
i_data = data.upper_bound(-1);
CHECK_EQUAL(*i_compare, *i_data);
CHECK(data.begin() == i_data);
i_compare = compare_data.upper_bound(11);
CHECK_EQUAL(compare_data.end(), i_compare);
i_data = data.upper_bound(11);
CHECK_EQUAL(data.end(), i_data);
i_data = data.upper_bound(99);
CHECK(i_data == data.end());
#endif
}
@ -1201,25 +1172,17 @@ namespace
CHECK_EQUAL(*i_compare, *i_data);
#ifdef TEST_GREATER_THAN
i_compare = compare_data.upper_bound(-1);
CHECK(compare_data.end() == i_compare);
i_data = data.upper_bound(-1);
CHECK(data.end() == i_data);
i_compare = compare_data.upper_bound(11);
i_data = data.upper_bound(11);
CHECK_EQUAL(*i_compare, *i_data);
i_data = data.upper_bound(99);
CHECK(i_data == data.begin());
#else
i_compare = compare_data.upper_bound(-1);
i_data = data.upper_bound(-1);
CHECK_EQUAL(*i_compare, *i_data);
CHECK(data.begin() == i_data);
i_compare = compare_data.upper_bound(11);
CHECK_EQUAL(compare_data.end(), i_compare);
i_data = data.upper_bound(11);
CHECK_EQUAL(data.end(), i_data);
i_data = data.upper_bound(99);
CHECK(i_data == data.end());
#endif
}

12
test/vs2022/etl.vcxproj
View File

@ -3294,6 +3294,8 @@
<ClInclude Include="..\..\include\etl\constant.h" />
<ClInclude Include="..\..\include\etl\const_map.h" />
<ClInclude Include="..\..\include\etl\const_multimap.h" />
<ClInclude Include="..\..\include\etl\const_multiset.h" />
<ClInclude Include="..\..\include\etl\const_set.h" />
<ClInclude Include="..\..\include\etl\correlation.h" />
<ClInclude Include="..\..\include\etl\covariance.h" />
<ClInclude Include="..\..\include\etl\crc.h" />
@ -3343,6 +3345,7 @@
<ClInclude Include="..\..\include\etl\crc8_j1850.h" />
<ClInclude Include="..\..\include\etl\crc8_j1850_zero.h" />
<ClInclude Include="..\..\include\etl\crc8_maxim.h" />
<ClInclude Include="..\..\include\etl\crc8_nrsc5.h" />
<ClInclude Include="..\..\include\etl\crc8_rohc.h" />
<ClInclude Include="..\..\include\etl\crc8_wcdma.h" />
<ClInclude Include="..\..\include\etl\expected.h" />
@ -9300,6 +9303,14 @@
<ClCompile Include="..\test_const_multimap_constexpr.cpp" />
<ClCompile Include="..\test_const_multimap_ext.cpp" />
<ClCompile Include="..\test_const_multimap_ext_constexpr.cpp" />
<ClCompile Include="..\test_const_multiset.cpp" />
<ClCompile Include="..\test_const_multiset_constexpr.cpp" />
<ClCompile Include="..\test_const_multiset_ext.cpp" />
<ClCompile Include="..\test_const_multiset_ext_constexpr.cpp" />
<ClCompile Include="..\test_const_set.cpp" />
<ClCompile Include="..\test_const_set_constexpr.cpp" />
<ClCompile Include="..\test_const_set_ext.cpp" />
<ClCompile Include="..\test_const_set_ext_constexpr.cpp" />
<ClCompile Include="..\test_correlation.cpp" />
<ClCompile Include="..\test_covariance.cpp" />
<ClCompile Include="..\test_crc1.cpp" />
@ -9349,6 +9360,7 @@
<ClCompile Include="..\test_crc8_j1850.cpp" />
<ClCompile Include="..\test_crc8_j1850_zero.cpp" />
<ClCompile Include="..\test_crc8_maxim.cpp" />
<ClCompile Include="..\test_crc8_nrsc5.cpp" />
<ClCompile Include="..\test_crc8_rohc.cpp" />
<ClCompile Include="..\test_crc8_wcdma.cpp" />
<ClCompile Include="..\test_expected.cpp" />

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

@ -1518,6 +1518,15 @@
<ClInclude Include="..\..\include\etl\closure.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\include\etl\const_set.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\include\etl\const_multiset.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\include\etl\crc8_nrsc5.h">
<Filter>ETL\Maths\CRC</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\test_string_char.cpp">
@ -3629,6 +3638,33 @@
<ClCompile Include="..\test_const_multimap_ext_constexpr.cpp">
<Filter>Tests\Containers</Filter>
</ClCompile>
<ClCompile Include="..\test_const_set.cpp">
<Filter>Tests\Containers</Filter>
</ClCompile>
<ClCompile Include="..\test_const_set_constexpr.cpp">
<Filter>Tests\Containers</Filter>
</ClCompile>
<ClCompile Include="..\test_const_set_ext.cpp">
<Filter>Tests\Containers</Filter>
</ClCompile>
<ClCompile Include="..\test_const_set_ext_constexpr.cpp">
<Filter>Tests\Containers</Filter>
</ClCompile>
<ClCompile Include="..\test_const_multiset.cpp">
<Filter>Tests\Containers</Filter>
</ClCompile>
<ClCompile Include="..\test_const_multiset_constexpr.cpp">
<Filter>Tests\Containers</Filter>
</ClCompile>
<ClCompile Include="..\test_const_multiset_ext.cpp">
<Filter>Tests\Containers</Filter>
</ClCompile>
<ClCompile Include="..\test_const_multiset_ext_constexpr.cpp">
<Filter>Tests\Containers</Filter>
</ClCompile>
<ClCompile Include="..\test_crc8_nrsc5.cpp">
<Filter>Tests\CRC</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<None Include="..\..\library.properties">