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 'feature/c++14-tests' into development

Browse Source 
# Conflicts:
#	include/etl/generators/type_traits_generator.h
#	test/vs2022/etl.vcxproj.filters
This commit is contained in:
John Wellbelove 2023-04-28 11:52:09 +01:00
commit f692c67b4f
122 changed files with 3051 additions and 1607 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.gitignore vendored
View File

@ -379,3 +379,7 @@ test/vs2022/Debug MSVC - No STL - Force Built-ins
test/temp
test/vs2022/Debug MSVC C++14
test/vs2022/Debug MSVC C++20 - No STL
build-test-Desktop_x86_windows_msvc2019_pe_64bit-Debug
test/vs2022/Debug MSVC C++14 - No STL
test/log.txt
test/etl_error_handler/log.txt

6
include/etl/array.h
View File

@ -236,7 +236,7 @@ namespace etl
//*************************************************************************
iterator end() ETL_NOEXCEPT
{
return &_buffer[SIZE];
return _buffer + SIZE;
}
//*************************************************************************
@ -244,7 +244,7 @@ namespace etl
//*************************************************************************
ETL_CONSTEXPR const_iterator end() const ETL_NOEXCEPT
{
return &_buffer[SIZE];
return _buffer + SIZE;
}
//*************************************************************************
@ -252,7 +252,7 @@ namespace etl
//*************************************************************************
ETL_CONSTEXPR const_iterator cend() const ETL_NOEXCEPT
{
return &_buffer[SIZE];
return _buffer + SIZE;
}
//*************************************************************************

4
include/etl/array_view.h
View File

@ -636,8 +636,8 @@ namespace etl
{
size_t operator()(const etl::array_view<T>& view) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&view[0]),
reinterpret_cast<const uint8_t*>(&view[view.size()]));
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(view.data()),
reinterpret_cast<const uint8_t*>(view.data() + view.size()));
}
};
#endif

6
include/etl/array_wrapper.h
View File

@ -394,8 +394,10 @@ namespace etl
{
size_t operator()(const etl::array_wrapper<T, SIZE, ARRAY>& aw) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&aw[0]),
reinterpret_cast<const uint8_t*>(&aw[aw.size()]));
const uint8_t* pb = reinterpret_cast<const uint8_t*>(aw.data());
const uint8_t* pe = pb + (SIZE * sizeof(T));
return etl::private_hash::generic_hash<size_t>(pb, pe);
}
};
#endif

41
include/etl/basic_string.h
View File

@ -136,21 +136,39 @@ namespace etl
///\ingroup string
/// The base class for all templated string types.
//***************************************************************************
class string_base
namespace private_basic_string
{
//*************************************************************************
template <typename T = void>
class string_base_statics
{
public:
typedef size_t size_type;
static ETL_CONSTANT uint_least8_t IS_TRUNCATED = etl::bit<0>::value;
static ETL_CONSTANT uint_least8_t CLEAR_AFTER_USE = etl::bit<1>::value;
static ETL_CONSTANT size_type npos = etl::integral_limits<size_type>::max;
};
template <typename T>
ETL_CONSTANT uint_least8_t string_base_statics<T>::IS_TRUNCATED;
template <typename T>
ETL_CONSTANT uint_least8_t string_base_statics<T>::CLEAR_AFTER_USE;
template <typename T>
ETL_CONSTANT typename string_base_statics<T>::size_type string_base_statics<T>::npos;
}
//***************************************************************************
class string_base : public private_basic_string::string_base_statics<>
{
public:
typedef size_t size_type;
#if ETL_USING_CPP11
static constexpr size_type npos = etl::integral_limits<size_type>::max;
#else
enum
{
npos = etl::integral_limits<size_type>::max
};
#endif
//*************************************************************************
/// Gets the current size of the string.
///\return The current size of the string.
@ -290,9 +308,6 @@ namespace etl
{
}
static ETL_CONSTANT uint_least8_t IS_TRUNCATED = etl::bit<0>::value;
static ETL_CONSTANT uint_least8_t CLEAR_AFTER_USE = etl::bit<1>::value;
size_type current_size; ///< The current number of elements in the string.
const size_type CAPACITY; ///< The maximum number of elements in the string.

34
include/etl/binary.h
View File

@ -96,8 +96,8 @@ namespace etl
template <>
struct max_value_for_nbits<0>
{
typedef etl::smallest_uint_for_bits<0>::type value_type;
static ETL_CONSTANT value_type value = 0;
typedef etl::smallest_uint_for_bits<0>::type value_type;
static ETL_CONSTANT value_type value = 0;
};
template <const size_t NBITS>
@ -544,6 +544,9 @@ namespace etl
static ETL_CONSTANT uint8_t value = uint8_t((value2 >> 4U) | ((value2 & 0x0FU) << 4U));
};
template <uint8_t Value>
ETL_CONSTANT uint8_t reverse_bits_const<uint8_t, Value>::value;
//***********************************
template <int8_t Value>
struct reverse_bits_const<int8_t, Value>
@ -557,6 +560,9 @@ namespace etl
static ETL_CONSTANT int8_t value = int8_t((value2 >> 4U) | ((value2 & 0x0FU) << 4U));
};
template <int8_t Value>
ETL_CONSTANT int8_t reverse_bits_const<int8_t, Value>::value;
#endif
//***************************************************************************
@ -591,6 +597,9 @@ namespace etl
static ETL_CONSTANT uint16_t value = uint16_t((value3 >> 8U) | ((value3 & 0xFFU) << 8U));
};
template <uint16_t Value>
ETL_CONSTANT uint16_t reverse_bits_const<uint16_t, Value>::value;
//***********************************
template <int16_t Value>
struct reverse_bits_const<int16_t, Value>
@ -606,6 +615,9 @@ namespace etl
static ETL_CONSTANT int16_t value = int16_t((value3 >> 8U) | ((value3 & 0xFFU) << 8U));
};
template <int16_t Value>
ETL_CONSTANT int16_t reverse_bits_const<int16_t, Value>::value;
//***************************************************************************
/// Reverse 32 bits.
///\ingroup binary
@ -640,6 +652,9 @@ namespace etl
static ETL_CONSTANT uint32_t value = uint32_t((value4 >> 16U) | ((value4 & 0xFFFFU) << 16U));
};
template <uint32_t Value>
ETL_CONSTANT uint32_t reverse_bits_const<uint32_t, Value>::value;
//***********************************
template <int32_t Value>
struct reverse_bits_const<int32_t, Value>
@ -656,6 +671,9 @@ namespace etl
static ETL_CONSTANT int32_t value = int32_t((value4 >> 16U) | ((value4 & 0xFFFFUL) << 16U));
};
template <int32_t Value>
ETL_CONSTANT int32_t reverse_bits_const<int32_t, Value>::value;
#if ETL_USING_64BIT_TYPES
//***************************************************************************
/// Reverse 64 bits.
@ -693,6 +711,9 @@ namespace etl
static ETL_CONSTANT uint64_t value = uint64_t((value5 >> 32U) | ((value5 & 0xFFFFFFFFULL) << 32U));
};
template <uint64_t Value>
ETL_CONSTANT uint64_t reverse_bits_const<uint64_t, Value>::value;
//***********************************
template <int64_t Value>
struct reverse_bits_const<int64_t, Value>
@ -709,6 +730,9 @@ namespace etl
static ETL_CONSTANT int64_t value = int64_t((value5 >> 32U) | ((value5 & 0xFFFFFFFFULL) << 32U));
};
template <int64_t Value>
ETL_CONSTANT int64_t reverse_bits_const<int64_t, Value>::value;
#endif
//***************************************************************************
@ -2190,6 +2214,9 @@ namespace etl
static ETL_CONSTANT T value = static_cast<T>(etl::max_value_for_nbits<NBits>::value);
};
template <typename T, size_t NBits>
ETL_CONSTANT T lsb_mask<T, NBits>::value;
//***********************************
template <typename T>
ETL_CONSTEXPR14 T make_lsb_mask(size_t nbits)
@ -2209,6 +2236,9 @@ namespace etl
static ETL_CONSTANT T value = static_cast<T>(etl::reverse_bits_const<T, lsb_mask<T, NBits>::value>::value);
};
template <typename T, size_t NBits>
ETL_CONSTANT T msb_mask<T, NBits>::value;
//***********************************
template <typename T>
ETL_CONSTEXPR T make_msb_mask(size_t nbits)

5
include/etl/bip_buffer_spsc_atomic.h
View File

@ -526,11 +526,14 @@ namespace etl
base_t::clear();
}
private:
private:
/// The uninitialised buffer of T used in the bip_buffer_spsc.
etl::uninitialized_buffer_of<T, RESERVED_SIZE> buffer;
};
template <typename T, const size_t SIZE, const size_t MEMORY_MODEL>
ETL_CONSTANT typename bip_buffer_spsc_atomic<T, SIZE, MEMORY_MODEL>::size_type bip_buffer_spsc_atomic<T, SIZE, MEMORY_MODEL>::RESERVED_SIZE;
}
#endif /* ETL_HAS_ATOMIC && ETL_USING_CPP11 */

9
include/etl/buffer_descriptors.h
View File

@ -290,6 +290,15 @@ namespace etl
etl::array<descriptor_item, N_BUFFERS> descriptor_items;
etl::cyclic_value<uint_least8_t, 0U, N_BUFFERS - 1> next;
};
template <typename TBuffer, size_t BUFFER_SIZE_, size_t N_BUFFERS_, typename TFlag>
ETL_CONSTANT typename buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::size_type buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::N_BUFFERS;
template <typename TBuffer, size_t BUFFER_SIZE_, size_t N_BUFFERS_, typename TFlag>
ETL_CONSTANT typename buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::size_type buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::BUFFER_SIZE;
template <typename TBuffer, size_t BUFFER_SIZE_, size_t N_BUFFERS_, typename TFlag>
ETL_CONSTANT typename buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::size_type buffer_descriptors<TBuffer, BUFFER_SIZE_, N_BUFFERS_, TFlag>::descriptor::MAX_SIZE;
}
#endif
#endif

3
include/etl/circular_buffer.h
View File

@ -1226,6 +1226,9 @@ namespace etl
etl::uninitialized_buffer_of<T, MAX_SIZE + 1> buffer;
};
template <typename T, size_t MAX_SIZE_>
ETL_CONSTANT typename icircular_buffer<T>::size_type circular_buffer<T, MAX_SIZE_>::MAX_SIZE;
//***************************************************************************
/// A fixed capacity circular buffer.
/// External buffer.

3
include/etl/combinations.h
View File

@ -51,6 +51,9 @@ namespace etl
static ETL_CONSTANT size_t value = etl::permutations<NV, KV>::value / etl::factorial<KV>::value;
};
template <const size_t NV, const size_t KV>
ETL_CONSTANT size_t combinations<NV, KV>::value;
#if ETL_USING_CPP17
template <size_t NV, size_t KV>
inline constexpr size_t combinations_v = combinations<NV, KV>::value;

23
include/etl/correlation.h
View File

@ -73,10 +73,24 @@ namespace etl
//***************************************************************************
/// Correlation Type.
//***************************************************************************
struct correlation_type
namespace private_correlation
{
template<typename T = void>
struct correlation_type_statics
{
static ETL_CONSTANT bool Sample = false;
static ETL_CONSTANT bool Population = true;
};
template<typename T>
ETL_CONSTANT bool correlation_type_statics<T>::Sample;
template<typename T>
ETL_CONSTANT bool correlation_type_statics<T>::Population;
}
struct correlation_type : public private_correlation::correlation_type_statics<>
{
static ETL_CONSTANT bool Sample = false;
static ETL_CONSTANT bool Population = true;
};
//***************************************************************************
@ -270,6 +284,9 @@ namespace etl
mutable double correlation_value;
mutable bool recalculate;
};
template <bool Correlation_Type, typename TInput, typename TCalc>
ETL_CONSTANT int correlation<Correlation_Type, TInput, TCalc>::Adjustment;
}
#endif

23
include/etl/covariance.h
View File

@ -73,10 +73,24 @@ namespace etl
//***************************************************************************
/// Covariance Type.
//***************************************************************************
struct covariance_type
namespace private_covariance
{
template<typename T = void>
struct covariance_type_statics
{
static ETL_CONSTANT bool Sample = false;
static ETL_CONSTANT bool Population = true;
};
template<typename T>
ETL_CONSTANT bool covariance_type_statics<T>::Sample;
template<typename T>
ETL_CONSTANT bool covariance_type_statics<T>::Population;
}
struct covariance_type : public private_covariance::covariance_type_statics<>
{
static ETL_CONSTANT bool Sample = false;
static ETL_CONSTANT bool Population = true;
};
//***************************************************************************
@ -219,6 +233,9 @@ namespace etl
mutable double covariance_value;
mutable bool recalculate;
};
template <bool Covariance_Type, typename TInput, typename TCalc>
ETL_CONSTANT int covariance<Covariance_Type, TInput, TCalc>::Adjustment;
}
#endif

3
include/etl/deque.h
View File

@ -2469,6 +2469,9 @@ namespace etl
etl::uninitialized_buffer_of<T, BUFFER_SIZE> buffer;
};
template <typename T, const size_t MAX_SIZE_>
ETL_CONSTANT size_t deque<T, MAX_SIZE_>::MAX_SIZE;
//*************************************************************************
/// Template deduction guides.
//*************************************************************************

3
include/etl/factorial.h
View File

@ -61,6 +61,9 @@ namespace etl
static ETL_CONSTANT size_t value = 1;
};
template <size_t N>
ETL_CONSTANT size_t factorial<N>::value;
#if ETL_USING_CPP17
template <size_t N>
inline constexpr size_t factorial_v = factorial<N>::value;

3
include/etl/fibonacci.h
View File

@ -70,6 +70,9 @@ namespace etl
static ETL_CONSTANT size_t value = 0UL;
};
template <size_t N>
ETL_CONSTANT size_t fibonacci<N>::value;
#if ETL_USING_CPP17
template <size_t N>
inline constexpr size_t fibonacci_v = fibonacci<N>::value;

9
include/etl/fixed_sized_memory_block_allocator.h
View File

@ -112,6 +112,15 @@ namespace etl
/// The generic pool from which allocate memory blocks.
etl::generic_pool<Block_Size, Alignment, Size> pool;
};
template <size_t VBlock_Size, size_t VAlignment, size_t VSize>
ETL_CONSTANT size_t fixed_sized_memory_block_allocator<VBlock_Size, VAlignment, VSize>::Block_Size;
template <size_t VBlock_Size, size_t VAlignment, size_t VSize>
ETL_CONSTANT size_t fixed_sized_memory_block_allocator<VBlock_Size, VAlignment, VSize>::Alignment;
template <size_t VBlock_Size, size_t VAlignment, size_t VSize>
ETL_CONSTANT size_t fixed_sized_memory_block_allocator<VBlock_Size, VAlignment, VSize>::Size;
}
#endif

9
include/etl/flags.h
View File

@ -349,6 +349,15 @@ namespace etl
value_type data;
};
template <typename T, T MASK>
ETL_CONSTANT typename flags<T, MASK>::value_type flags<T, MASK>::ALL_SET;
template <typename T, T MASK>
ETL_CONSTANT typename flags<T, MASK>::value_type flags<T, MASK>::ALL_CLEAR;
template <typename T, T MASK>
ETL_CONSTANT size_t flags<T, MASK>::NBITS;
//***************************************************************************
/// operator ==
//***************************************************************************

3
include/etl/flat_map.h
View File

@ -1158,6 +1158,9 @@ namespace etl
etl::vector<node_t*, MAX_SIZE> lookup;
};
template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare>
ETL_CONSTANT size_t flat_map<TKey, TValue, MAX_SIZE_, TCompare>::MAX_SIZE;
//*************************************************************************
/// Template deduction guides.
//*************************************************************************

5
include/etl/flat_multimap.h
View File

@ -206,7 +206,7 @@ namespace etl
//*********************************************************************
const_reverse_iterator rend() const
{
refmap_t::rend();
return refmap_t::rend();
}
//*********************************************************************
@ -1041,6 +1041,9 @@ namespace etl
etl::vector<node_t*, MAX_SIZE> lookup;
};
template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare>
ETL_CONSTANT size_t flat_multimap<TKey, TValue, MAX_SIZE_, TCompare>::MAX_SIZE;
//*************************************************************************
/// Template deduction guides.
//*************************************************************************

3
include/etl/flat_multiset.h
View File

@ -995,6 +995,9 @@ namespace etl
etl::vector<node_t*, MAX_SIZE> lookup;
};
template <typename T,const size_t MAX_SIZE_, typename TCompare>
ETL_CONSTANT size_t flat_multiset<T, MAX_SIZE_, TCompare>::MAX_SIZE;
//*************************************************************************
/// Template deduction guides.
//*************************************************************************

3
include/etl/flat_set.h
View File

@ -1082,6 +1082,9 @@ namespace etl
etl::vector<node_t*, MAX_SIZE> lookup;
};
template <typename T, const size_t MAX_SIZE_, typename TCompare>
ETL_CONSTANT size_t flat_set<T, MAX_SIZE_, TCompare>::MAX_SIZE;
//*************************************************************************
/// Template deduction guides.
//*************************************************************************

3
include/etl/forward_list.h
View File

@ -1748,6 +1748,9 @@ namespace etl
etl::pool<typename etl::iforward_list<T>::data_node_t, MAX_SIZE> node_pool;
};
template <typename T, const size_t MAX_SIZE_>
ETL_CONSTANT size_t forward_list<T, MAX_SIZE_>::MAX_SIZE;
//*************************************************************************
/// Template deduction guides.
//*************************************************************************

29
include/etl/fsm.h
View File

@ -169,19 +169,34 @@ namespace etl
}
};
namespace private_fsm
{
template <typename T = void>
class ifsm_state_helper
{
public:
// Pass this whenever no state change is desired.
// The highest unsigned value of fsm_state_id_t.
static ETL_CONSTANT fsm_state_id_t No_State_Change = etl::integral_limits<fsm_state_id_t>::max;
// Pass this when this event also needs to be passed to the parent.
static ETL_CONSTANT fsm_state_id_t Pass_To_Parent = No_State_Change - 1U;
};
template <typename T>
ETL_CONSTANT fsm_state_id_t ifsm_state_helper<T>::No_State_Change;
template <typename T>
ETL_CONSTANT fsm_state_id_t ifsm_state_helper<T>::Pass_To_Parent;
}
//***************************************************************************
/// Interface class for FSM states.
//***************************************************************************
class ifsm_state
class ifsm_state : public private_fsm::ifsm_state_helper<>
{
public:
// Pass this whenever no state change is desired.
// The highest unsigned value of fsm_state_id_t.
static ETL_CONSTANT fsm_state_id_t No_State_Change = etl::integral_limits<fsm_state_id_t>::max;
// Pass this when this event also needs to be passed to the parent.
static ETL_CONSTANT fsm_state_id_t Pass_To_Parent = No_State_Change - 1U;
/// Allows ifsm_state functions to be private.
friend class etl::fsm;
friend class etl::hfsm;

5
include/etl/functional.h
View File

@ -57,6 +57,11 @@ namespace etl
{
}
ETL_CONSTEXPR20 reference_wrapper(const reference_wrapper& rhs) ETL_NOEXCEPT
: t(rhs.t)
{
}
ETL_CONSTEXPR20 reference_wrapper<T>& operator = (const reference_wrapper& rhs) ETL_NOEXCEPT
{
t = rhs.t;

33
include/etl/generators/fsm_generator.h
View File

@ -188,19 +188,35 @@ namespace etl
}
};
namespace private_fsm
{
template <typename T = void>
class ifsm_state_helper
{
public:
// Pass this whenever no state change is desired.
// The highest unsigned value of fsm_state_id_t.
static ETL_CONSTANT fsm_state_id_t No_State_Change = etl::integral_limits<fsm_state_id_t>::max;
// Pass this when this event also needs to be passed to the parent.
static ETL_CONSTANT fsm_state_id_t Pass_To_Parent = No_State_Change - 1U;
};
template <typename T>
ETL_CONSTANT fsm_state_id_t ifsm_state_helper<T>::No_State_Change;
template <typename T>
ETL_CONSTANT fsm_state_id_t ifsm_state_helper<T>::Pass_To_Parent;
}
//***************************************************************************
/// Interface class for FSM states.
//***************************************************************************
class ifsm_state
class ifsm_state : public private_fsm::ifsm_state_helper<>
{
public:
// Pass this whenever no state change is desired.
// The highest unsigned value of fsm_state_id_t.
static ETL_CONSTANT fsm_state_id_t No_State_Change = etl::integral_limits<fsm_state_id_t>::max;
// Pass this when this event also needs to be passed to the parent.
static ETL_CONSTANT fsm_state_id_t Pass_To_Parent = No_State_Change - 1U;
/// Allows ifsm_state functions to be private.
friend class etl::fsm;
friend class etl::hfsm;
@ -325,6 +341,9 @@ namespace etl
ifsm_state& operator =(const ifsm_state&);
};
ETL_CONSTANT fsm_state_id_t ifsm_state::No_State_Change;
ETL_CONSTANT fsm_state_id_t ifsm_state::Pass_To_Parent;
//***************************************************************************
/// The FSM class.
//***************************************************************************

4
include/etl/generators/message_packet_generator.h
View File

@ -483,7 +483,7 @@ namespace etl
for n in range(1, int(Handlers)):
cog.out("T%s, " % n)
cog.outl("T%s>::value, int>::type>" % int(Handlers))
cog.outl(" explicit message_packet(TMessage&& msg)")
cog.outl(" explicit message_packet(TMessage&& /*msg*/)")
cog.outl(" : valid(true)")
cog.outl(" {")
generate_static_assert_cpp11(int(Handlers))
@ -767,7 +767,7 @@ namespace etl
for t in range(1, n):
cog.out("T%s, " % t)
cog.outl("T%s>::value, int>::type>" % n)
cog.outl(" explicit message_packet(TMessage&& msg)")
cog.outl(" explicit message_packet(TMessage&& /*msg*/)")
cog.outl(" : valid(true)")
cog.outl(" {")
generate_static_assert_cpp11(n)

12
include/etl/generators/smallest_generator.h
View File

@ -333,6 +333,9 @@ namespace etl
typedef typename private_smallest::best_fit_uint_type<TYPE_INDEX>::type type;
};
template <size_t NBITS>
ETL_CONSTANT int smallest_uint_for_bits<NBITS>::TYPE_INDEX;
#if ETL_USING_CPP11
template <size_t NBITS>
using smallest_uint_for_bits_t = typename smallest_uint_for_bits<NBITS>::type;
@ -359,6 +362,9 @@ namespace etl
typedef typename private_smallest::best_fit_int_type<TYPE_INDEX>::type type;
};
template <size_t NBITS>
ETL_CONSTANT int smallest_int_for_bits<NBITS>::TYPE_INDEX;
#if ETL_USING_CPP11
template <size_t NBITS>
using smallest_int_for_bits_t = typename smallest_int_for_bits<NBITS>::type;
@ -385,6 +391,9 @@ namespace etl
typedef typename private_smallest::best_fit_uint_type<TYPE_INDEX>::type type;
};
template <size_t NBITS>
ETL_CONSTANT int smallest_uint_for_value<NBITS>::TYPE_INDEX;
#if ETL_USING_CPP11
template <uintmax_t VALUE>
using smallest_uint_for_value_t = typename smallest_uint_for_value<VALUE>::type;
@ -411,6 +420,9 @@ namespace etl
typedef typename private_smallest::best_fit_int_type<TYPE_INDEX>::type type;
};
template <size_t NBITS>
ETL_CONSTANT int smallest_int_for_value<NBITS>::TYPE_INDEX;
#if ETL_USING_CPP11
template <intmax_t VALUE>
using smallest_int_for_value_t = typename smallest_int_for_value<VALUE>::type;

4
include/etl/generators/type_lookup_generator.h
View File

@ -137,14 +137,14 @@ namespace etl
template <typename T, typename T1, typename... TRest>
struct id_from_type_helper
{
static constexpr size_t value = etl::is_same<T, typename T1::type>::value ? T1::ID : id_from_type_helper<T, TRest...>::value;
static constexpr size_t value = etl::is_same<T, typename T1::type>::value ? size_t(T1::ID) : id_from_type_helper<T, TRest...>::value;
};
// Specialisation for 1 type pair.
template <typename T, typename T1>
struct id_from_type_helper<T, T1>
{
static constexpr size_t value = etl::is_same<T, typename T1::type>::value ? T1::ID : UNKNOWN;
static constexpr size_t value = etl::is_same<T, typename T1::type>::value ? size_t(T1::ID) : UNKNOWN;
};
public:

79
include/etl/generators/type_traits_generator.h
View File

@ -96,7 +96,7 @@ namespace etl
//***************************************************************************
/// integral_constant
template <typename T, const T VALUE>
template <typename T, T VALUE>
struct integral_constant
{
static const T value = VALUE;
@ -119,7 +119,7 @@ namespace etl
#if ETL_USING_CPP17
template <typename T, T VALUE>
inline constexpr T integral_constant_v = std::integral_constant<T, VALUE>::value;
inline constexpr T integral_constant_v = etl::integral_constant<T, VALUE>::value;
#endif
#if ETL_USING_CPP11
@ -132,7 +132,7 @@ namespace etl
#if ETL_USING_CPP17
template <bool B>
inline constexpr bool bool_constant_v = std::bool_constant<B>::value;
inline constexpr bool bool_constant_v = bool_constant<B>::value;
#endif
//***************************************************************************
@ -825,11 +825,11 @@ namespace etl
// Traits are derived from the STL
//*****************************************************************************
//***************************************************************************
/// integral_constant
///\ingroup type_traits
template <typename T, T VALUE>
struct integral_constant : std::integral_constant<T, VALUE> {};
//***************************************************************************
/// integral_constant
///\ingroup type_traits
template <typename T, T VALUE>
struct integral_constant : std::integral_constant<T, VALUE> {};
/// integral_constant specialisations
///\ingroup type_traits
@ -841,6 +841,11 @@ typedef integral_constant<bool, true> true_type;
inline constexpr T integral_constant_v = std::integral_constant<T, VALUE>::value;
#endif
#if ETL_USING_CPP17
template <typename T, T VALUE>
inline constexpr T integral_constant_v = std::integral_constant<T, VALUE>::value;
#endif
#if ETL_USING_CPP17
template <bool B>
using bool_constant = std::bool_constant<B>;
@ -851,7 +856,7 @@ typedef integral_constant<bool, true> true_type;
#if ETL_USING_CPP17
template <bool B>
inline constexpr bool bool_constant_v = std::bool_constant<B>::value;
inline constexpr bool bool_constant_v = bool_constant<B>::value;
#endif
//***************************************************************************
@ -1637,99 +1642,71 @@ typedef integral_constant<bool, true> true_type;
//*********************************************
// is_assignable
template<typename T1, typename T2>
struct is_assignable : public std::is_assignable<T1, T2>
{
};
using is_assignable = std::is_assignable<T1, T2>;
//*********************************************
// is_constructible
template<typename T, typename... TArgs>
struct is_constructible : public std::is_constructible<T, TArgs...>
{
};
using is_constructible = std::is_constructible<T, TArgs...>;
//*********************************************
// is_copy_constructible
template <typename T>
struct is_copy_constructible : public std::is_copy_constructible<T>
{
};
using is_copy_constructible = std::is_copy_constructible<T>;
//*********************************************
// is_move_constructible
template <typename T>
struct is_move_constructible : public std::is_move_constructible<T>
{
};
using is_move_constructible = std::is_move_constructible<T>;
//*********************************************
// is_trivially_constructible
#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T>
struct is_trivially_constructible : public std::is_trivially_constructible<T>
{
};
using is_trivially_constructible = std::is_trivially_constructible<T>;
#else
template <typename T>
struct is_trivially_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
using is_trivially_constructible = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
#endif
//*********************************************
// is_trivially_copy_constructible
#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T>
struct is_trivially_copy_constructible : public std::is_trivially_copy_constructible<T>
{
};
using is_trivially_copy_constructible = std::is_trivially_copy_constructible<T>;
#else
template <typename T>
struct is_trivially_copy_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
using is_trivially_copy_constructible = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
#endif
//*********************************************
// is_trivially_destructible
#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T>
struct is_trivially_destructible : public std::is_trivially_destructible<T>
{
};
using is_trivially_destructible = std::is_trivially_destructible<T>;
#else
template <typename T>
struct is_trivially_destructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
using is_trivially_destructible = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
#endif
//*********************************************
// is_trivially_copy_assignable
#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T>
struct is_trivially_copy_assignable : public std::is_trivially_copy_assignable<T>
{
};
using is_trivially_copy_assignable = std::is_trivially_copy_assignable<T>;
#else
template <typename T>
struct is_trivially_copy_assignable : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
using is_trivially_copy_assignable = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
#endif
//*********************************************
// is_trivially_copyable
#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T>
struct is_trivially_copyable : public std::is_trivially_copyable<T>
{
};
using is_trivially_copyable = std::is_trivially_copyable<T>;
#else
template <typename T>
struct is_trivially_copyable : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
using is_trivially_copyable = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
#endif
#elif defined(ETL_USE_TYPE_TRAITS_BUILTINS) && !defined(ETL_USER_DEFINED_TYPE_TRAITS)

15
include/etl/generic_pool.h
View File

@ -194,6 +194,15 @@ namespace etl
generic_pool& operator =(const generic_pool&) ETL_DELETE;
};
template <const size_t VTypeSize, const size_t VAlignment, const size_t VSize>
ETL_CONSTANT size_t generic_pool<VTypeSize, VAlignment, VSize>::SIZE;
template <const size_t VTypeSize, const size_t VAlignment, const size_t VSize>
ETL_CONSTANT size_t generic_pool<VTypeSize, VAlignment, VSize>::ALIGNMENT;
template <const size_t VTypeSize, const size_t VAlignment, const size_t VSize>
ETL_CONSTANT size_t generic_pool<VTypeSize, VAlignment, VSize>::TYPE_SIZE;
//*************************************************************************
/// A templated abstract pool implementation that uses a fixed size pool.
/// The storage for the pool is supplied externally.
@ -338,6 +347,12 @@ namespace etl
generic_pool_ext(const generic_pool_ext&) ETL_DELETE;
generic_pool_ext& operator=(const generic_pool_ext&) ETL_DELETE;
};
template <const size_t VTypeSize, const size_t VAlignment>
ETL_CONSTANT size_t generic_pool_ext<VTypeSize, VAlignment>::ALIGNMENT;
template <const size_t VTypeSize, const size_t VAlignment>
ETL_CONSTANT size_t generic_pool_ext<VTypeSize, VAlignment>::TYPE_SIZE;
}
#endif

8
include/etl/hfsm.h
View File

@ -67,6 +67,14 @@ namespace etl
if (call_on_enter_state)
{
do_enters(ETL_NULLPTR, p_state, true);
//etl::fsm_state_id_t next_state = do_enters(ETL_NULLPTR, p_state, true);
//if (ifsm_state::No_State_Change != next_state)
//{
// p_state = state_list[next_state];
//}
}
}
}

6
include/etl/histogram.h
View File

@ -126,6 +126,9 @@ namespace etl
etl::array<TCount, Max_Size> accumulator;
};
template <typename TCount, size_t Max_Size_>
ETL_CONSTANT size_t histogram_common<TCount, Max_Size_>::Max_Size;
}
//***************************************************************************
@ -592,6 +595,9 @@ namespace etl
etl::flat_map<key_type, count_type, Max_Size> accumulator;
};
template <typename TKey, typename TCount, size_t Max_Size_>
ETL_CONSTANT size_t sparse_histogram<TKey, TCount, Max_Size_>::Max_Size;
}
#endif

3
include/etl/indirect_vector.h
View File

@ -1424,6 +1424,9 @@ namespace etl
etl::pool<T, MAX_SIZE> storage_pool;
};
template <typename T, const size_t MAX_SIZE_>
ETL_CONSTANT size_t indirect_vector<T, MAX_SIZE_>::MAX_SIZE;
//*************************************************************************
/// Template deduction guides.
//*************************************************************************

543
include/etl/integral_limits.h
View File

@ -45,8 +45,422 @@ SOFTWARE.
///\ingroup utilities
//*****************************************************************************
#ifndef LLONG_MAX
#define LLONG_MAX 9223372036854775807LL
#endif
#ifndef LLONG_MIN
#define LLONG_MIN (-LLONG_MAX - 1LL)
#endif
#ifndef ULLONG_MAX
#define ULLONG_MAX 18446744073709551615ULL
#endif
namespace etl
{
namespace private_integral_limits
{
//*****************************************************************************
/// The technique of using templated base classes to declare and define the statics
/// is to get around the limits of the One Definition Rule (ODR) that occurs when
/// the top level integral_limits classes are specialised. This issue currently seems
/// to only be apparent for GCC/C++14.
/// In C++17 and above this is not necessary, as the inline keyword may be used.
/// At the time of writing, the ETL is generally aimed to be compatible with C++98 and above.
//*****************************************************************************
//*********************************
// signed char
template <typename T = void>
struct statics_signed_char
{
typedef signed char value_type;
static ETL_CONSTANT signed char min = SCHAR_MIN;
static ETL_CONSTANT signed char max = SCHAR_MAX;
static ETL_CONSTANT int bits = CHAR_BIT;
static ETL_CONSTANT bool is_signed = etl::is_signed<signed char>::value;
};
template <typename T>
ETL_CONSTANT signed char statics_signed_char<T>::min;
template <typename T>
ETL_CONSTANT signed char statics_signed_char<T>::max;
template <typename T>
ETL_CONSTANT int statics_signed_char<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_signed_char<T>::is_signed;
//***********************************
// unsigned char
template <typename T = void>
struct statics_unsigned_char
{
typedef unsigned char value_type;
static ETL_CONSTANT unsigned char min = 0;
static ETL_CONSTANT unsigned char max = UCHAR_MAX;
static ETL_CONSTANT int bits = CHAR_BIT;
static ETL_CONSTANT bool is_signed = etl::is_signed<unsigned char>::value;
};
template <typename T>
ETL_CONSTANT unsigned char statics_unsigned_char<T>::min;
template <typename T>
ETL_CONSTANT unsigned char statics_unsigned_char<T>::max;
template <typename T>
ETL_CONSTANT int statics_unsigned_char<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_unsigned_char<T>::is_signed;
//***********************************
// char
template <typename T = void>
struct statics_char
{
typedef char value_type;
static ETL_CONSTANT char min = (etl::is_signed<char>::value) ? SCHAR_MIN : 0;
static ETL_CONSTANT char max = (etl::is_signed<char>::value) ? SCHAR_MAX : static_cast<char>(UCHAR_MAX);
static ETL_CONSTANT int bits = CHAR_BIT;
static ETL_CONSTANT bool is_signed = etl::is_signed<char>::value;
};
template <typename T>
ETL_CONSTANT char statics_char<T>::min;
template <typename T>
ETL_CONSTANT char statics_char<T>::max;
template <typename T>
ETL_CONSTANT int statics_char<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_char<T>::is_signed;
//***********************************
// wchar_t
template <typename T = void>
struct statics_wchar_t
{
typedef wchar_t value_type;
static ETL_CONSTANT wchar_t min = WCHAR_MIN;
static ETL_CONSTANT wchar_t max = WCHAR_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * sizeof(wchar_t);
static ETL_CONSTANT bool is_signed = etl::is_signed<wchar_t>::value;
};
template <typename T>
ETL_CONSTANT wchar_t statics_wchar_t<T>::min;
template <typename T>
ETL_CONSTANT wchar_t statics_wchar_t<T>::max;
template <typename T>
ETL_CONSTANT int statics_wchar_t<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_wchar_t<T>::is_signed;
//***********************************
// short
#if defined(ETL_COMPILER_MICROSOFT)
#pragma warning(push)
#pragma warning(disable : 4309)
#endif
template <typename T = void>
struct statics_short
{
typedef short value_type;
static ETL_CONSTANT short min = SHRT_MIN;
static ETL_CONSTANT short max = SHRT_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(short) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<short>::value;
};
template <typename T>
ETL_CONSTANT short statics_short<T>::min;
template <typename T>
ETL_CONSTANT short statics_short<T>::max;
template <typename T>
ETL_CONSTANT int statics_short<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_short<T>::is_signed;
#if defined(ETL_COMPILER_MICROSOFT)
#pragma warning(pop)
#endif
//***********************************
// unsigned short
template <typename T = void>
struct statics_unsigned_short
{
typedef unsigned short value_type;
static ETL_CONSTANT unsigned short min = 0;
static ETL_CONSTANT unsigned short max = USHRT_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(unsigned short) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<unsigned short>::value;
};
template <typename T>
ETL_CONSTANT unsigned short statics_unsigned_short<T>::min;
template <typename T>
ETL_CONSTANT unsigned short statics_unsigned_short<T>::max;
template <typename T>
ETL_CONSTANT int statics_unsigned_short<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_unsigned_short<T>::is_signed;
//***********************************
// int
template <typename T = void>
struct statics_int
{
typedef int value_type;
static ETL_CONSTANT int min = INT_MIN;
static ETL_CONSTANT int max = INT_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(int) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<int>::value;
};
template <typename T>
ETL_CONSTANT int statics_int<T>::min;
template <typename T>
ETL_CONSTANT int statics_int<T>::max;
template <typename T>
ETL_CONSTANT int statics_int<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_int<T>::is_signed;
//***********************************
// unsigned int
template <typename T = void>
struct statics_unsigned_int
{
typedef unsigned int value_type;
static ETL_CONSTANT unsigned int min = 0;
static ETL_CONSTANT unsigned int max = UINT_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(unsigned int) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<unsigned int>::value;
};
template <typename T>
ETL_CONSTANT unsigned int statics_unsigned_int<T>::min;
template <typename T>
ETL_CONSTANT unsigned int statics_unsigned_int<T>::max;
template <typename T>
ETL_CONSTANT int statics_unsigned_int<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_unsigned_int<T>::is_signed;
//***********************************
// long
template <typename T = void>
struct statics_long
{
typedef long value_type;
static ETL_CONSTANT long min = LONG_MIN;
static ETL_CONSTANT long max = LONG_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(long) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<long>::value;
};
template <typename T>
ETL_CONSTANT long statics_long<T>::min;
template <typename T>
ETL_CONSTANT long statics_long<T>::max;
template <typename T>
ETL_CONSTANT int statics_long<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_long<T>::is_signed;
//***********************************
// unsigned long
template <typename T = void>
struct statics_unsigned_long
{
typedef unsigned long value_type;
static ETL_CONSTANT unsigned long min = 0;
static ETL_CONSTANT unsigned long max = ULONG_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(unsigned long) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<unsigned long>::value;
};
template <typename T>
ETL_CONSTANT unsigned long statics_unsigned_long<T>::min;
template <typename T>
ETL_CONSTANT unsigned long statics_unsigned_long<T>::max;
template <typename T>
ETL_CONSTANT int statics_unsigned_long<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_unsigned_long<T>::is_signed;
//***********************************
// long long
template <typename T = void>
struct statics_long_long
{
typedef long long value_type;
static ETL_CONSTANT long long min = LLONG_MIN;
static ETL_CONSTANT long long max = LLONG_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(long long) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<long long>::value;
};
template <typename T>
ETL_CONSTANT long long statics_long_long<T>::min;
template <typename T>
ETL_CONSTANT long long statics_long_long<T>::max;
template <typename T>
ETL_CONSTANT int statics_long_long<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_long_long<T>::is_signed;
//***********************************
// unsigned long long
template <typename T = void>
struct statics_unsigned_long_long
{
typedef unsigned long value_type;
static ETL_CONSTANT unsigned long long min = 0;
static ETL_CONSTANT unsigned long long max = ULLONG_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(unsigned long long) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<unsigned long long>::value;
};
template <typename T>
ETL_CONSTANT unsigned long long statics_unsigned_long_long<T>::min;
template <typename T>
ETL_CONSTANT unsigned long long statics_unsigned_long_long<T>::max;
template <typename T>
ETL_CONSTANT int statics_unsigned_long_long<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_unsigned_long_long<T>::is_signed;
#if ETL_HAS_NATIVE_CHAR8_T
//***********************************
// char8_t
template <typename T = void>
struct statics_char8_t
{
typedef char8_t value_type;
static ETL_CONSTANT char8_t min = (etl::is_signed<char8_t>::value) ? SCHAR_MIN : 0;
static ETL_CONSTANT char8_t max = (etl::is_signed<char8_t>::value) ? SCHAR_MAX : static_cast<char8_t>(UCHAR_MAX);
static ETL_CONSTANT int bits = CHAR_BIT;
static ETL_CONSTANT bool is_signed = etl::is_signed<char8_t>::value;
};
template <typename T>
ETL_CONSTANT char8_t statics_char8_t<T>::min;
template <typename T>
ETL_CONSTANT char8_t statics_char8_t<T>::max;
template <typename T>
ETL_CONSTANT int statics_char8_t<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_char8_t<T>::is_signed;
#endif
#if ETL_HAS_NATIVE_CHAR16_T
//***********************************
// char16_t
template <typename T = void>
struct statics_char16_t
{
typedef char16_t value_type;
static ETL_CONSTANT char16_t min = 0;
static ETL_CONSTANT char16_t max = 0xFFFFU;
static ETL_CONSTANT int bits = 16;
static ETL_CONSTANT bool is_signed = false;
};
template <typename T>
ETL_CONSTANT char16_t statics_char16_t<T>::min;
template <typename T>
ETL_CONSTANT char16_t statics_char16_t<T>::max;
template <typename T>
ETL_CONSTANT int statics_char16_t<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_char16_t<T>::is_signed;
#endif
#if ETL_HAS_NATIVE_CHAR32_T
//***********************************
// char32_t
template <typename T = void>
struct statics_char32_t
{
typedef char32_t value_type;
static ETL_CONSTANT char32_t min = 0;
static ETL_CONSTANT char32_t max = 0xFFFFFFFFU;
static ETL_CONSTANT int bits = 32;
static ETL_CONSTANT bool is_signed = false;
};
template <typename T>
ETL_CONSTANT char32_t statics_char32_t<T>::min;
template <typename T>
ETL_CONSTANT char32_t statics_char32_t<T>::max;
template <typename T>
ETL_CONSTANT int statics_char32_t<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_char32_t<T>::is_signed;
#endif
}
//***************************************************************************
///\ingroup integral_limits
//***************************************************************************
@ -57,166 +471,91 @@ namespace etl
///\ingroup integral_limits
//***************************************************************************
template <>
struct integral_limits<void>
struct integral_limits<signed char> : public private_integral_limits::statics_signed_char<>
{
static ETL_CONSTANT int min = 0;
static ETL_CONSTANT int max = 0;
static ETL_CONSTANT int bits = 0;
static ETL_CONSTANT bool is_signed = false;
};
//***************************************************************************
///\ingroup integral_limits
//***************************************************************************
template <>
struct integral_limits<signed char>
struct integral_limits<unsigned char> : public private_integral_limits::statics_unsigned_char<>
{
static ETL_CONSTANT signed char min = SCHAR_MIN;
static ETL_CONSTANT signed char max = SCHAR_MAX;
static ETL_CONSTANT int bits = CHAR_BIT;
static ETL_CONSTANT bool is_signed = etl::is_signed<signed char>::value;
};
//***************************************************************************
///\ingroup integral_limits
//***************************************************************************
template <>
struct integral_limits<char> : public private_integral_limits::statics_char<>
{
typedef char value_type;
};
//***************************************************************************
///\ingroup integral_limits
//***************************************************************************
template <>
struct integral_limits<unsigned char>
struct integral_limits<short> : public private_integral_limits::statics_short<>
{
static ETL_CONSTANT unsigned char min = 0;
static ETL_CONSTANT unsigned char max = UCHAR_MAX;
static ETL_CONSTANT int bits = CHAR_BIT;
static ETL_CONSTANT bool is_signed = etl::is_signed<unsigned char>::value;
};
//***************************************************************************
///\ingroup integral_limits
//***************************************************************************
#if defined(ETL_COMPILER_MICROSOFT)
#pragma warning(push)
#pragma warning(disable : 4309)
#endif
template <>
struct integral_limits<char>
{
static ETL_CONSTANT char min = (etl::is_signed<char>::value) ? SCHAR_MIN : 0;
static ETL_CONSTANT char max = (etl::is_signed<char>::value) ? SCHAR_MAX : static_cast<char>(UCHAR_MAX);
static ETL_CONSTANT int bits = CHAR_BIT;
static ETL_CONSTANT bool is_signed = etl::is_signed<char>::value;
};
#if defined(ETL_COMPILER_MICROSOFT)
#pragma warning(pop)
#endif
//***************************************************************************
///\ingroup integral_limits
//***************************************************************************
template <>
struct integral_limits<short>
{
static ETL_CONSTANT short min = SHRT_MIN;
static ETL_CONSTANT short max = SHRT_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(short) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<short>::value;
};
//***************************************************************************
///\ingroup integral_limits
//***************************************************************************
template <>
struct integral_limits<unsigned short>
struct integral_limits<unsigned short> : public private_integral_limits::statics_unsigned_short<>
{
static ETL_CONSTANT unsigned short min = 0;
static ETL_CONSTANT unsigned short max = USHRT_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(unsigned short) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<unsigned short>::value;
};
//***************************************************************************
///\ingroup integral_limits
//***************************************************************************
template <>
struct integral_limits<int>
struct integral_limits<int> : public private_integral_limits::statics_int<>
{
static ETL_CONSTANT int min = INT_MIN;
static ETL_CONSTANT int max = INT_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(int) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<int>::value;
};
//***************************************************************************
///\ingroup integral_limits
//***************************************************************************
template <>
struct integral_limits<unsigned int>
struct integral_limits<unsigned int> : public private_integral_limits::statics_unsigned_int<>
{
static ETL_CONSTANT unsigned int min = 0;
static ETL_CONSTANT unsigned int max = UINT_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(unsigned int) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<unsigned int>::value;
};
//***************************************************************************
///\ingroup integral_limits
//***************************************************************************
template <>
struct integral_limits<long>
struct integral_limits<long> : public private_integral_limits::statics_long<>
{
static ETL_CONSTANT long min = LONG_MIN;
static ETL_CONSTANT long max = LONG_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(long) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<long>::value;
};
//***************************************************************************
///\ingroup integral_limits
//***************************************************************************
template <>
struct integral_limits<unsigned long>
struct integral_limits<unsigned long> : public private_integral_limits::statics_unsigned_long<>
{
static ETL_CONSTANT unsigned long min = 0;
static ETL_CONSTANT unsigned long max = ULONG_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(unsigned long) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<unsigned long>::value;
};
#ifndef LLONG_MAX
#define LLONG_MAX 9223372036854775807LL
#endif
#ifndef LLONG_MIN
#define LLONG_MIN (-LLONG_MAX - 1LL)
#endif
#ifndef ULLONG_MAX
#define ULLONG_MAX 18446744073709551615ULL
#endif
//***************************************************************************
///\ingroup integral_limits
//***************************************************************************
template <>
struct integral_limits<long long>
{
static ETL_CONSTANT long long min = LLONG_MIN;
static ETL_CONSTANT long long max = LLONG_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(long long) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<long long>::value;
};
//***************************************************************************
///\ingroup integral_limits
//***************************************************************************
template <>
struct integral_limits<unsigned long long>
{
static ETL_CONSTANT unsigned long long min = 0;
static ETL_CONSTANT unsigned long long max = ULLONG_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(unsigned long long) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<unsigned long long>::value;
struct integral_limits<long long> : public private_integral_limits::statics_long_long<>
{
};
static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
//***************************************************************************
///\ingroup integral_limits
//***************************************************************************
template <>
struct integral_limits<unsigned long long> : public private_integral_limits::statics_unsigned_long_long<>
{
};
}
#include "private/minmax_pop.h"

39
include/etl/iterator.h
View File

@ -806,24 +806,36 @@ namespace etl
static ETL_CONSTANT bool value = etl::is_same<typename etl::iterator_traits<T>::iterator_category, ETL_OR_STD::input_iterator_tag>::value;
};
template <typename T>
ETL_CONSTANT bool is_input_iterator<T>::value;
template <typename T>
struct is_output_iterator
{
static ETL_CONSTANT bool value = etl::is_same<typename etl::iterator_traits<T>::iterator_category, ETL_OR_STD::output_iterator_tag>::value;
};
template <typename T>
ETL_CONSTANT bool is_output_iterator<T>::value;
template <typename T>
struct is_forward_iterator
{
static ETL_CONSTANT bool value = etl::is_same<typename etl::iterator_traits<T>::iterator_category, ETL_OR_STD::forward_iterator_tag>::value;
};
template <typename T>
ETL_CONSTANT bool is_forward_iterator<T>::value;
template <typename T>
struct is_bidirectional_iterator
{
static ETL_CONSTANT bool value = etl::is_same<typename etl::iterator_traits<T>::iterator_category, ETL_OR_STD::bidirectional_iterator_tag>::value;
};
template <typename T>
ETL_CONSTANT bool is_bidirectional_iterator<T>::value;
// Deprecated
template <typename T>
struct is_random_iterator
@ -831,12 +843,18 @@ namespace etl
static ETL_CONSTANT bool value = etl::is_same<typename etl::iterator_traits<T>::iterator_category, ETL_OR_STD::random_access_iterator_tag>::value;
};
template <typename T>
ETL_CONSTANT bool is_random_iterator<T>::value;
template <typename T>
struct is_random_access_iterator
{
static ETL_CONSTANT bool value = etl::is_same<typename etl::iterator_traits<T>::iterator_category, ETL_OR_STD::random_access_iterator_tag>::value;
};
template <typename T>
ETL_CONSTANT bool is_random_access_iterator<T>::value;
template <typename T>
struct is_input_iterator_concept
{
@ -846,6 +864,9 @@ namespace etl
etl::is_random_iterator<T>::value;
};
template <typename T>
ETL_CONSTANT bool is_input_iterator_concept<T>::value;
template <typename T>
struct is_output_iterator_concept
{
@ -855,6 +876,9 @@ namespace etl
etl::is_random_iterator<T>::value;
};
template <typename T>
ETL_CONSTANT bool is_output_iterator_concept<T>::value;
template <typename T>
struct is_forward_iterator_concept
{
@ -863,6 +887,9 @@ namespace etl
etl::is_random_iterator<T>::value;
};
template <typename T>
ETL_CONSTANT bool is_forward_iterator_concept<T>::value;
template <typename T>
struct is_bidirectional_iterator_concept
{
@ -870,6 +897,9 @@ namespace etl
etl::is_random_iterator<T>::value;
};
template <typename T>
ETL_CONSTANT bool is_bidirectional_iterator_concept<T>::value;
// Deprecated
template <typename T>
struct is_random_iterator_concept
@ -877,12 +907,21 @@ namespace etl
static ETL_CONSTANT bool value = etl::is_random_iterator<T>::value;
};
// Deprecated
template <typename T>
ETL_CONSTANT bool is_random_iterator_concept<T>::value;
// Deprecated
template <typename T>
struct is_random_access_iterator_concept
{
static ETL_CONSTANT bool value = etl::is_random_access_iterator<T>::value;
};
// Deprecated
template <typename T>
ETL_CONSTANT bool is_random_access_iterator_concept<T>::value;
#if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
//*****************************************************************************
/// Get the 'begin' iterator.

862
include/etl/limits.h
View File

File diff suppressed because it is too large Load Diff

11
include/etl/list.h
View File

@ -689,7 +689,7 @@ namespace etl
//*************************************************************************
const_iterator end() const
{
return const_iterator(static_cast<const data_node_t&>(terminal_node));
return const_iterator(terminal_node);
}
//*************************************************************************
@ -705,7 +705,7 @@ namespace etl
//*************************************************************************
const_iterator cend() const
{
return const_iterator(static_cast<const data_node_t&>(terminal_node));
return const_iterator(terminal_node);
}
//*************************************************************************
@ -721,7 +721,7 @@ namespace etl
//*************************************************************************
const_reverse_iterator rbegin() const
{
return const_reverse_iterator(static_cast<const data_node_t&>(terminal_node));
return const_reverse_iterator(terminal_node);
}
//*************************************************************************
@ -745,7 +745,7 @@ namespace etl
//*************************************************************************
const_reverse_iterator crbegin() const
{
return const_reverse_iterator(static_cast<const data_node_t&>(terminal_node));
return const_reverse_iterator(terminal_node);
}
//*************************************************************************
@ -2167,6 +2167,9 @@ namespace etl
etl::pool<typename etl::ilist<T>::data_node_t, MAX_SIZE> node_pool;
};
template <typename T, const size_t MAX_SIZE_>
ETL_CONSTANT size_t list<T, MAX_SIZE_>::MAX_SIZE;
//*************************************************************************
/// Template deduction guides.
//*************************************************************************

3
include/etl/map.h
View File

@ -2718,6 +2718,9 @@ namespace etl
etl::pool<typename etl::imap<TKey, TValue, TCompare>::Data_Node, MAX_SIZE> node_pool;
};
template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare>
ETL_CONSTANT size_t map<TKey, TValue, MAX_SIZE_, TCompare>::MAX_SIZE;
//*************************************************************************
/// Template deduction guides.
//*************************************************************************

60
include/etl/math_constants.h
View File

@ -33,19 +33,57 @@ SOFTWARE.
namespace etl
{
namespace math
namespace private_math_constants
{
ETL_CONSTANT double pi = 3.14159265358979;
ETL_CONSTANT double pi_reciprocal = 0.31830988618379;
ETL_CONSTANT double pi_squared = 9.86960440108936;
ETL_CONSTANT double e = 2.71828182845905;
ETL_CONSTANT double e_reciprocal = 0.36787944117144;
ETL_CONSTANT double e_squared = 7.38905609893065;
ETL_CONSTANT double root2 = 1.41421356237310;
ETL_CONSTANT double root2_reciprocal = 0.70710678118655;
ETL_CONSTANT double euler = 0.57721566490153;
ETL_CONSTANT double golden_ratio = 1.61803398874989;
template <typename T = void>
struct math_helper
{
static ETL_CONSTANT double pi = 3.14159265358979;
static ETL_CONSTANT double pi_reciprocal = 0.31830988618379;
static ETL_CONSTANT double pi_squared = 9.86960440108936;
static ETL_CONSTANT double e = 2.71828182845905;
static ETL_CONSTANT double e_reciprocal = 0.36787944117144;
static ETL_CONSTANT double e_squared = 7.38905609893065;
static ETL_CONSTANT double root2 = 1.41421356237310;
static ETL_CONSTANT double root2_reciprocal = 0.70710678118655;
static ETL_CONSTANT double euler = 0.57721566490153;
static ETL_CONSTANT double golden_ratio = 1.61803398874989;
};
template <typename T>
ETL_CONSTANT double math_helper<T>::pi;
template <typename T>
ETL_CONSTANT double math_helper<T>::pi_reciprocal;
template <typename T>
ETL_CONSTANT double math_helper<T>::pi_squared;
template <typename T>
ETL_CONSTANT double math_helper<T>::e;
template <typename T>
ETL_CONSTANT double math_helper<T>::e_reciprocal;
template <typename T>
ETL_CONSTANT double math_helper<T>::e_squared;
template <typename T>
ETL_CONSTANT double math_helper<T>::root2;
template <typename T>
ETL_CONSTANT double math_helper<T>::root2_reciprocal;
template <typename T>
ETL_CONSTANT double math_helper<T>::euler;
template <typename T>
ETL_CONSTANT double math_helper<T>::golden_ratio;
}
struct math : public private_math_constants::math_helper<>
{
};
}
#endif

6
include/etl/mem_cast.h
View File

@ -315,6 +315,12 @@ namespace etl
etl::uninitialized_buffer<Size, 1U, Alignment> buffer;
};
template <size_t Size_, size_t Alignment_>
ETL_CONSTANT size_t mem_cast<Size_, Alignment_>::Size;
template <size_t Size_, size_t Alignment_>
ETL_CONSTANT size_t mem_cast<Size_, Alignment_>::Alignment;
//*****************************************************************************
/// mem_cast_ptr
//*****************************************************************************

18
include/etl/memory.h
View File

@ -2146,6 +2146,15 @@ namespace etl
#endif
};
template <size_t VObject_Size, size_t VN_Objects, size_t VAlignment>
ETL_CONSTANT size_t uninitialized_buffer<VObject_Size, VN_Objects, VAlignment>::Object_Size;
template <size_t VObject_Size, size_t VN_Objects, size_t VAlignment>
ETL_CONSTANT size_t uninitialized_buffer<VObject_Size, VN_Objects, VAlignment>::N_Objects;
template <size_t VObject_Size, size_t VN_Objects, size_t VAlignment>
ETL_CONSTANT size_t uninitialized_buffer<VObject_Size, VN_Objects, VAlignment>::Alignment;
//***************************************************************************
/// Declares an aligned buffer of VN_Objects as if they were type T.
///\ingroup alignment
@ -2235,6 +2244,15 @@ namespace etl
#endif
};
template <typename T, size_t VN_Objects>
ETL_CONSTANT size_t uninitialized_buffer_of<T, VN_Objects>::Object_Size;
template <typename T, size_t VN_Objects>
ETL_CONSTANT size_t uninitialized_buffer_of<T, VN_Objects>::N_Objects;
template <typename T, size_t VN_Objects>
ETL_CONSTANT size_t uninitialized_buffer_of<T, VN_Objects>::Alignment;
#if ETL_USING_CPP11
template <typename T, size_t N_Objects>
using uninitialized_buffer_of_t = typename uninitialized_buffer_of<T, N_Objects>::buffer;

32
include/etl/message_packet.h
View File

@ -387,7 +387,7 @@ namespace etl
template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> >::value &&
!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
!etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value, int>::type>
explicit message_packet(TMessage&& msg)
explicit message_packet(TMessage&& /*msg*/)
: valid(true)
{
// Not etl::message_packet, not etl::imessage and in typelist.
@ -680,7 +680,7 @@ namespace etl
template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::value &&
!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
!etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value, int>::type>
explicit message_packet(TMessage&& msg)
explicit message_packet(TMessage&& /*msg*/)
: valid(true)
{
// Not etl::message_packet, not etl::imessage and in typelist.
@ -971,7 +971,7 @@ namespace etl
template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> >::value &&
!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
!etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value, int>::type>
explicit message_packet(TMessage&& msg)
explicit message_packet(TMessage&& /*msg*/)
: valid(true)
{
// Not etl::message_packet, not etl::imessage and in typelist.
@ -1260,7 +1260,7 @@ namespace etl
template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> >::value &&
!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
!etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value, int>::type>
explicit message_packet(TMessage&& msg)
explicit message_packet(TMessage&& /*msg*/)
: valid(true)
{
// Not etl::message_packet, not etl::imessage and in typelist.
@ -1546,7 +1546,7 @@ namespace etl
template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> >::value &&
!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
!etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value, int>::type>
explicit message_packet(TMessage&& msg)
explicit message_packet(TMessage&& /*msg*/)
: valid(true)
{
// Not etl::message_packet, not etl::imessage and in typelist.
@ -1827,7 +1827,7 @@ namespace etl
template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> >::value &&
!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
!etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value, int>::type>
explicit message_packet(TMessage&& msg)
explicit message_packet(TMessage&& /*msg*/)
: valid(true)
{
// Not etl::message_packet, not etl::imessage and in typelist.
@ -2106,7 +2106,7 @@ namespace etl
template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >::value &&
!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
!etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value, int>::type>
explicit message_packet(TMessage&& msg)
explicit message_packet(TMessage&& /*msg*/)
: valid(true)
{
// Not etl::message_packet, not etl::imessage and in typelist.
@ -2383,7 +2383,7 @@ namespace etl
template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9> >::value &&
!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
!etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9>::value, int>::type>
explicit message_packet(TMessage&& msg)
explicit message_packet(TMessage&& /*msg*/)
: valid(true)
{
// Not etl::message_packet, not etl::imessage and in typelist.
@ -2657,7 +2657,7 @@ namespace etl
template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8> >::value &&
!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
!etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8>::value, int>::type>
explicit message_packet(TMessage&& msg)
explicit message_packet(TMessage&& /*msg*/)
: valid(true)
{
// Not etl::message_packet, not etl::imessage and in typelist.
@ -2926,7 +2926,7 @@ namespace etl
template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7> >::value &&
!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
!etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7>::value, int>::type>
explicit message_packet(TMessage&& msg)
explicit message_packet(TMessage&& /*msg*/)
: valid(true)
{
// Not etl::message_packet, not etl::imessage and in typelist.
@ -3193,7 +3193,7 @@ namespace etl
template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6> >::value &&
!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
!etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6>::value, int>::type>
explicit message_packet(TMessage&& msg)
explicit message_packet(TMessage&& /*msg*/)
: valid(true)
{
// Not etl::message_packet, not etl::imessage and in typelist.
@ -3458,7 +3458,7 @@ namespace etl
template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5> >::value &&
!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
!etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5>::value, int>::type>
explicit message_packet(TMessage&& msg)
explicit message_packet(TMessage&& /*msg*/)
: valid(true)
{
// Not etl::message_packet, not etl::imessage and in typelist.
@ -3720,7 +3720,7 @@ namespace etl
template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4> >::value &&
!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
!etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4>::value, int>::type>
explicit message_packet(TMessage&& msg)
explicit message_packet(TMessage&& /*msg*/)
: valid(true)
{
// Not etl::message_packet, not etl::imessage and in typelist.
@ -3977,7 +3977,7 @@ namespace etl
template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3> >::value &&
!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
!etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3>::value, int>::type>
explicit message_packet(TMessage&& msg)
explicit message_packet(TMessage&& /*msg*/)
: valid(true)
{
// Not etl::message_packet, not etl::imessage and in typelist.
@ -4232,7 +4232,7 @@ namespace etl
template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2> >::value &&
!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
!etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2>::value, int>::type>
explicit message_packet(TMessage&& msg)
explicit message_packet(TMessage&& /*msg*/)
: valid(true)
{
// Not etl::message_packet, not etl::imessage and in typelist.
@ -4485,7 +4485,7 @@ namespace etl
template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1> >::value &&
!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
!etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1>::value, int>::type>
explicit message_packet(TMessage&& msg)
explicit message_packet(TMessage&& /*msg*/)
: valid(true)
{
// Not etl::message_packet, not etl::imessage and in typelist.

3
include/etl/multimap.h
View File

@ -2438,6 +2438,9 @@ namespace etl
etl::pool<typename etl::imultimap<TKey, TValue, TCompare>::Data_Node, MAX_SIZE> node_pool;
};
template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare>
ETL_CONSTANT size_t multimap<TKey, TValue, MAX_SIZE_, TCompare>::MAX_SIZE;
//*************************************************************************
/// Template deduction guides.
//*************************************************************************

3
include/etl/multiset.h
View File

@ -2420,6 +2420,9 @@ namespace etl
etl::pool<typename etl::imultiset<TKey, TCompare>::Data_Node, MAX_SIZE> node_pool;
};
template <typename TKey, const size_t MAX_SIZE_, typename TCompare>
ETL_CONSTANT size_t multiset<TKey, MAX_SIZE_, TCompare>::MAX_SIZE;
//*************************************************************************
/// Template deduction guides.
//*************************************************************************

10
include/etl/parameter_pack.h
View File

@ -121,9 +121,19 @@ namespace etl
using type_from_index_t = typename type_from_index<I>::type;
};
//***********************************
template <size_t Index, typename... TTypes>
using parameter_pack_t = typename etl::parameter_pack<TTypes...>::template type_from_index_t<Index>;
//***********************************
template <typename... TTypes>
constexpr size_t parameter_pack<TTypes...>::size;
//***********************************
template <typename... TTypes>
template <typename T>
constexpr size_t parameter_pack<TTypes...>::template index_of_type<T>::value;
#if ETL_USING_CPP17
template <typename T, typename... TTypes>
inline constexpr size_t parameter_pack_v = etl::parameter_pack<TTypes...>::template index_of_type<T>::value;

6
include/etl/permutations.h
View File

@ -49,6 +49,9 @@ namespace etl
static ETL_CONSTANT size_t value = NV * permutations<NV - 1, KV - 1>::value;
};
template <const size_t NV, const size_t KV>
ETL_CONSTANT size_t permutations<NV, KV>::value;
//***************************************************************************
/// Calculates permutations.
/// Specialisation for KV == 0.
@ -59,6 +62,9 @@ namespace etl
static ETL_CONSTANT size_t value = 1UL;
};
template <const size_t NV>
ETL_CONSTANT size_t permutations<NV, 0>::value;
#if ETL_USING_CPP17
template <size_t NV, size_t KV>
inline constexpr size_t permutations_v = permutations<NV, KV>::value;

10
include/etl/poly_span.h
View File

@ -611,6 +611,9 @@ namespace etl
size_t element_size;
};
template <typename TBase, size_t Extent>
ETL_CONSTANT size_t poly_span<TBase, Extent>::extent;
//***************************************************************************
/// Poly Span - Dynamic Extent
//***************************************************************************
@ -984,6 +987,9 @@ protected:
size_t span_extent;
};
template <typename TBase>
ETL_CONSTANT size_t poly_span<TBase, etl::dynamic_extent>::extent;
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
@ -1028,8 +1034,8 @@ protected:
{
size_t operator()(const etl::poly_span<TBase, Extent>& view) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&view[0]),
reinterpret_cast<const uint8_t*>(&view[view.size()]));
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(view.data()),
reinterpret_cast<const uint8_t*>(view.data() + view.size()));
}
};
#endif

9
include/etl/power.h
View File

@ -63,6 +63,9 @@ namespace etl
static ETL_CONSTANT private_power::type value = NV * power<NV, POWER - 1>::value;
};
template <const size_t NV, const size_t POWER>
ETL_CONSTANT private_power::type power<NV, POWER>::value;
//***************************************************************************
/// Calculates powers.
///\note Only supports positive N.
@ -74,6 +77,9 @@ namespace etl
static ETL_CONSTANT private_power::type value = 1;
};
template <const size_t NV>
ETL_CONSTANT private_power::type power<NV, 0>::value;
#if ETL_USING_CPP17
template <size_t NV, size_t POWER>
inline constexpr size_t power_v = power<NV, POWER>::value;
@ -203,6 +209,9 @@ namespace etl
static ETL_CONSTANT bool value = false;
};
template <const size_t NV>
ETL_CONSTANT bool is_power_of_2<NV>::value;
#if ETL_USING_CPP17
template <size_t NV>
inline constexpr size_t is_power_of_2_v = is_power_of_2<NV>::value;

3
include/etl/priority_queue.h
View File

@ -526,6 +526,9 @@ namespace etl
}
#endif
};
template <typename T, const size_t SIZE, typename TContainer, typename TCompare>
ETL_CONSTANT typename priority_queue<T, SIZE, TContainer, TCompare>::size_type priority_queue<T, SIZE, TContainer, TCompare>::MAX_SIZE;
}
#endif

21
include/etl/private/bitset_legacy.h
View File

@ -183,6 +183,15 @@ namespace etl
return p_bitset->test(position);
}
//*******************************
/// Copy constructor.
//*******************************
bit_reference(const bit_reference& other)
: p_bitset(other.p_bitset)
, position(other.position)
{
}
//*******************************
/// Assignment operator.
//*******************************
@ -1064,6 +1073,12 @@ namespace etl
#endif
};
ETL_CONSTANT ibitset::element_type ibitset::ALL_SET;
ETL_CONSTANT ibitset::element_type ibitset::ALL_CLEAR;
ETL_CONSTANT size_t ibitset::Bits_Per_Element;
//*************************************************************************
/// The class emulates an array of bool elements, but optimized for space allocation.
/// Will accommodate any number of bits.
@ -1429,6 +1444,12 @@ namespace etl
element_type data[Array_Size > 0U ? Array_Size : 1U];
};
template <const size_t MaxN>
ETL_CONSTANT size_t bitset<MaxN>::ALLOCATED_BITS;
template <const size_t MaxN>
ETL_CONSTANT size_t bitset<MaxN>::Allocated_Bits;
//***************************************************************************
/// operator &
///\ingroup bitset

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

@ -76,11 +76,15 @@ SOFTWARE.
namespace etl
{
template <typename T = void>
struct bitset_constants
{
static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
};
template <typename T>
ETL_CONSTANT size_t bitset_constants<T>::npos;
//***************************************************************************
/// Exception base for bitset
///\ingroup bitset
@ -114,7 +118,7 @@ namespace etl
///\ingroup bitset
//*************************************************************************
template <typename TElement>
class bitset_impl : public bitset_constants
class bitset_impl : public bitset_constants<>
{
public:
@ -795,9 +799,18 @@ namespace etl
}
};
template <typename TElement>
ETL_CONSTANT size_t bitset_impl<TElement>::Bits_Per_Element;
template <typename TElement>
ETL_CONSTANT typename bitset_impl<TElement>::element_type bitset_impl<TElement>::All_Set_Element;
template <typename TElement>
ETL_CONSTANT typename bitset_impl<TElement>::element_type bitset_impl<TElement>::All_Clear_Element;
//***************************************************************************
template <size_t Active_Bits = 0U,
typename TElement = void,
typename TElement = char,
bool IsSingleElement = etl::integral_limits<TElement>::bits == Active_Bits>
class bitset;
@ -806,7 +819,7 @@ namespace etl
/// Just defines 'npos'.
//***************************************************************************
template <>
class bitset<0U, void, true> : public bitset_constants
class bitset<0U, char, true> : public bitset_constants<>
{
};
@ -814,7 +827,7 @@ namespace etl
/// Specialisation for zero bits.
//***************************************************************************
template <>
class bitset<0U, void, false> : public bitset_constants
class bitset<0U, char, false> : public bitset_constants<>
{
};
@ -823,7 +836,7 @@ namespace etl
/// same size as the number of active bits.
//***************************************************************************
template <size_t Active_Bits, typename TElement>
class bitset<Active_Bits, TElement, true> : public bitset_constants
class bitset<Active_Bits, TElement, true> : public bitset_constants<>
{
public:
@ -853,6 +866,15 @@ namespace etl
friend class bitset;
//*******************************
/// Copy constructor.
//*******************************
ETL_CONSTEXPR14 bit_reference(const bit_reference& other) ETL_NOEXCEPT
: p_bitset(other.p_bitset)
, position(other.position)
{
}
//*******************************
/// Conversion operator.
//*******************************
@ -1663,11 +1685,32 @@ namespace etl
element_type buffer;
};
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Bits_Per_Element;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Number_Of_Elements;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Allocated_Bits;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT typename bitset<Active_Bits, TElement, true>::element_type bitset<Active_Bits, TElement, true>::All_Set_Element;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT typename bitset<Active_Bits, TElement, true>::element_type bitset<Active_Bits, TElement, true>::All_Clear_Element;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Top_Mask_Shift;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT typename bitset<Active_Bits, TElement, true>::element_type bitset<Active_Bits, TElement, true>::Top_Mask;
//*************************************************************************
/// The specialisation that uses an array of the default element type.
//*************************************************************************
template <size_t Active_Bits, typename TElement>
class bitset<Active_Bits, TElement, false> : public bitset_constants
class bitset<Active_Bits, TElement, false> : public bitset_constants<>
{
private:
@ -1708,6 +1751,15 @@ namespace etl
friend class bitset;
//*******************************
/// Copy constructor.
//*******************************
ETL_CONSTEXPR14 bit_reference(const bit_reference& other) ETL_NOEXCEPT
: p_bitset(other.p_bitset)
, position(other.position)
{
}
//*******************************
/// Conversion operator.
//*******************************
@ -2312,6 +2364,27 @@ namespace etl
element_type buffer[Number_Of_Elements > 0U ? Number_Of_Elements : 1U];
};
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Bits_Per_Element;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Number_Of_Elements;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Allocated_Bits;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT typename bitset<Active_Bits, TElement, false>::element_type bitset<Active_Bits, TElement, false>::All_Set_Element;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT typename bitset<Active_Bits, TElement, false>::element_type bitset<Active_Bits, TElement, false>::All_Clear_Element;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Top_Mask_Shift;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT typename bitset<Active_Bits, TElement, false>::element_type bitset<Active_Bits, TElement, false>::Top_Mask;
//***************************************************************************
/// operator &
///\ingroup bitset
@ -2375,8 +2448,8 @@ namespace etl
{
//***************************************************************************
template <size_t Active_Bits = 0U,
typename TElement = void,
bool IsSingleElement = etl::integral_limits<TElement>::bits == Active_Bits>
typename TElement = char,
bool IsSingleElement = etl::integral_limits<TElement>::bits == Active_Bits>
class bitset_ext;
//***************************************************************************
@ -2384,7 +2457,7 @@ namespace etl
/// Just defines 'npos'.
//***************************************************************************
template <>
class bitset_ext<0U, void, true> : public bitset_constants
class bitset_ext<0U, char, true> : public bitset_constants<>
{
};
@ -2392,7 +2465,7 @@ namespace etl
/// Specialisation for zero bits.
//***************************************************************************
template <>
class bitset_ext<0U, void, false> : public bitset_constants
class bitset_ext<0U, char, false> : public bitset_constants<>
{
};
@ -2401,7 +2474,7 @@ namespace etl
/// same size as the number of active bits.
//***************************************************************************
template <size_t Active_Bits, typename TElement>
class bitset_ext<Active_Bits, TElement, true> : public bitset_constants
class bitset_ext<Active_Bits, TElement, true> : public bitset_constants<>
{
public:
@ -2433,6 +2506,15 @@ namespace etl
friend class bitset_ext;
//*******************************
/// Copy constructor.
//*******************************
ETL_CONSTEXPR14 bit_reference(const bit_reference& other) ETL_NOEXCEPT
: p_bitset(other.p_bitset)
, position(other.position)
{
}
//*******************************
/// Conversion operator.
//*******************************
@ -3240,11 +3322,32 @@ namespace etl
element_type* pbuffer;
};
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Bits_Per_Element;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Number_Of_Elements;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Allocated_Bits;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, true>::element_type bitset_ext<Active_Bits, TElement, true>::All_Set_Element;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, true>::element_type bitset_ext<Active_Bits, TElement, true>::All_Clear_Element;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Top_Mask_Shift;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, true>::element_type bitset_ext<Active_Bits, TElement, true>::Top_Mask;
//*************************************************************************
/// The specialisation that uses an array of the default element type.
//*************************************************************************
template <size_t Active_Bits, typename TElement>
class bitset_ext<Active_Bits, TElement, false> : public bitset_constants
class bitset_ext<Active_Bits, TElement, false> : public bitset_constants<>
{
private:
@ -3287,6 +3390,15 @@ namespace etl
friend class bitset_ext;
//*******************************
/// Copy constructor
//*******************************
ETL_CONSTEXPR14 bit_reference(const bit_reference& other) ETL_NOEXCEPT
: p_bitset(other.p_bitset)
, position(other.position)
{
}
//*******************************
/// Conversion operator.
//*******************************
@ -3891,6 +4003,27 @@ namespace etl
element_type* pbuffer;
};
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Bits_Per_Element;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Number_Of_Elements;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Allocated_Bits;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, false>::element_type bitset_ext<Active_Bits, TElement, false>::All_Set_Element;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, false>::element_type bitset_ext<Active_Bits, TElement, false>::All_Clear_Element;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Top_Mask_Shift;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, false>::element_type bitset_ext<Active_Bits, TElement, false>::Top_Mask;
//***************************************************************************
/// operator !=
///\ingroup bitset

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

@ -33,6 +33,7 @@ SOFTWARE.
#undef ETL_OR_STD
#undef ETL_OR_STD11
#undef ETL_OR_STD14
#if ETL_NOT_USING_STL && !defined(ETL_IN_UNIT_TEST)
// If we're not using the STL and we are not unit testing, then use the ETL's definitions under the etl namespace
@ -58,4 +59,28 @@ SOFTWARE.
#define ETL_USING_ETL11_NAMESPACE 0
#endif
#if (ETL_NOT_USING_STL && !defined(ETL_IN_UNIT_TEST)) || ETL_CPP14_NOT_SUPPORTED
// If we're not using the STL and we are not unit testing or C++14 is not supported, then use the ETL's definitions under the etl namespace
#define ETL_OR_STD14 etl
#define ETL_USING_STD14_NAMESPACE 0
#define ETL_USING_ETL14_NAMESPACE 1
#else
// We will use the STL's definitions under the std namespace
#define ETL_OR_STD14 std
#define ETL_USING_STD14_NAMESPACE 1
#define ETL_USING_ETL14_NAMESPACE 0
#endif
#if (ETL_NOT_USING_STL && !defined(ETL_IN_UNIT_TEST)) || ETL_CPP17_NOT_SUPPORTED
// If we're not using the STL and we are not unit testing or C++17 is not supported, then use the ETL's definitions under the etl namespace
#define ETL_OR_STD17 etl
#define ETL_USING_STD17_NAMESPACE 0
#define ETL_USING_ETL17_NAMESPACE 1
#else
// We will use the STL's definitions under the std namespace
#define ETL_OR_STD17 std
#define ETL_USING_STD17_NAMESPACE 1
#define ETL_USING_ETL17_NAMESPACE 0
#endif
#endif

30
include/etl/private/crc_implementation.h
View File

@ -66,6 +66,9 @@ namespace etl
: TAccumulator(Do_Poly ? (Entry << 1U) ^ Polynomial : (Entry << 1U));
};
template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, TAccumulator Entry>
ETL_CONSTANT TAccumulator crc_partial_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Entry>::value;
//*****************************************************************************
/// CRC Table Entry
//*****************************************************************************
@ -89,6 +92,15 @@ namespace etl
crc_partial_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Entry>::value>::value;
};
template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
ETL_CONSTANT size_t crc_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Index, 2U>::Shift_Bits;
template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
ETL_CONSTANT TAccumulator crc_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Index, 2U>::Entry;
template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
ETL_CONSTANT TAccumulator crc_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Index, 2U>::value;
//*********************************
// Chunk bit size of 4.
template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
@ -105,6 +117,15 @@ namespace etl
crc_partial_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Entry>::value>::value>::value>::value;
};
template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
ETL_CONSTANT size_t crc_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Index, 4U>::Shift_Bits;
template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
ETL_CONSTANT TAccumulator crc_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Index, 4U>::Entry;
template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
ETL_CONSTANT TAccumulator crc_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Index, 4U>::value;
//*********************************
// Chunk bit size of 8.
template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
@ -125,6 +146,15 @@ namespace etl
crc_partial_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Entry>::value>::value>::value>::value>::value>::value>::value>::value;
};
template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
ETL_CONSTANT size_t crc_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Index, 8U>::Shift_Bits;
template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
ETL_CONSTANT TAccumulator crc_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Index, 8U>::Entry;
template <typename TAccumulator, size_t Accumulator_Bits, TAccumulator Polynomial, bool Reflect, size_t Index>
ETL_CONSTANT TAccumulator crc_table_entry<TAccumulator, Accumulator_Bits, Polynomial, Reflect, Index, 8U>::value;
//*****************************************************************************
/// CRC Update Chunk
//*****************************************************************************

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

@ -53,6 +53,21 @@ namespace etl
static ETL_CONSTANT size_t Accumulator_Bits = etl::integral_limits<accumulator_type>::bits;
};
template <typename TAccumulator, TAccumulator Polynomial_, TAccumulator Initial_, TAccumulator Xor_Out_, bool Reflect_>
ETL_CONSTANT TAccumulator crc_parameters<TAccumulator, Polynomial_, Initial_, Xor_Out_, Reflect_>::Polynomial;
template <typename TAccumulator, TAccumulator Polynomial_, TAccumulator Initial_, TAccumulator Xor_Out_, bool Reflect_>
ETL_CONSTANT TAccumulator crc_parameters<TAccumulator, Polynomial_, Initial_, Xor_Out_, Reflect_>::Initial;
template <typename TAccumulator, TAccumulator Polynomial_, TAccumulator Initial_, TAccumulator Xor_Out_, bool Reflect_>
ETL_CONSTANT TAccumulator crc_parameters<TAccumulator, Polynomial_, Initial_, Xor_Out_, Reflect_>::Xor_Out;
template <typename TAccumulator, TAccumulator Polynomial_, TAccumulator Initial_, TAccumulator Xor_Out_, bool Reflect_>
ETL_CONSTANT bool crc_parameters<TAccumulator, Polynomial_, Initial_, Xor_Out_, Reflect_>::Reflect;
template <typename TAccumulator, TAccumulator Polynomial_, TAccumulator Initial_, TAccumulator Xor_Out_, bool Reflect_>
ETL_CONSTANT size_t crc_parameters<TAccumulator, Polynomial_, Initial_, Xor_Out_, Reflect_>::Accumulator_Bits;
// 8 bit.
typedef crc_parameters<uint8_t, 0x07U, 0x00U, 0x00U, false> crc8_ccitt_parameters;
typedef crc_parameters<uint8_t, 0x07U, 0xFFU, 0x00U, true> crc8_rohc_parameters;

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

@ -1352,10 +1352,10 @@ namespace etl
/// in which every recursive instantiation of `visit_result_helper` appends
/// more elements and give it a pass through `common_type_t`.
//***************************************************************************
template <template <typename...> typename, typename...>
template <template <typename...> class, typename...>
struct visit_result_helper;
template <template <typename...> typename TToInject, size_t... tAltIndices, typename TCur>
template <template <typename...> class TToInject, size_t... tAltIndices, typename TCur>
struct visit_result_helper<TToInject, index_sequence<tAltIndices...>, TCur>
{
template <size_t tIndex>
@ -1365,7 +1365,7 @@ namespace etl
using type = common_type_t<TToInject<var_type<tAltIndices> >...>;
};
template <template <typename...> typename TToInject, size_t... tAltIndices, typename TCur, typename TNext, typename... TVs>
template <template <typename...> class TToInject, size_t... tAltIndices, typename TCur, typename TNext, typename... TVs>
struct visit_result_helper<TToInject, index_sequence<tAltIndices...>, TCur, TNext, TVs...>
{
template <size_t tIndex>

33
include/etl/pseudo_moving_average.h
View File

@ -48,8 +48,8 @@ namespace etl
public:
//***********************************
explicit add_insert_iterator(TCMA& cma) ETL_NOEXCEPT
: p_cma(&cma)
explicit add_insert_iterator(TCMA& pma) ETL_NOEXCEPT
: p_pma(&pma)
{
}
@ -74,18 +74,18 @@ namespace etl
//***********************************
add_insert_iterator& operator =(typename TCMA::value_type value)
{
p_cma->add(value);
p_pma->add(value);
return *this;
}
private:
TCMA* p_cma;
TCMA* p_pma;
};
}
//***************************************************************************
/// Cumulative Moving Average
/// Pseudo Moving Average
/// \tparam T The sample value type.
/// \tparam SAMPLE_SIZE The number of samples to average over.
/// \tparam SCALING The scaling factor applied to samples. Default = 1.
@ -98,7 +98,7 @@ namespace etl
class pseudo_moving_average;
//***************************************************************************
/// Cumulative Moving Average
/// Pseudo Moving Average
/// For integral types.
/// \tparam T The sample value type.
/// \tparam SAMPLE_SIZE The number of samples to average over.
@ -177,8 +177,14 @@ namespace etl
T average; ///< The current pseudo moving average.
};
template <typename T, const size_t SAMPLE_SIZE_, const size_t SCALING_>
ETL_CONSTANT size_t pseudo_moving_average<T, SAMPLE_SIZE_, SCALING_, true, false>::SAMPLE_SIZE;
template <typename T, const size_t SAMPLE_SIZE_, const size_t SCALING_>
ETL_CONSTANT size_t pseudo_moving_average<T, SAMPLE_SIZE_, SCALING_, true, false>::SCALING;
//***************************************************************************
/// Cumulative Moving Average
/// Pseudo Moving Average
/// For integral types.
/// \tparam T The sample value type.
/// \tparam SCALING The scaling factor applied to samples. Default = 1.
@ -263,8 +269,11 @@ namespace etl
sample_t samples; ///< The number of samples to average over.
};
template <typename T, const size_t SCALING_>
ETL_CONSTANT size_t pseudo_moving_average<T, 0, SCALING_, true, false>::SCALING;
//***************************************************************************
/// Cumulative Moving Average
/// Pseudo Moving Average
/// For floating point types.
/// \tparam T The sample value type.
/// \tparam SAMPLE_SIZE The number of samples to average over.
@ -333,11 +342,13 @@ namespace etl
T average; ///< The current pseudo moving average.
};
template <typename T, const size_t SAMPLE_SIZE_>
ETL_CONSTANT size_t pseudo_moving_average<T, SAMPLE_SIZE_, 1U, false, true>::SAMPLE_SIZE;
//***************************************************************************
/// Cumulative Moving Average
/// Pseudo Moving Average
/// For floating point types.
/// \tparam T The sample value type.
/// \tparam SAMPLE_SIZE The number of samples to average over.
/// \tparam T The sample value type.
//***************************************************************************
template <typename T>
class pseudo_moving_average<T, 0U, 1U, false, true>

3
include/etl/queue.h
View File

@ -660,6 +660,9 @@ namespace etl
/// The uninitialised buffer of T used in the queue.
container_type buffer[SIZE];
};
template <typename T, const size_t SIZE, const size_t MEMORY_MODEL>
ETL_CONSTANT typename queue<T, SIZE, MEMORY_MODEL>::size_type queue<T, SIZE, MEMORY_MODEL>::MAX_SIZE;
}
#endif

6
include/etl/queue_lockable.h
View File

@ -837,6 +837,12 @@ namespace etl
/// The uninitialised buffer of T used in the queue_lockable.
etl::uninitialized_buffer_of<T, Max_Size> buffer;
};
template <typename T, size_t VSize, size_t VMemory_Model>
ETL_CONSTANT typename queue_lockable<T, VSize, VMemory_Model>::size_type queue_lockable<T, VSize, VMemory_Model>::Max_Size;
template <typename T, size_t VSize, size_t VMemory_Model>
ETL_CONSTANT typename queue_lockable<T, VSize, VMemory_Model>::size_type queue_lockable<T, VSize, VMemory_Model>::Memory_Model;
}
#endif

3
include/etl/queue_mpmc_mutex.h
View File

@ -676,6 +676,9 @@ namespace etl
/// The uninitialised buffer of T used in the queue_mpmc_mutex.
typename etl::aligned_storage<sizeof(T), etl::alignment_of<T>::value>::type buffer[MAX_SIZE];
};
template <typename T, size_t SIZE, const size_t MEMORY_MODEL>
ETL_CONSTANT typename queue_mpmc_mutex<T, SIZE, MEMORY_MODEL>::size_type queue_mpmc_mutex<T, SIZE, MEMORY_MODEL>::MAX_SIZE;
}
#endif

3
include/etl/queue_spsc_atomic.h
View File

@ -541,6 +541,9 @@ namespace etl
/// The uninitialised buffer of T used in the queue_spsc.
typename etl::aligned_storage<sizeof(T), etl::alignment_of<T>::value>::type buffer[RESERVED_SIZE];
};
template <typename T, size_t SIZE, const size_t MEMORY_MODEL>
ETL_CONSTANT typename queue_spsc_atomic<T, SIZE, MEMORY_MODEL>::size_type queue_spsc_atomic<T, SIZE, MEMORY_MODEL>::MAX_SIZE;
}
#endif

3
include/etl/queue_spsc_isr.h
View File

@ -797,6 +797,9 @@ namespace etl
/// The uninitialised buffer of T used in the queue_spsc_isr.
typename etl::aligned_storage<sizeof(T), etl::alignment_of<T>::value>::type buffer[MAX_SIZE];
};
template <typename T, size_t SIZE, typename TAccess, const size_t MEMORY_MODEL>
ETL_CONSTANT typename queue_spsc_isr<T, SIZE, TAccess, MEMORY_MODEL>::size_type queue_spsc_isr<T, SIZE, TAccess, MEMORY_MODEL>::MAX_SIZE;
}
#endif

3
include/etl/queue_spsc_locked.h
View File

@ -860,6 +860,9 @@ namespace etl
/// The uninitialised buffer of T used in the queue_lockable.
etl::uninitialized_buffer_of<T, MAX_SIZE> buffer;
};
template <typename T, size_t SIZE, const size_t MEMORY_MODEL>
ETL_CONSTANT typename queue_spsc_locked<T, SIZE, MEMORY_MODEL>::size_type queue_spsc_locked<T, SIZE, MEMORY_MODEL>::MAX_SIZE;
}
#endif

6
include/etl/ratio.h
View File

@ -48,6 +48,12 @@ namespace etl
static ETL_CONSTANT intmax_t den = DEN;
};
template <const size_t NUM, const size_t DEN>
ETL_CONSTANT intmax_t ratio<NUM, DEN>::num;
template <const size_t NUM, const size_t DEN>
ETL_CONSTANT intmax_t ratio<NUM, DEN>::den;
#if INT_MAX > INT32_MAX
typedef ratio<1, 1000000000000000000000000> yocto;
typedef ratio<1, 1000000000000000000000> zepto;

26
include/etl/reference_counted_message_pool.h
View File

@ -214,6 +214,7 @@ namespace etl
// The maximum alignment.
static constexpr size_t max_alignment = etl::alignment_of<etl::reference_counted_message<TMessage1, TCounter>>::value;
};
#else
template <typename TMessage1, typename TMessage2 = TMessage1, typename TMessage3 = TMessage1, typename TMessage4 = TMessage1,
typename TMessage5 = TMessage1, typename TMessage6 = TMessage1, typename TMessage7 = TMessage1, typename TMessage8 = TMessage1>
@ -247,6 +248,7 @@ namespace etl
etl::reference_counted_message<TMessage7, TCounter>,
etl::reference_counted_message<TMessage8, TCounter> >::alignment;
};
#endif
private:
@ -259,6 +261,30 @@ namespace etl
reference_counted_message_pool& operator =(const reference_counted_message_pool&) ETL_DELETE;
};
#if ETL_USING_CPP11
template <typename TCounter>
template <typename TMessage1, typename... TMessages>
constexpr size_t reference_counted_message_pool<TCounter>::pool_message_parameters<TMessage1, TMessages...>::max_size;
template <typename TCounter>
template <typename TMessage1, typename... TMessages>
constexpr size_t reference_counted_message_pool<TCounter>::pool_message_parameters<TMessage1, TMessages...>::max_alignment;
#else
template <typename TCounter>
template <typename TMessage1, typename TMessage2, typename TMessage3, typename TMessage4,
typename TMessage5, typename TMessage6, typename TMessage7, typename TMessage8>
const size_t reference_counted_message_pool<TCounter>::pool_message_parameters<TMessage1, TMessage2, TMessage3, TMessage4, TMessage5, TMessage6, TMessage7, TMessage8>::max_size;
template <typename TCounter>
template <typename TMessage1, typename TMessage2, typename TMessage3, typename TMessage4,
typename TMessage5, typename TMessage6, typename TMessage7, typename TMessage8>
const size_t reference_counted_message_pool<TCounter>::pool_message_parameters<TMessage1, TMessage2, TMessage3, TMessage4, TMessage5, TMessage6, TMessage7, TMessage8>::max_alignment;
#endif
#if ETL_USING_CPP11 && ETL_HAS_ATOMIC
using atomic_counted_message_pool = reference_counted_message_pool<etl::atomic_int>;
#endif

3
include/etl/reference_flat_map.h
View File

@ -1175,6 +1175,9 @@ namespace etl
etl::vector<node_t*, MAX_SIZE> lookup;
};
template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare>
ETL_CONSTANT size_t reference_flat_map< TKey, TValue, MAX_SIZE_, TCompare>::MAX_SIZE;
//*************************************************************************
/// Template deduction guides.
//*************************************************************************

3
include/etl/reference_flat_multimap.h
View File

@ -1041,6 +1041,9 @@ namespace etl
etl::vector<node_t*, MAX_SIZE> lookup;
};
template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare>
ETL_CONSTANT size_t reference_flat_multimap< TKey, TValue, MAX_SIZE_, TCompare>::MAX_SIZE;
//*************************************************************************
/// Template deduction guides.
//*************************************************************************

3
include/etl/reference_flat_multiset.h
View File

@ -991,6 +991,9 @@ namespace etl
etl::vector<value_type*, MAX_SIZE> lookup;
};
template <typename TKey, const size_t MAX_SIZE_, typename TCompare>
ETL_CONSTANT size_t reference_flat_multiset<TKey, MAX_SIZE_, TCompare>::MAX_SIZE;
//*************************************************************************
/// Template deduction guides.
//*************************************************************************

3
include/etl/reference_flat_set.h
View File

@ -981,6 +981,9 @@ namespace etl
etl::vector<value_type*, MAX_SIZE> lookup;
};
template <typename TKey, const size_t MAX_SIZE_, typename TCompare>
ETL_CONSTANT size_t reference_flat_set<TKey, MAX_SIZE_, TCompare>::MAX_SIZE;
//*************************************************************************
/// Template deduction guides.
//*************************************************************************

3
include/etl/set.h
View File

@ -2625,6 +2625,9 @@ namespace etl
etl::pool<typename etl::iset<TKey, TCompare>::Data_Node, MAX_SIZE> node_pool;
};
template <typename TKey, const size_t MAX_SIZE_, typename TCompare>
ETL_CONSTANT size_t set<TKey, MAX_SIZE_, TCompare>::MAX_SIZE;
//*************************************************************************
/// Template deduction guides.
//*************************************************************************

14
include/etl/smallest.h
View File

@ -303,6 +303,9 @@ namespace etl
typedef typename private_smallest::best_fit_uint_type<TYPE_INDEX>::type type;
};
template <size_t NBITS>
ETL_CONSTANT int smallest_uint_for_bits<NBITS>::TYPE_INDEX;
#if ETL_USING_CPP11
template <size_t NBITS>
using smallest_uint_for_bits_t = typename smallest_uint_for_bits<NBITS>::type;
@ -329,6 +332,9 @@ namespace etl
typedef typename private_smallest::best_fit_int_type<TYPE_INDEX>::type type;
};
template <size_t NBITS>
ETL_CONSTANT int smallest_int_for_bits<NBITS>::TYPE_INDEX;
#if ETL_USING_CPP11
template <size_t NBITS>
using smallest_int_for_bits_t = typename smallest_int_for_bits<NBITS>::type;
@ -355,6 +361,9 @@ namespace etl
typedef typename private_smallest::best_fit_uint_type<TYPE_INDEX>::type type;
};
template <uintmax_t NBITS>
ETL_CONSTANT int smallest_uint_for_value<NBITS>::TYPE_INDEX;
#if ETL_USING_CPP11
template <uintmax_t VALUE>
using smallest_uint_for_value_t = typename smallest_uint_for_value<VALUE>::type;
@ -366,7 +375,7 @@ namespace etl
/// Defines 'type' which is the type of the smallest signed integer.
///\ingroup smallest
//***************************************************************************
template <const intmax_t VALUE>
template <intmax_t VALUE>
struct smallest_int_for_value
{
private:
@ -381,6 +390,9 @@ namespace etl
typedef typename private_smallest::best_fit_int_type<TYPE_INDEX>::type type;
};
template <intmax_t NBITS>
ETL_CONSTANT int smallest_int_for_value<NBITS>::TYPE_INDEX;
#if ETL_USING_CPP11
template <intmax_t VALUE>
using smallest_int_for_value_t = typename smallest_int_for_value<VALUE>::type;

10
include/etl/span.h
View File

@ -849,6 +849,12 @@ namespace etl
pointer pend;
};
template <typename T, size_t Extent>
ETL_CONSTANT size_t span<T, Extent>::extent;
template <typename T>
ETL_CONSTANT size_t span<T, etl::dynamic_extent>::extent;
//*************************************************************************
/// Compare two spans for equality.
//*************************************************************************
@ -933,8 +939,8 @@ namespace etl
{
size_t operator()(const etl::span<T>& view) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&view[0]),
reinterpret_cast<const uint8_t*>(&view[view.size()]));
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(view.data()),
reinterpret_cast<const uint8_t*>(view.data() + view.size()));
}
};
#endif

5
include/etl/sqrt.h
View File

@ -60,6 +60,11 @@ namespace etl
#endif
};
#if ETL_USING_CPP11
template <size_t VALUE, size_t I>
constexpr size_t sqrt<VALUE, I>::value;
#endif
#if ETL_USING_CPP17
template <size_t VALUE, size_t I = 1>
inline constexpr size_t sqrt_v = sqrt<VALUE, I>::value;

3
include/etl/stack.h
View File

@ -601,6 +601,9 @@ namespace etl
/// The uninitialised buffer of T used in the stack.
container_type buffer[SIZE];
};
template <typename T, const size_t SIZE>
ETL_CONSTANT size_t stack<T, SIZE>::MAX_SIZE;
}
#endif

20
include/etl/standard_deviation.h
View File

@ -73,10 +73,24 @@ namespace etl
//***************************************************************************
/// Standard Deviation Type.
//***************************************************************************
struct standard_deviation_type
namespace private_standard_deviation
{
template<typename T = void>
struct standard_deviation_type_helper
{
static ETL_CONSTANT bool Sample = false;
static ETL_CONSTANT bool Population = true;
};
template <typename T>
ETL_CONSTANT bool standard_deviation_type_helper<T>::Sample;
template <typename T>
ETL_CONSTANT bool standard_deviation_type_helper<T>::Population;
}
struct standard_deviation_type : public private_standard_deviation::standard_deviation_type_helper<>
{
static ETL_CONSTANT bool Sample = false;
static ETL_CONSTANT bool Population = true;
};
//***************************************************************************

15
include/etl/string.h
View File

@ -259,6 +259,9 @@ namespace etl
value_type buffer[MAX_SIZE + 1];
};
template <size_t MAX_SIZE_>
ETL_CONSTANT size_t string<MAX_SIZE_>::MAX_SIZE;
//***************************************************************************
/// A string implementation that uses a fixed size external buffer.
///\ingroup string
@ -455,8 +458,8 @@ namespace etl
{
size_t operator()(const etl::istring& text) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
reinterpret_cast<const uint8_t*>(&text[text.size()]));
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
reinterpret_cast<const uint8_t*>(text.data() + text.size()));
}
};
@ -465,8 +468,8 @@ namespace etl
{
size_t operator()(const etl::string<SIZE>& text) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
reinterpret_cast<const uint8_t*>(&text[text.size()]));
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
reinterpret_cast<const uint8_t*>(text.data() + text.size()));
}
};
@ -475,8 +478,8 @@ namespace etl
{
size_t operator()(const etl::string_ext& text) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
reinterpret_cast<const uint8_t*>(&text[text.size()]));
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
reinterpret_cast<const uint8_t*>(text.data() + text.size()));
}
};
#endif

16
include/etl/string_view.h
View File

@ -852,8 +852,8 @@ namespace etl
{
size_t operator()(const etl::string_view& text) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
reinterpret_cast<const uint8_t*>(&text[text.size()]));
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
reinterpret_cast<const uint8_t*>(text.data() + text.size()));
}
};
@ -862,8 +862,8 @@ namespace etl
{
size_t operator()(const etl::wstring_view& text) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
reinterpret_cast<const uint8_t*>(&text[text.size()]));
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
reinterpret_cast<const uint8_t*>(text.data() + text.size()));
}
};
@ -872,8 +872,8 @@ namespace etl
{
size_t operator()(const etl::u16string_view& text) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
reinterpret_cast<const uint8_t*>(&text[text.size()]));
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
reinterpret_cast<const uint8_t*>(text.data() + text.size()));
}
};
@ -882,8 +882,8 @@ namespace etl
{
size_t operator()(const etl::u32string_view& text) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
reinterpret_cast<const uint8_t*>(&text[text.size()]));
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
reinterpret_cast<const uint8_t*>(text.data() + text.size()));
}
};
#endif

55
include/etl/to_arithmetic.h
View File

@ -193,11 +193,34 @@ namespace etl
namespace private_to_arithmetic
{
static ETL_CONSTANT char Positive_Char = '+';
static ETL_CONSTANT char Negative_Char = '-';
static ETL_CONSTANT char Radix_Point1_Char = '.';
static ETL_CONSTANT char Radix_Point2_Char = ',';
static ETL_CONSTANT char Exponential_Char = 'e';
template <typename T = void>
struct char_statics
{
static ETL_CONSTANT char Positive_Char = '+';
static ETL_CONSTANT char Negative_Char = '-';
static ETL_CONSTANT char Radix_Point1_Char = '.';
static ETL_CONSTANT char Radix_Point2_Char = ',';
static ETL_CONSTANT char Exponential_Char = 'e';
};
template <typename T>
ETL_CONSTANT char char_statics<T>::Positive_Char;
template <typename T>
ETL_CONSTANT char char_statics<T>::Negative_Char;
template <typename T>
ETL_CONSTANT char char_statics<T>::Radix_Point1_Char;
template <typename T>
ETL_CONSTANT char char_statics<T>::Radix_Point2_Char;
template <typename T>
ETL_CONSTANT char char_statics<T>::Exponential_Char;
struct char_constant : char_statics<>
{
};
//*******************************************
ETL_NODISCARD
@ -312,8 +335,8 @@ namespace etl
{
// Check for prefix.
const char c = convert(view[0]);
const bool has_positive_prefix = (c == Positive_Char);
const bool has_negative_prefix = (c == Negative_Char);
const bool has_positive_prefix = (c == char_constant::Positive_Char);
const bool has_negative_prefix = (c == char_constant::Negative_Char);
// Step over the prefix, if present.
if (has_positive_prefix || has_negative_prefix)
@ -465,19 +488,19 @@ namespace etl
//***************************
case Parsing_Integral:
{
if (expecting_sign && ((c == Positive_Char) || (c == Negative_Char)))
if (expecting_sign && ((c == char_constant::Positive_Char) || (c == char_constant::Negative_Char)))
{
is_negative_mantissa = (c == Negative_Char);
is_negative_mantissa = (c == char_constant::Negative_Char);
expecting_sign = false;
}
// Radix point?
else if ((c == Radix_Point1_Char) || (c == Radix_Point2_Char))
else if ((c == char_constant::Radix_Point1_Char) || (c == char_constant::Radix_Point2_Char))
{
expecting_sign = false;
state = Parsing_Fractional;
}
// Exponential?
else if (c == Exponential_Char)
else if (c == char_constant::Exponential_Char)
{
expecting_sign = true;
state = Parsing_Exponential;
@ -502,13 +525,13 @@ namespace etl
case Parsing_Fractional:
{
// Radix point?
if ((c == Radix_Point1_Char) || (c == Radix_Point2_Char))
if ((c == char_constant::Radix_Point1_Char) || (c == char_constant::Radix_Point2_Char))
{
conversion_status = to_arithmetic_status::Invalid_Format;
is_success = false;
}
// Exponential?
else if (c == Exponential_Char)
else if (c == char_constant::Exponential_Char)
{
expecting_sign = true;
state = Parsing_Exponential;
@ -532,13 +555,13 @@ namespace etl
//***************************
case Parsing_Exponential:
{
if (expecting_sign && ((c == Positive_Char) || (c == Negative_Char)))
if (expecting_sign && ((c == char_constant::Positive_Char) || (c == char_constant::Negative_Char)))
{
is_negative_exponent = (c == Negative_Char);
is_negative_exponent = (c == char_constant::Negative_Char);
expecting_sign = false;
}
// Radix point?
else if ((c == Radix_Point1_Char) || (c == Radix_Point2_Char) || (c == Exponential_Char))
else if ((c == char_constant::Radix_Point1_Char) || (c == char_constant::Radix_Point2_Char) || (c == char_constant::Exponential_Char))
{
conversion_status = to_arithmetic_status::Invalid_Format;
is_success = false;

4
include/etl/type_lookup.h
View File

@ -125,14 +125,14 @@ namespace etl
template <typename T, typename T1, typename... TRest>
struct id_from_type_helper
{
static constexpr size_t value = etl::is_same<T, typename T1::type>::value ? T1::ID : id_from_type_helper<T, TRest...>::value;
static constexpr size_t value = etl::is_same<T, typename T1::type>::value ? size_t(T1::ID) : id_from_type_helper<T, TRest...>::value;
};
// Specialisation for 1 type pair.
template <typename T, typename T1>
struct id_from_type_helper<T, T1>
{
static constexpr size_t value = etl::is_same<T, typename T1::type>::value ? T1::ID : UNKNOWN;
static constexpr size_t value = etl::is_same<T, typename T1::type>::value ? size_t(T1::ID) : UNKNOWN;
};
public:

70
include/etl/type_traits.h
View File

@ -84,7 +84,7 @@ namespace etl
//***************************************************************************
/// integral_constant
template <typename T, const T VALUE>
template <typename T, T VALUE>
struct integral_constant
{
static const T value = VALUE;
@ -102,12 +102,12 @@ namespace etl
typedef integral_constant<bool, false> false_type;
typedef integral_constant<bool, true> true_type;
template <typename T, const T VALUE>
template <typename T, T VALUE>
const T integral_constant<T, VALUE>::value;
#if ETL_USING_CPP17
template <typename T, T VALUE>
inline constexpr T integral_constant_v = std::integral_constant<T, VALUE>::value;
inline constexpr T integral_constant_v = etl::integral_constant<T, VALUE>::value;
#endif
#if ETL_USING_CPP11
@ -120,7 +120,7 @@ namespace etl
#if ETL_USING_CPP17
template <bool B>
inline constexpr bool bool_constant_v = std::bool_constant<B>::value;
inline constexpr bool bool_constant_v = bool_constant<B>::value;
#endif
//***************************************************************************
@ -839,7 +839,7 @@ typedef integral_constant<bool, true> true_type;
#if ETL_USING_CPP17
template <bool B>
inline constexpr bool bool_constant_v = std::bool_constant<B>::value;
inline constexpr bool bool_constant_v = bool_constant<B>::value;
#endif
//***************************************************************************
@ -847,9 +847,7 @@ typedef integral_constant<bool, true> true_type;
///\ingroup type_traits
#if ETL_USING_CPP17
template <typename T>
struct negation : std::negation<T>
{
};
using negation = std::negation<T>;
#else
template <typename T>
struct negation : etl::bool_constant<!bool(T::value)>
@ -1630,99 +1628,71 @@ typedef integral_constant<bool, true> true_type;
//*********************************************
// is_assignable
template<typename T1, typename T2>
struct is_assignable : public std::is_assignable<T1, T2>
{
};
using is_assignable = std::is_assignable<T1, T2>;
//*********************************************
// is_constructible
template<typename T, typename... TArgs>
struct is_constructible : public std::is_constructible<T, TArgs...>
{
};
using is_constructible = std::is_constructible<T, TArgs...>;
//*********************************************
// is_copy_constructible
template <typename T>
struct is_copy_constructible : public std::is_copy_constructible<T>
{
};
using is_copy_constructible = std::is_copy_constructible<T>;
//*********************************************
// is_move_constructible
template <typename T>
struct is_move_constructible : public std::is_move_constructible<T>
{
};
using is_move_constructible = std::is_move_constructible<T>;
//*********************************************
// is_trivially_constructible
#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T>
struct is_trivially_constructible : public std::is_trivially_constructible<T>
{
};
using is_trivially_constructible = std::is_trivially_constructible<T>;
#else
template <typename T>
struct is_trivially_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
using is_trivially_constructible = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
#endif
//*********************************************
// is_trivially_copy_constructible
#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T>
struct is_trivially_copy_constructible : public std::is_trivially_copy_constructible<T>
{
};
using is_trivially_copy_constructible = std::is_trivially_copy_constructible<T>;
#else
template <typename T>
struct is_trivially_copy_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
using is_trivially_copy_constructible = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
#endif
//*********************************************
// is_trivially_destructible
#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T>
struct is_trivially_destructible : public std::is_trivially_destructible<T>
{
};
using is_trivially_destructible = std::is_trivially_destructible<T>;
#else
template <typename T>
struct is_trivially_destructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
using is_trivially_destructible = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
#endif
//*********************************************
// is_trivially_copy_assignable
#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T>
struct is_trivially_copy_assignable : public std::is_trivially_copy_assignable<T>
{
};
using is_trivially_copy_assignable = std::is_trivially_copy_assignable<T>;
#else
template <typename T>
struct is_trivially_copy_assignable : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
using is_trivially_copy_assignable = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
#endif
//*********************************************
// is_trivially_copyable
#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T>
struct is_trivially_copyable : public std::is_trivially_copyable<T>
{
};
using is_trivially_copyable = std::is_trivially_copyable<T>;
#else
template <typename T>
struct is_trivially_copyable : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
using is_trivially_copyable = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
#endif
#elif defined(ETL_USE_TYPE_TRAITS_BUILTINS) && !defined(ETL_USER_DEFINED_TYPE_TRAITS)

12
include/etl/u16string.h
View File

@ -438,8 +438,8 @@ namespace etl
{
size_t operator()(const etl::iu16string& text) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
reinterpret_cast<const uint8_t*>(&text[text.size()]));
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
reinterpret_cast<const uint8_t*>(text.data() + text.size()));
}
};
@ -448,8 +448,8 @@ namespace etl
{
size_t operator()(const etl::u16string<SIZE>& text) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
reinterpret_cast<const uint8_t*>(&text[text.size()]));
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
reinterpret_cast<const uint8_t*>(text.data() + text.size()));
}
};
@ -458,8 +458,8 @@ namespace etl
{
size_t operator()(const etl::u16string_ext& text) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
reinterpret_cast<const uint8_t*>(&text[text.size()]));
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
reinterpret_cast<const uint8_t*>(text.data() + text.size()));
}
};
#endif

12
include/etl/u32string.h
View File

@ -438,8 +438,8 @@ namespace etl
{
size_t operator()(const etl::iu32string& text) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
reinterpret_cast<const uint8_t*>(&text[text.size()]));
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
reinterpret_cast<const uint8_t*>(text.data() + text.size()));
}
};
@ -448,8 +448,8 @@ namespace etl
{
size_t operator()(const etl::u32string<SIZE>& text) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
reinterpret_cast<const uint8_t*>(&text[text.size()]));
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
reinterpret_cast<const uint8_t*>(text.data() + text.size()));
}
};
@ -458,8 +458,8 @@ namespace etl
{
size_t operator()(const etl::u32string_ext& text) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
reinterpret_cast<const uint8_t*>(&text[text.size()]));
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
reinterpret_cast<const uint8_t*>(text.data() + text.size()));
}
};
#endif

9
include/etl/unaligned_type.h
View File

@ -214,6 +214,9 @@ namespace etl
unsigned char storage[Size];
};
template <size_t Size_>
ETL_CONSTANT size_t unaligned_type_common<Size_>::Size;
}
//*************************************************************************
@ -599,6 +602,12 @@ namespace etl
};
};
template <typename T, int Endian_>
ETL_CONSTANT int unaligned_type<T, Endian_>::Endian;
template <typename T, int Endian_>
ETL_CONSTANT size_t unaligned_type<T, Endian_>::Size;
#if ETL_HAS_CONSTEXPR_ENDIANNESS
// Host order
typedef unaligned_type<char, etl::endianness::value()> host_char_t;

26
include/etl/variance.h
View File

@ -43,7 +43,7 @@ namespace etl
namespace private_variance
{
//***************************************************************************
/// Types for generic correlation.
/// Types for generic variance.
//***************************************************************************
template <typename TInput, typename TCalc>
struct variance_traits
@ -52,7 +52,7 @@ namespace etl
};
//***************************************************************************
/// Types for float correlation.
/// Types for float variance.
//***************************************************************************
template <typename TCalc>
struct variance_traits<float, TCalc>
@ -61,7 +61,7 @@ namespace etl
};
//***************************************************************************
/// Types for double correlation.
/// Types for double variance.
//***************************************************************************
template <typename TCalc>
struct variance_traits<double, TCalc>
@ -73,10 +73,24 @@ namespace etl
//***************************************************************************
/// Variance Type.
//***************************************************************************
struct variance_type
namespace private_variance
{
template<typename T = void>
struct variance_type_helper
{
static ETL_CONSTANT bool Sample = false;
static ETL_CONSTANT bool Population = true;
};
template <typename T>
ETL_CONSTANT bool variance_type_helper<T>::Sample;
template <typename T>
ETL_CONSTANT bool variance_type_helper<T>::Population;
}
struct variance_type : public private_variance::variance_type_helper<>
{
static ETL_CONSTANT bool Sample = false;
static ETL_CONSTANT bool Population = true;
};
//***************************************************************************

12
include/etl/wstring.h
View File

@ -438,8 +438,8 @@ namespace etl
{
size_t operator()(const etl::iwstring& text) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
reinterpret_cast<const uint8_t*>(&text[text.size()]));
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
reinterpret_cast<const uint8_t*>(text.data() + text.size()));
}
};
@ -448,8 +448,8 @@ namespace etl
{
size_t operator()(const etl::wstring<SIZE>& text) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
reinterpret_cast<const uint8_t*>(&text[text.size()]));
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
reinterpret_cast<const uint8_t*>(text.data() + text.size()));
}
};
@ -458,8 +458,8 @@ namespace etl
{
size_t operator()(const etl::wstring_ext& text) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&text[0]),
reinterpret_cast<const uint8_t*>(&text[text.size()]));
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
reinterpret_cast<const uint8_t*>(text.data() + text.size()));
}
};
#endif

13
test/CMakeLists.txt
View File

@ -16,10 +16,10 @@ add_executable(etl_tests
test_algorithm.cpp
test_alignment.cpp
test_array.cpp
test_array_view.cpp
test_array_view.cpp
test_array_wrapper.cpp
test_atomic.cpp
test_binary.cpp
test_binary.cpp
test_bip_buffer_spsc_atomic.cpp
test_bit.cpp
test_bitset_legacy.cpp
@ -147,7 +147,7 @@ add_executable(etl_tests
test_largest.cpp
test_limiter.cpp
test_limits.cpp
test_list.cpp
test_list.cpp
test_list_shared_pool.cpp
test_make_string.cpp
test_map.cpp
@ -156,7 +156,7 @@ add_executable(etl_tests
test_mem_cast.cpp
test_mem_cast_ptr.cpp
test_memory.cpp
test_message_broker.cpp
test_message_broker.cpp
test_message_bus.cpp
test_message_packet.cpp
test_message_router.cpp
@ -164,7 +164,7 @@ add_executable(etl_tests
test_message_timer.cpp
test_message_timer_atomic.cpp
test_message_timer_interrupt.cpp
test_message_timer_locked.cpp
test_message_timer_locked.cpp
test_multimap.cpp
test_multiset.cpp
test_multi_array.cpp
@ -288,7 +288,7 @@ if (ETL_CXX_STANDARD MATCHES "98")
message(STATUS "Compiling for C++98")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 98)
elseif (ETL_CXX_STANDARD MATCHES "03")
message(STATUS "Compiling for C++98")
message(STATUS "Compiling for C++03 (C++98)")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 98)
elseif (ETL_CXX_STANDARD MATCHES "11")
message(STATUS "Compiling for C++11")
@ -359,6 +359,7 @@ if ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Cla
target_compile_options(etl_tests
PRIVATE
-fno-omit-frame-pointer
-fno-common
-Wall
-Wextra
-Werror

2
test/UnitTest++/Checks.h
View File

@ -170,7 +170,7 @@ namespace UnitTest
}
template< typename Expected, typename Actual >
void CheckEqual(TestResults& results, Expected const& expected, Actual const& actual, TestDetails const& details)
void CheckEqual(TestResults& results, Expected&& expected, Actual&& actual, TestDetails const& details)
{
if (!(expected == actual))
{

23
test/etl_initializer_list/CMakeLists.txt
View File

@ -30,6 +30,26 @@ if (ETL_OPTIMISATION MATCHES "-O3")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
endif()
if (ETL_CXX_STANDARD MATCHES "98")
message(STATUS "Compiling for C++98")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 98)
elseif (ETL_CXX_STANDARD MATCHES "03")
message(STATUS "Compiling for C++98")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 98)
elseif (ETL_CXX_STANDARD MATCHES "11")
message(STATUS "Compiling for C++11")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 11)
elseif (ETL_CXX_STANDARD MATCHES "14")
message(STATUS "Compiling for C++14")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 14)
elseif (ETL_CXX_STANDARD MATCHES "17")
message(STATUS "Compiling for C++17")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 17)
else()
message(STATUS "Compiling for C++20")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 20)
endif()
target_include_directories(etl_tests
PUBLIC
${CMAKE_CURRENT_LIST_DIR}
@ -59,6 +79,3 @@ add_test(etl_initializer_list_unit_tests etl_tests)
add_custom_target(test_verbose COMMAND ${CMAKE_CTEST_COMMAND} --verbose)
#RSG
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 17)

745
test/runsanitychecks.sh
View File

@ -1,20 +1,77 @@
#!/bin/sh
clear
echo -e
testname="Test Name Not Set"
FailColour='\033[38;2;255;128;128m'
PassColour='\033[38;2;128;255;128m'
TitleColour='\033[38;2;100;173;254m'
NoColour='\033[0m'
SetCxxStandard()
{
cxx_standard=$1
}
SetTestName()
{
testname=$1
}
PrintHeader()
{
echo "${TitleColour}"
echo "----------------------------------------------------------------------------" | tee -a log.txt
echo " $testname" | tee -a log.txt
echo " Language standard : C++${cxx_standard}" | tee -a log.txt
echo "----------------------------------------------------------------------------" | tee -a log.txt
echo "${NoColour}"
}
PassedCompilation()
{
echo "${PassColour}"
echo "-----------------------------------------------" | tee -a log.txt
echo " Passed Compilation - $testname" | tee -a ../log.txt
echo "-----------------------------------------------" | tee -a log.txt
echo "${NoColour}"
}
FailedCompilation()
{
echo "${FailColour}"
echo "****************************************************************************" | tee -a log.txt
echo "**** Failed Compilation $testname" | tee -a log.txt
echo "****************************************************************************" | tee -a ../log.txt
echo "${NoColour}"
}
ChecksCompleted()
{
echo "${PassColour}"
echo "-----------------------------------------------" | tee -a log.txt
echo " All Checks Completed OK" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
echo "${NoColour}"
}
cd sanity-check || exit 1
echo "" > log.txt
export CMAKE_BUILD_PARALLEL_LEVEL=4
echo ""
echo "Using "${CMAKE_BUILD_PARALLEL_LEVEL}" jobs"
###############################################################################
cd c++03 || exit 1
{ echo ""
echo "Using "${CMAKE_BUILD_PARALLEL_LEVEL}" jobs"
echo "-----------------------------------------------"
echo " C++03"
echo "-----------------------------------------------"
echo "GCC - STL"; } | tee -a ../log.txt
SetCxxStandard "03 (98)"
SetTestName "GCC - STL"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
@ -22,13 +79,14 @@ g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bgcc
if [ $? -eq 0 ]; then
echo "Passed"
PassedCompilation
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
{ echo ""; echo "GCC - No STL"; } | tee -a ../log.txt
SetTestName "GCC - No STL"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
@ -36,13 +94,14 @@ g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bgcc
if [ $? -eq 0 ]; then
echo "Passed"
PassedCompilation
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
##{ echo ""; echo "GCC - No STL - User defined traits"; } | tee -a ../log.txt
##SetTestName "GCC - No STL - User defined traits"
# PrintHeader
#rm -rdf bgcc
#rm -rdf bclang
#cmake -E make_directory bgcc bclang
@ -50,13 +109,14 @@ fi
#CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
#cmake --build bgcc
#if [ $? -eq 0 ]; then
# echo "Passed"
# PassedCompilation
#else
# echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
# FailedCompilation
# exit $?
#fi
{ echo ""; echo "Clang - STL"; } | tee -a ../log.txt
SetTestName "Clang - STL"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
@ -64,13 +124,14 @@ clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bclang
if [ $? -eq 0 ]; then
echo "Passed"
PassedCompilation
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
{ echo ""; echo "Clang - No STL"; } | tee -a ../log.txt
SetTestName "Clang - No STL"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
@ -78,13 +139,14 @@ clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bclang
if [ $? -eq 0 ]; then
echo "Passed"
PassedCompilation
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
##{ echo ""; echo "Clang - No STL - User defined traits"; } | tee -a ../log.txt
#SetTestName "Clang - No STL - User defined traits"
#PrintHeader
#rm -rdf bgcc
#rm -rdf bclang
#cmake -E make_directory bgcc bclang
@ -92,20 +154,19 @@ fi
#CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
#cmake --build bclang
#if [ $? -eq 0 ]; then
# echo "Passed"
# PassedCompilation
#else
# echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
# FailedCompilation
# exit $?
#fi
###############################################################################
cd ../c++11 || exit 1
{ echo ""
echo "-----------------------------------------------"
echo " C++11"
echo "-----------------------------------------------"
echo "GCC - STL"; } | tee -a ../log.txt
SetCxxStandard "11"
SetTestName "GCC - STL"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
@ -113,13 +174,14 @@ g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bgcc
if [ $? -eq 0 ]; then
echo "Passed"
PassedCompilation
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
{ echo ""; echo "GCC - STL - Force C++03"; } | tee -a ../log.txt
SetTestName "GCC - STL - Force C++03"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
@ -127,13 +189,14 @@ g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
cmake --build bgcc
if [ $? -eq 0 ]; then
echo "Passed"
PassedCompilation
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
{ echo ""; echo "GCC - No STL"; } | tee -a ../log.txt
SetTestName "GCC - No STL"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
@ -141,251 +204,14 @@ g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bgcc
if [ $? -eq 0 ]; then
echo "Passed"
PassedCompilation
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
##{ echo ""; echo "GCC - No STL - User defined traits"; } | tee -a ../log.txt
#rm -rdf bgcc
#rm -rdf bclang
#cmake -E make_directory bgcc bclang
#g++ --version | head --lines=1 | tee -a ../log.txt
#CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
#cmake --build bgcc
#if [ $? -eq 0 ]; then
# echo "Passed"
#else
# echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
# exit $?
#fi
{ echo ""; echo "Clang - STL"; } | tee -a ../log.txt
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bclang
if [ $? -eq 0 ]; then
echo "Passed"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
{ echo ""; echo "Clang - STL - Force C++03"; } | tee -a ../log.txt
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
cmake --build bclang
if [ $? -eq 0 ]; then
echo "Passed"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
{ echo ""; echo "Clang - No STL"; } | tee -a ../log.txt
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bclang
if [ $? -eq 0 ]; then
echo "Passed"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
##{ echo ""; echo "Clang - No STL - User defined traits"; } | tee -a ../log.txt
#rm -rdf bgcc
#rm -rdf bclang
#cmake -E make_directory bgcc bclang
#clang++ --version | head --lines=1 | tee -a ../log.txt
#CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
#cmake --build bclang
#if [ $? -eq 0 ]; then
# echo "Passed"
#else
# echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
# exit $?
#fi
###############################################################################
cd ../c++14 || exit 1
{ echo ""
echo "-----------------------------------------------"
echo " C++14"
echo "-----------------------------------------------"
echo "GCC - STL"; } | tee -a ../log.txt
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bgcc
if [ $? -eq 0 ]; then
echo "Passed"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
{ echo ""; echo "GCC - STL - Force C++03"; } | tee -a ../log.txt
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
cmake --build bgcc
if [ $? -eq 0 ]; then
echo "Passed"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
{ echo ""; echo "GCC - No STL"; } | tee -a ../log.txt
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bgcc
if [ $? -eq 0 ]; then
echo "Passed"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
##{ echo ""; echo "GCC - No STL - User defined traits"; } | tee -a ../log.txt
#rm -rdf bgcc
#rm -rdf bclang
#cmake -E make_directory bgcc bclang
#g++ --version | head --lines=1 | tee -a ../log.txt
#CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
#cmake --build bgcc
#if [ $? -eq 0 ]; then
# echo "Passed"
#else
# echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
# exit $?
#fi
{ echo ""; echo "Clang - STL"; } | tee -a ../log.txt
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bclang
if [ $? -eq 0 ]; then
echo "Passed"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
{ echo ""; echo "Clang - STL - Force C++03"; } | tee -a ../log.txt
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
cmake --build bclang
if [ $? -eq 0 ]; then
echo "Passed"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
{ echo ""; echo "Clang - No STL"; } | tee -a ../log.txt
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bclang
if [ $? -eq 0 ]; then
echo "Passed"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
##{ echo ""; echo "Clang - No STL - User defined traits"; } | tee -a ../log.txt
#rm -rdf bgcc
#rm -rdf bclang
#cmake -E make_directory bgcc bclang
#clang++ --version | head --lines=1 | tee -a ../log.txt
#CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
#cmake --build bclang
#if [ $? -eq 0 ]; then
# echo "Passed"
#else
# echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
# exit $?
#fi
###############################################################################
cd ../c++17 || exit 1
{ echo ""
echo "-----------------------------------------------"
echo " C++17 "
echo "-----------------------------------------------"
echo "GCC - STL"; } | tee -a ../log.txt
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bgcc
if [ $? -eq 0 ]; then
echo "Passed"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
{ echo ""; echo "GCC - STL - Force C++03"; } | tee -a ../log.txt
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
cmake --build bgcc
if [ $? -eq 0 ]; then
echo "Passed"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
{ echo ""; echo "GCC - No STL"; } | tee -a ../log.txt
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bgcc
if [ $? -eq 0 ]; then
echo "Passed"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
{ echo ""; echo "GCC - No STL - Force C++03"; } | tee -a ../log.txt
SetTestName "GCC - No STL - Force C++03"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
@ -393,13 +219,14 @@ g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
cmake --build bgcc
if [ $? -eq 0 ]; then
echo "Passed"
PassedCompilation
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
##{ echo ""; echo "GCC - No STL - User defined traits"; } | tee -a ../log.txt
#SetTestName "GCC - No STL - User defined traits"
#PrintHeader
#rm -rdf bgcc
#rm -rdf bclang
#cmake -E make_directory bgcc bclang
@ -407,13 +234,14 @@ fi
#CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
#cmake --build bgcc
#if [ $? -eq 0 ]; then
# echo "Passed"
# PassedCompilation
#else
# echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
# FailedCompilation
# exit $?
#fi
{ echo ""; echo "Clang - STL"; } | tee -a ../log.txt
SetTestName "Clang - STL"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
@ -421,13 +249,14 @@ clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bclang
if [ $? -eq 0 ]; then
echo "Passed"
PassedCompilation
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
{ echo ""; echo "Clang - STL - Force C++03"; } | tee -a ../log.txt
SetTestName "Clang - STL - Force C++03"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
@ -435,13 +264,14 @@ clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
cmake --build bclang
if [ $? -eq 0 ]; then
echo "Passed"
PassedCompilation
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
{ echo ""; echo "Clang - No STL"; } | tee -a ../log.txt
SetTestName "Clang - No STL"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
@ -449,13 +279,29 @@ clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bclang
if [ $? -eq 0 ]; then
echo "Passed"
PassedCompilation
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
##{ echo ""; echo "Clang - No STL - User defined traits"; } | tee -a ../log.txt
SetTestName "Clang - No STL - Force C++03"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
#SetTestName "Clang - No STL - User defined traits"
#PrintHeader
#rm -rdf bgcc
#rm -rdf bclang
#cmake -E make_directory bgcc bclang
@ -463,13 +309,320 @@ fi
#CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
#cmake --build bclang
#if [ $? -eq 0 ]; then
# echo "Passed"
# PassedCompilation
#else
# echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
# FailedCompilation
# exit $?
#fi
{ echo ""
echo "-----------------------------------------------"
echo " All Checks Completed OK"
echo "-----------------------------------------------"; } | tee -a ../log.txt
###############################################################################
cd ../c++14 || exit 1
SetCxxStandard "14"
SetTestName "GCC - STL"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bgcc
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
SetTestName "GCC - STL - Force C++03"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
cmake --build bgcc
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
SetTestName "GCC - No STL"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bgcc
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
SetTestName "GCC - No STL - Force C++03"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
cmake --build bgcc
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
#SetTestName "GCC - No STL - User defined traits"
#PrintHeader
#rm -rdf bgcc
#rm -rdf bclang
#cmake -E make_directory bgcc bclang
#g++ --version | head --lines=1 | tee -a ../log.txt
#CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
#cmake --build bgcc
#if [ $? -eq 0 ]; then
# PassedCompilation
#else
# FailedCompilation
# exit $?
#fi
SetTestName "Clang - STL"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
SetTestName "Clang - STL - Force C++03"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
SetTestName "Clang - No STL"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
SetTestName "Clang - No STL - Force C++03"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
#SetTestName "Clang - No STL - User defined traits"
#PrintHeader
#rm -rdf bgcc
#rm -rdf bclang
#cmake -E make_directory bgcc bclang
#clang++ --version | head --lines=1 | tee -a ../log.txt
#CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
#cmake --build bclang
#if [ $? -eq 0 ]; then
# PassedCompilation
#else
# FailedCompilation
# exit $?
#fi
###############################################################################
cd ../c++17 || exit 1
SetCxxStandard "17"
SetTestName "GCC - STL"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bgcc
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
SetTestName "GCC - STL - Force C++03"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
cmake --build bgcc
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
SetTestName "GCC - No STL"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bgcc
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
SetTestName "GCC - No STL - Force C++03"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
g++ --version | head --lines=1 | tee -a ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
cmake --build bgcc
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
#SetTestName "GCC - No STL - User defined traits"
#PrintHeader
#rm -rdf bgcc
#rm -rdf bclang
#cmake -E make_directory bgcc bclang
#g++ --version | head --lines=1 | tee -a ../log.txt
#CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
#cmake --build bgcc
#if [ $? -eq 0 ]; then
# PassedCompilation
#else
# FailedCompilation
# exit $?
#fi
SetTestName "Clang - STL"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
SetTestName "Clang - STL - Force C++03"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
SetTestName "Clang - No STL"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
SetTestName "Clang - No STL - Force C++03"
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
clang++ --version | head --lines=1 | tee -a ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
#SetTestName "Clang - No STL - User defined traits"
#PrintHeader
#rm -rdf bgcc
#rm -rdf bclang
#cmake -E make_directory bgcc bclang
#clang++ --version | head --lines=1 | tee -a ../log.txt
#CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=ON -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF ..
#cmake --build bclang
#if [ $? -eq 0 ]; then
# PassedCompilation
#else
# FailedCompilation
# exit $?
#fi
ChecksCompleted

348
test/runtests-c++14.sh
View File

@ -1,348 +0,0 @@
#!/bin/sh
clear
mkdir -p build-make || exit 1
cd build-make || exit 1
echo "ETL Tests" > log.txt
opt="-O0"
cxx_standard="14"
#******************************************************************************
# GCC
#******************************************************************************
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - STL" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
rm * -rf
gcc --version | grep gcc | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Compilation >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - STL - Force C++03" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
rm * -rf
gcc --version | grep gcc | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Compilation >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - No STL" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
rm * -rf
gcc --version | grep gcc | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Compilation >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
#******************************************************************************
# CLANG
#******************************************************************************
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - STL" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
rm * -rf
clang --version | grep clang | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Compilation >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - STL - Force C++03" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
rm * -rf
clang --version | grep clang | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Compilation >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - No STL" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
rm * -rf
clang --version | grep clang | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Compilation >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - Initializer list test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../etl_initializer_list/
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
gcc --version | grep gcc | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed initializer_list Compilation >>>>"
else
echo "****************\n**** Failed initializer_list ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - Initializer list test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
rm * -rf
clang --version | grep clang | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed initializer_list Compilation >>>>"
else
echo "****************\n**** Failed initializer_list ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - Error macros 'log_errors' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../../etl_error_handler/log_errors
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
gcc --version | grep gcc | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'log_errors' Compilation >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - Error macros 'exceptions' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../../../etl_error_handler/exceptions
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
gcc --version | grep gcc | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'exceptions' Compilation >>>>"
else
echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - Error macros 'log_errors and exceptions' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../../../etl_error_handler/log_errors_and_exceptions
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
gcc --version | grep gcc | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'log_errors and exceptions' Compilation >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - Error macros 'log_errors' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../../../etl_error_handler/log_errors
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
clang --version | grep clang | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'log_errors' Compilation >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - Error macros 'exceptions' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../../../etl_error_handler/exceptions
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
clang --version | grep clang | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'exceptions' Compilation >>>>"
else
echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - Error macros 'log_errors and exceptions' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../../../etl_error_handler/log_errors_and_exceptions
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
clang --version | grep clang | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'log_errors and exceptions' Compilation >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
cd ../..
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " All Tests Completed OK" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt

441
test/runtests.sh
View File

@ -6,365 +6,462 @@ cd build-make || exit 1
echo "ETL Tests" > log.txt
# Set the optimisation level
if [ "$1" = "1" ]; then
# Set the language standard. Default C++20
if [ "$1" = "11" ]; then
cxx_standard="11"
elif [ "$1" = "14" ]; then
cxx_standard="14"
elif [ "$1" = "17" ]; then
cxx_standard="17"
else
cxx_standard="20"
fi
# Set the optimisation level. Default -O0
if [ "$2" = "1" ]; then
opt="-O1"
elif [ "$1" = "2" ]; then
elif [ "$2" = "2" ]; then
opt="-O2"
elif [ "$1" = "3" ]; then
elif [ "$2" = "3" ]; then
opt="-O3"
else
opt="-O0"
fi
export ASAN_OPTIONS=symbol_line=1
export ASAN_SYMBOLIZER_PATH=/usr/lib/llvm-14/bin//llvm-symbolizer
echo -e
testname="Test Name Not Set"
FailColour='\033[38;2;255;128;128m'
PassColour='\033[38;2;128;255;128m'
TitleColour='\033[38;2;100;173;254m'
NoColour='\033[0m'
SetTestName()
{
testname=$1
}
PrintHeader()
{
echo "${TitleColour}"
echo "----------------------------------------------------------------------------" | tee -a log.txt
echo " $testname" | tee -a log.txt
echo " Language standard : C++${cxx_standard}" | tee -a log.txt
echo " Optimisation : ${opt}" | tee -a log.txt
echo "----------------------------------------------------------------------------" | tee -a log.txt
echo "${NoColour}"
}
PassedCompilation()
{
echo "${PassColour}"
echo "-----------------------------------------------" | tee -a log.txt
echo " Passed Compilation - $testname" | tee -a ../log.txt
echo "-----------------------------------------------" | tee -a log.txt
echo "${NoColour}"
}
PassedTests()
{
echo "${PassColour}"
echo "-----------------------------------------------" | tee -a log.txt
echo " Passed Tests - $testname" | tee -a ../log.txt
echo "-----------------------------------------------" | tee -a log.txt
echo "${NoColour}"
}
FailedCompilation()
{
echo "${FailColour}"
echo "****************************************************************************" | tee -a log.txt
echo "**** Failed Compilation $testname" | tee -a log.txt
echo "****************************************************************************" | tee -a ../log.txt
echo "${NoColour}"
}
FailedTests()
{
echo "${FailColour}"
echo "****************************************************************************" | tee -a log.txt
echo "**** Failed Tests $testname" | tee -a log.txt
echo "****************************************************************************" | tee -a ../log.txt
echo "${NoColour}"
}
TestsCompleted()
{
echo "${PassColour}"
echo "-----------------------------------------------" | tee -a log.txt
echo " All Tests Completed OK" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
echo "${NoColour}"
}
#******************************************************************************
# GCC
#******************************************************************************
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - STL" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
SetTestName "GCC - STL"
PrintHeader
rm * -rf
gcc --version | grep gcc | tee -a log.txt
echo "Using optimisation" $opt | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt ..
cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Compilation >>>>"
PassedCompilation
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
PassedTests
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedTests
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - STL - Force C++03" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
#******************************************************************************
SetTestName "GCC - STL - Force C++03"
PrintHeader
rm * -rf
gcc --version | grep gcc | tee -a log.txt
echo "Using optimisation" $opt | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt ..
cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Compilation >>>>"
PassedCompilation
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
PassedTests
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedTests
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - No STL" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
#******************************************************************************
SetTestName "GCC - No STL"
PrintHeader
rm * -rf
gcc --version | grep gcc | tee -a log.txt
echo "Using optimisation" $opt | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt ..
cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Compilation >>>>"
PassedCompilation
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
PassedTests
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedTests
exit $?
fi
#******************************************************************************
SetTestName "GCC - No STL - Force C++03"
PrintHeader
rm * -rf
gcc --version | grep gcc | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
PassedTests
else
FailedTests
exit $?
fi
#******************************************************************************
# CLANG
#******************************************************************************
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - STL" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
SetTestName "Clang - STL"
PrintHeader
rm * -rf
clang --version | grep clang | tee -a log.txt
echo "Using optimisation" $opt | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt ..
cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Compilation >>>>"
PassedCompilation
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
PassedTests
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - STL - Force C++03" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
rm * -rf
clang --version | grep clang | tee -a log.txt
echo "Using optimisation" $opt | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Compilation >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - No STL" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
rm * -rf
clang --version | grep clang | tee -a log.txt
echo "Using optimisation" $opt | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Compilation >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedTests
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - Initializer list test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
#******************************************************************************
SetTestName "Clang - STL - Force C++03"
PrintHeader
rm * -rf
clang --version | grep clang | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
PassedTests
else
FailedTests
exit $?
fi
#******************************************************************************
SetTestName "Clang - No STL"
PrintHeader
rm * -rf
clang --version | grep clang | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
PassedTests
else
FailedTests
exit $?
fi
#******************************************************************************
SetTestName "Clang - No STL - Force C++03"
PrintHeader
rm * -rf
clang --version | grep clang | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
PassedTests
else
FailedTests
exit $?
fi
#******************************************************************************
SetTestName "GCC - Initializer list test"
PrintHeader
cd ../etl_initializer_list/
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
gcc --version | grep gcc | tee -a log.txt
echo "Using optimisation" $opt | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt ..
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed initializer_list Compilation >>>>"
PassedCompilation
else
echo "****************\n**** Failed initializer_list ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
PassedTests
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedTests
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - Initializer list test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
#******************************************************************************
SetTestName "Clang - Initializer list test"
PrintHeader
rm * -rf
clang --version | grep clang | tee -a log.txt
echo "Using optimisation" $opt | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt ..
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed initializer_list Compilation >>>>"
PassedCompilation
else
echo "****************\n**** Failed initializer_list ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
PassedTests
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
FailedTests
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - Error macros 'log_errors' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
#******************************************************************************
SetTestName "GCC - Error macros 'log_errors' test"
PrintHeader
cd ../../etl_error_handler/log_errors
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
gcc --version | grep gcc | tee -a log.txt
echo "Using optimisation" $opt | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt ..
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'log_errors' Compilation >>>>"
PassedCompilation
else
echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
PassedTests
else
echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
FailedTests
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - Error macros 'exceptions' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
#******************************************************************************
SetTestName "GCC - Error macros 'exceptions' test"
PrintHeader
cd ../../../etl_error_handler/exceptions
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
gcc --version | grep gcc | tee -a log.txt
echo "Using optimisation" $opt | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt ..
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'exceptions' Compilation >>>>"
PassedCompilation
else
echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
PassedTests
else
echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
FailedTests
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - Error macros 'log_errors and exceptions' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
#******************************************************************************
SetTestName "GCC - Error macros 'log_errors and exceptions' test"
PrintHeader
cd ../../../etl_error_handler/log_errors_and_exceptions
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
gcc --version | grep gcc | tee -a log.txt
echo "Using optimisation" $opt | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt ..
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'log_errors and exceptions' Compilation >>>>"
PassedCompilation
else
echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
PassedTests
else
echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
FailedTests
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - Error macros 'log_errors' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
#******************************************************************************
SetTestName "Clang - Error macros 'log_errors' test"
PrintHeader
cd ../../../etl_error_handler/log_errors
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
clang --version | grep clang | tee -a log.txt
echo "Using optimisation" $opt | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt ..
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'log_errors' Compilation >>>>"
PassedCompilation
else
echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
PassedTests
else
echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
FailedTests
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - Error macros 'exceptions' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
#******************************************************************************
SetTestName "Clang - Error macros 'exceptions' test"
PrintHeader
cd ../../../etl_error_handler/exceptions
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
clang --version | grep clang | tee -a log.txt
echo "Using optimisation" $opt | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt ..
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'exceptions' Compilation >>>>"
PassedCompilation
else
echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
PassedTests
else
echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
FailedTests
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - Error macros 'log_errors and exceptions' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
#******************************************************************************
SetTestName "Clang - Error macros 'log_errors and exceptions' test"
PrintHeader
cd ../../../etl_error_handler/log_errors_and_exceptions
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
clang --version | grep clang | tee -a log.txt
echo "Using optimisation" $opt | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt ..
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'log_errors and exceptions' Compilation >>>>"
PassedCompilation
else
echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
FailedCompilation
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
PassedTests
else
echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
FailedTests
exit $?
fi
cd ../..
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " All Tests Completed OK" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
TestsCompleted

4
test/test_algorithm.cpp
View File

@ -1601,7 +1601,7 @@ namespace
etl::transform_s(std::begin(input),
std::end(input),
std::begin(output),
std::begin(output) + (ETL_OR_STD::size(output) / 2),
std::begin(output) + (ETL_OR_STD17::size(output) / 2),
std::bind(std::multiplies<int>(), std::placeholders::_1, 2));
bool is_same = std::equal(std::begin(output), std::end(output), std::begin(compare));
@ -1610,7 +1610,7 @@ namespace
std::fill(std::begin(output), std::end(output), 0);
etl::transform_s(std::begin(input),
std::begin(input) + (ETL_OR_STD::size(input) / 2),
std::begin(input) + (ETL_OR_STD17::size(input) / 2),
std::begin(output),
std::end(output),
std::bind(std::multiplies<int>(), std::placeholders::_1, 2));

4
test/test_array_view.cpp
View File

@ -722,8 +722,8 @@ namespace
View view(etldata.begin(), etldata.end());
CView cview(etldata.begin(), etldata.end());
size_t hashdata = etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&etldata[0]),
reinterpret_cast<const uint8_t*>(&etldata[etldata.size()]));
size_t hashdata = etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(etldata.data()),
reinterpret_cast<const uint8_t*>(etldata.data() + etldata.size()));
size_t hashview = etl::hash<View>()(view);
size_t hashcview = etl::hash<CView>()(cview);

2
test/test_array_wrapper.cpp
View File

@ -563,10 +563,8 @@ namespace
Data5 aw5;
size_t hash = etl::hash<Data5>()(aw5);
size_t compare_hash = etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(data5), reinterpret_cast<const uint8_t*>(data5 + 5U));
CHECK_EQUAL(compare_hash, hash);
}
};

10
test/test_byte_stream.cpp
View File

@ -109,7 +109,7 @@ namespace
{
char storage[7];
etl::byte_stream_writer writer(storage, ETL_OR_STD::size(storage), etl::endian::big);
etl::byte_stream_writer writer(storage, ETL_OR_STD17::size(storage), etl::endian::big);
etl::byte_stream_reader reader(storage, writer.size_bytes(), etl::endian::big); // Capacity is zero.
CHECK(writer.empty());
@ -120,7 +120,7 @@ namespace
CHECK_EQUAL(0U, writer.size_bytes());
CHECK_EQUAL(0U, reader.size_bytes());
CHECK_EQUAL(ETL_OR_STD::size(storage), writer.capacity());
CHECK_EQUAL(ETL_OR_STD17::size(storage), writer.capacity());
CHECK_EQUAL(0U, reader.available<int8_t>());
@ -136,9 +136,9 @@ namespace
{
char storage[8];
etl::byte_stream_writer writer(storage, ETL_OR_STD::size(storage), etl::endian::big);
etl::byte_stream_writer writer(storage, ETL_OR_STD17::size(storage), etl::endian::big);
etl::span<char> storage_span(storage, storage + ETL_OR_STD::size(storage));
etl::span<char> storage_span(storage, storage + ETL_OR_STD17::size(storage));
etl::span<char> writer_span = writer.data();
CHECK(writer_span.begin() == storage_span.begin());
CHECK(writer_span.end() == storage_span.end());
@ -150,7 +150,7 @@ namespace
etl::span<char> free_span = writer.free_data();
CHECK_EQUAL(sizeof(uint8_t) + sizeof(uint16_t), (std::distance(used_span.begin(), used_span.end())));
CHECK_EQUAL(ETL_OR_STD::size(storage) - sizeof(uint8_t) - sizeof(uint16_t), (std::distance(free_span.begin(), free_span.end())));
CHECK_EQUAL(ETL_OR_STD17::size(storage) - sizeof(uint8_t) - sizeof(uint16_t), (std::distance(free_span.begin(), free_span.end())));
CHECK(writer.write(uint32_t(0x12345678U))); // 4 more written.
CHECK_FALSE(writer.write(uint32_t(0x12345678U))); // Can't write 4 more.

80
test/test_char_traits.cpp
View File

@ -74,7 +74,7 @@ namespace
char_type r = 'A';
char_type c = 'B';
char_type src[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
char_type dst[ETL_OR_STD::size(src)];
char_type dst[ETL_OR_STD17::size(src)];
char_type filled[] = { 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };
const char_type* p_src;
char_type* p_dst;
@ -96,18 +96,18 @@ namespace
CHECK_EQUAL(-1, char_traits::compare("ABCDEE", "ABCDEF", 6U));
CHECK_EQUAL(1, char_traits::compare("ABCDEF", "ABCDEE", 6U));
p_dst = char_traits::assign(dst, ETL_OR_STD::size(dst), 9);
CHECK_ARRAY_EQUAL(filled, p_dst, ETL_OR_STD::size(filled));
p_dst = char_traits::assign(dst, ETL_OR_STD17::size(dst), 9);
CHECK_ARRAY_EQUAL(filled, p_dst, ETL_OR_STD17::size(filled));
std::fill_n(dst, ETL_OR_STD::size(dst), 0);
p_dst = char_traits::copy(dst, src, ETL_OR_STD::size(src));
CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD::size(src));
std::fill_n(dst, ETL_OR_STD17::size(dst), 0);
p_dst = char_traits::copy(dst, src, ETL_OR_STD17::size(src));
CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD17::size(src));
std::fill_n(dst, ETL_OR_STD::size(dst), 0);
p_dst = char_traits::move(dst, src, ETL_OR_STD::size(src));
CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD::size(src));
std::fill_n(dst, ETL_OR_STD17::size(dst), 0);
p_dst = char_traits::move(dst, src, ETL_OR_STD17::size(src));
CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD17::size(src));
p_src = char_traits::find(src, ETL_OR_STD::size(src), 4);
p_src = char_traits::find(src, ETL_OR_STD17::size(src), 4);
CHECK_EQUAL(src[4], *p_src);
CHECK_EQUAL(127, char_traits::to_char_type(int_type(127)));
@ -130,7 +130,7 @@ namespace
char_type r = L'A';
char_type c = L'B';
char_type src[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
char_type dst[ETL_OR_STD::size(src)];
char_type dst[ETL_OR_STD17::size(src)];
char_type filled[] = { 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };
const char_type* p_src;
char_type* p_dst;
@ -152,18 +152,18 @@ namespace
CHECK_EQUAL(-1, char_traits::compare(L"ABCDEE", L"ABCDEF", 6U));
CHECK_EQUAL(1, char_traits::compare(L"ABCDEF", L"ABCDEE", 6U));
p_dst = char_traits::assign(dst, ETL_OR_STD::size(dst), 9);
CHECK_ARRAY_EQUAL(filled, p_dst, ETL_OR_STD::size(filled));
p_dst = char_traits::assign(dst, ETL_OR_STD17::size(dst), 9);
CHECK_ARRAY_EQUAL(filled, p_dst, ETL_OR_STD17::size(filled));
std::fill_n(dst, ETL_OR_STD::size(dst), 0);
p_dst = char_traits::copy(dst, src, ETL_OR_STD::size(src));
CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD::size(src));
std::fill_n(dst, ETL_OR_STD17::size(dst), 0);
p_dst = char_traits::copy(dst, src, ETL_OR_STD17::size(src));
CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD17::size(src));
std::fill_n(dst, ETL_OR_STD::size(dst), 0);
p_dst = char_traits::move(dst, src, ETL_OR_STD::size(src));
CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD::size(src));
std::fill_n(dst, ETL_OR_STD17::size(dst), 0);
p_dst = char_traits::move(dst, src, ETL_OR_STD17::size(src));
CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD17::size(src));
p_src = char_traits::find(src, ETL_OR_STD::size(src), 4);
p_src = char_traits::find(src, ETL_OR_STD17::size(src), 4);
CHECK_EQUAL(src[4], *p_src);
CHECK_TRUE(127 == char_traits::to_char_type(int_type(127)));
@ -186,7 +186,7 @@ namespace
char_type r = u'A';
char_type c = u'B';
char_type src[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
char_type dst[ETL_OR_STD::size(src)];
char_type dst[ETL_OR_STD17::size(src)];
char_type filled[] = { 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };
const char_type* p_src;
char_type* p_dst;
@ -208,18 +208,18 @@ namespace
CHECK_EQUAL(-1, char_traits::compare(u"ABCDEE", u"ABCDEF", 6U));
CHECK_EQUAL(1, char_traits::compare(u"ABCDEF", u"ABCDEE", 6U));
p_dst = char_traits::assign(dst, ETL_OR_STD::size(dst), 9);
CHECK_ARRAY_EQUAL(filled, p_dst, ETL_OR_STD::size(filled));
p_dst = char_traits::assign(dst, ETL_OR_STD17::size(dst), 9);
CHECK_ARRAY_EQUAL(filled, p_dst, ETL_OR_STD17::size(filled));
std::fill_n(dst, ETL_OR_STD::size(dst), 0);
p_dst = char_traits::copy(dst, src, ETL_OR_STD::size(src));
CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD::size(src));
std::fill_n(dst, ETL_OR_STD17::size(dst), 0);
p_dst = char_traits::copy(dst, src, ETL_OR_STD17::size(src));
CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD17::size(src));
std::fill_n(dst, ETL_OR_STD::size(dst), 0);
p_dst = char_traits::move(dst, src, ETL_OR_STD::size(src));
CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD::size(src));
std::fill_n(dst, ETL_OR_STD17::size(dst), 0);
p_dst = char_traits::move(dst, src, ETL_OR_STD17::size(src));
CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD17::size(src));
p_src = char_traits::find(src, ETL_OR_STD::size(src), 4);
p_src = char_traits::find(src, ETL_OR_STD17::size(src), 4);
CHECK_EQUAL(src[4], *p_src);
CHECK_EQUAL(127, char_type(127));
@ -241,7 +241,7 @@ namespace
char_type r = U'A';
char_type c = U'B';
char_type src[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
char_type dst[ETL_OR_STD::size(src)];
char_type dst[ETL_OR_STD17::size(src)];
char_type filled[] = { 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };
const char_type* p_src;
char_type* p_dst;
@ -263,18 +263,18 @@ namespace
CHECK_EQUAL(-1, char_traits::compare(U"ABCDEE", U"ABCDEF", 6U));
CHECK_EQUAL(1, char_traits::compare(U"ABCDEF", U"ABCDEE", 6U));
p_dst = char_traits::assign(dst, ETL_OR_STD::size(dst), 9);
CHECK_ARRAY_EQUAL(filled, p_dst, ETL_OR_STD::size(filled));
p_dst = char_traits::assign(dst, ETL_OR_STD17::size(dst), 9);
CHECK_ARRAY_EQUAL(filled, p_dst, ETL_OR_STD17::size(filled));
std::fill_n(dst, ETL_OR_STD::size(dst), 0);
p_dst = char_traits::copy(dst, src, ETL_OR_STD::size(src));
CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD::size(src));
std::fill_n(dst, ETL_OR_STD17::size(dst), 0);
p_dst = char_traits::copy(dst, src, ETL_OR_STD17::size(src));
CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD17::size(src));
std::fill_n(dst, ETL_OR_STD::size(dst), 0);
p_dst = char_traits::move(dst, src, ETL_OR_STD::size(src));
CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD::size(src));
std::fill_n(dst, ETL_OR_STD17::size(dst), 0);
p_dst = char_traits::move(dst, src, ETL_OR_STD17::size(src));
CHECK_ARRAY_EQUAL(src, p_dst, ETL_OR_STD17::size(src));
p_src = char_traits::find(src, ETL_OR_STD::size(src), 4);
p_src = char_traits::find(src, ETL_OR_STD17::size(src), 4);
CHECK_EQUAL(src[4], *p_src);
CHECK_EQUAL(127, char_traits::to_int_type(char_type(127)));

12
test/test_circular_iterator.cpp
View File

@ -63,8 +63,8 @@ namespace
CHECK(std::begin(data) == ci.begin());
CHECK(std::end(data) == ci.end());
CHECK(std::begin(data) == ci.current());
CHECK_EQUAL(ETL_OR_STD::size(data), size_t(std::distance(ci.begin(), ci.end())));
CHECK_EQUAL(ETL_OR_STD::size(data), ci.size());
CHECK_EQUAL(ETL_OR_STD17::size(data), size_t(std::distance(ci.begin(), ci.end())));
CHECK_EQUAL(ETL_OR_STD17::size(data), ci.size());
}
//*************************************************************************
@ -80,8 +80,8 @@ namespace
CHECK(std::begin(data) == ci.begin());
CHECK(std::end(data) == ci.end());
CHECK(start == ci.current());
CHECK_EQUAL(ETL_OR_STD::size(data), size_t(std::distance(ci.begin(), ci.end())));
CHECK_EQUAL(ETL_OR_STD::size(data), ci.size());
CHECK_EQUAL(ETL_OR_STD17::size(data), size_t(std::distance(ci.begin(), ci.end())));
CHECK_EQUAL(ETL_OR_STD17::size(data), ci.size());
}
//*************************************************************************
@ -645,7 +645,7 @@ namespace
for (int i = 0; i < 20; i += step)
{
CHECK_EQUAL(expected[i % ETL_OR_STD::size(data)], *ci);
CHECK_EQUAL(expected[i % ETL_OR_STD17::size(data)], *ci);
ci -= step;
}
}
@ -663,7 +663,7 @@ namespace
for (int i = 0; i < 20; i += step)
{
CHECK_EQUAL(expected[i % ETL_OR_STD::size(data)], *ci);
CHECK_EQUAL(expected[i % ETL_OR_STD17::size(data)], *ci);
ci = ci - step;
}
}

8
test/test_container.cpp
View File

@ -74,7 +74,7 @@ namespace
CHECK(&data[0] == iBegin);
int* iEnd = etl::end(data);
CHECK(&data[SIZE] == iEnd);
CHECK((data + SIZE) == iEnd);
}
//*************************************************************************
@ -87,7 +87,7 @@ namespace
CHECK(&data[0] == iBegin);
const int* const iEnd = etl::end(data);
CHECK(&data[SIZE] == iEnd);
CHECK((data + SIZE) == iEnd);
}
@ -129,7 +129,7 @@ namespace
const size_t SIZE = 10UL;
std::list<int> data(SIZE);
size_t runtime_size = ETL_OR_STD::size(data);
size_t runtime_size = ETL_OR_STD17::size(data);
CHECK_EQUAL(SIZE, runtime_size);
}
@ -139,7 +139,7 @@ namespace
const size_t SIZE = 10UL;
int data[SIZE];
size_t runtime_size = ETL_OR_STD::size(data);
size_t runtime_size = ETL_OR_STD17::size(data);
CHECK_EQUAL(SIZE, runtime_size);
size_t compiletime_size = sizeof(etl::array_size(data));

6
test/test_fsm.cpp
View File

@ -341,7 +341,7 @@ namespace
CHECK(motorControl.is_producer());
CHECK(motorControl.is_consumer());
motorControl.Initialise(stateList, ETL_OR_STD::size(stateList));
motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList));
motorControl.reset();
motorControl.ClearStatistics();
@ -480,7 +480,7 @@ namespace
{
etl::null_message_router nmr;
motorControl.Initialise(stateList, ETL_OR_STD::size(stateList));
motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList));
motorControl.reset();
motorControl.ClearStatistics();
@ -529,7 +529,7 @@ namespace
{
etl::null_message_router nmr;
motorControl.Initialise(stateList, ETL_OR_STD::size(stateList));
motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList));
motorControl.reset();
motorControl.ClearStatistics();

16
test/test_hfsm.cpp
View File

@ -474,9 +474,9 @@ namespace
CHECK(motorControl.is_producer());
CHECK(motorControl.is_consumer());
running.set_child_states(childStates, ETL_OR_STD::size(childStates));
running.set_child_states(childStates, ETL_OR_STD17::size(childStates));
motorControl.Initialise(stateList, ETL_OR_STD::size(stateList));
motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList));
motorControl.reset();
motorControl.ClearStatistics();
@ -647,7 +647,7 @@ namespace
{
etl::null_message_router nmr;
motorControl.Initialise(stateList, ETL_OR_STD::size(stateList));
motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList));
motorControl.reset();
motorControl.ClearStatistics();
@ -700,7 +700,7 @@ namespace
{
etl::null_message_router nmr;
motorControl.Initialise(stateList, ETL_OR_STD::size(stateList));
motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList));
motorControl.reset();
motorControl.ClearStatistics();
@ -754,7 +754,7 @@ namespace
{
etl::null_message_router nmr;
motorControl.Initialise(stateList, ETL_OR_STD::size(stateList));
motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList));
motorControl.reset();
motorControl.ClearStatistics();
@ -809,7 +809,7 @@ namespace
{
etl::null_message_router nmr;
motorControl.Initialise(stateList, ETL_OR_STD::size(stateList));
motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList));
motorControl.reset();
motorControl.ClearStatistics();
@ -902,7 +902,7 @@ namespace
{
MotorControl mc;
motorControl.Initialise(stateList, ETL_OR_STD::size(stateList));
motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList));
motorControl.reset();
motorControl.ClearStatistics();
@ -941,7 +941,7 @@ namespace
{
MotorControl mc;
motorControl.Initialise(stateList, ETL_OR_STD::size(stateList));
motorControl.Initialise(stateList, ETL_OR_STD17::size(stateList));
motorControl.reset();
motorControl.ClearStatistics();

2
test/test_integral_limits.cpp
View File

@ -41,7 +41,7 @@ namespace
//*************************************************************************
TEST(test_min)
{
CHECK_EQUAL(std::numeric_limits<char>::min(), (char)etl::integral_limits<char>::min);
CHECK_EQUAL(std::numeric_limits<char>::min(), etl::integral_limits<char>::min);
CHECK_EQUAL(std::numeric_limits<signed char>::min(), (signed char)etl::integral_limits<signed char>::min);
CHECK_EQUAL(std::numeric_limits<unsigned char>::min(), (unsigned char)etl::integral_limits<unsigned char>::min);
CHECK_EQUAL(std::numeric_limits<short>::min(), (short)etl::integral_limits<short>::min);

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