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

Merge branch 'feature/variadic-variant' into development

Browse Source 
# Conflicts:
#	.gitignore
#	arduino/examples/Vector_Examples/Example_Vector_1_simple_use/Example_Vector_1_simple_use.ino
#	include/etl/version.h
#	library.json
#	library.properties
#	meson.build
#	support/Release notes.txt
#	test/vs2019/etl.vcxproj.filters
This commit is contained in:
John Wellbelove 2021-07-17 23:51:16 +01:00
commit e9a9e8d1af
41 changed files with 12584 additions and 1036 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -315,3 +315,4 @@ test/sanity-check/c++17/Makefile
test/vs2019/Debug LLVM
test/vs2019/DebugLLVMNoSTL
test/vs2019/DebugNoSTL
test/vs2022/Debug LLVM

4
include/etl/circular_buffer.h
View File

@ -41,6 +41,10 @@ SOFTWARE.
#include "iterator.h"
#include "static_assert.h"
#if ETL_CPP11_SUPPORTED && ETL_NOT_USING_STLPORT && ETL_USING_STL
#include <initializer_list>
#endif
namespace etl
{
//***************************************************************************

6
include/etl/delegate.h
View File

@ -107,7 +107,7 @@ namespace etl
//*************************************************************************
// Constructor from lambda or functor.
//*************************************************************************
template <typename TLambda, typename = typename etl::enable_if<etl::is_class<TLambda>::value, void>::type>
template <typename TLambda, typename = etl::enable_if_t<etl::is_class<TLambda>::value, void>>
delegate(const TLambda& instance)
{
assign((void*)(&instance), lambda_stub<TLambda>);
@ -125,7 +125,7 @@ namespace etl
//*************************************************************************
/// Create from Lambda or Functor.
//*************************************************************************
template <typename TLambda, typename = typename etl::enable_if<etl::is_class<TLambda>::value, void>::type>
template <typename TLambda, typename = etl::enable_if_t<etl::is_class<TLambda>::value, void>>
constexpr static delegate create(const TLambda& instance)
{
return delegate((void*)(&instance), lambda_stub<TLambda>);
@ -210,7 +210,7 @@ namespace etl
//*************************************************************************
/// Create from Lambda or Functor.
//*************************************************************************
template <typename TLambda, typename = typename etl::enable_if<etl::is_class<TLambda>::value, void>::type>
template <typename TLambda, typename = etl::enable_if_t<etl::is_class<TLambda>::value, void>>
delegate& operator =(const TLambda& instance)
{
assign((void*)(&instance), lambda_stub<TLambda>);

78
include/etl/experimental/mem_cast.h Normal file
View File

@ -0,0 +1,78 @@
#pragma once
template <size_t Size_>
class uni_type
{
public:
static constexpr size_t Size = Size_;
//***********************************
template <typename T>
T& get()
{
return *reinterpret_cast<T*>(buffer);
}
//***********************************
template <typename T>
const T& get() const
{
return *reinterpret_cast<T*>(buffer);
}
template <typename T>
operator T()
{
return *reinterpret_cast<T*>(buffer);
}
//***********************************
constexpr size_t size() const
{
return Size;
}
private:
char buffer[Size]
};
template <size_t Size_>
class uni_type_ptr
{
public:
static constexpr size_t Size = Size_;
//***********************************
template <typename T>
T& get()
{
return *reinterpret_cast<T*>(pbuffer);
}
//***********************************
template <typename T>
const T& get() const
{
return *reinterpret_cast<T*>(pbuffer);
}
template <typename T>
operator T()
{
return *reinterpret_cast<T*>(pbuffer);
}
//***********************************
constexpr size_t size() const
{
return Size;
}
private:
char* pbuffer;
};

1
include/etl/functional.h
View File

@ -232,7 +232,6 @@ namespace etl
}
//***************************************************************************
template <typename TFunction >
class binder2nd : public etl::unary_function<typename TFunction::first_argument_type, typename TFunction::result_type>
{

8
include/etl/generators/largest_generator.h
View File

@ -395,6 +395,14 @@ namespace etl
using largest_t = typename largest<T...>::type;
#endif
#if ETL_CPP17_SUPPORTED
template <typename... T>
inline constexpr size_t largest_size_v = largest<T...>::size;
template <typename... T>
inline constexpr size_t largest_alignment_v = largest<T...>::alignment;
#endif
#else
/*[[[cog
import cog

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

@ -135,6 +135,9 @@ namespace etl
/// remove_reference
template <typename T> struct remove_reference { typedef T type; };
template <typename T> struct remove_reference<T&> { typedef T type; };
#if ETL_CPP11_SUPPORTED
template <typename T> struct remove_reference<T&&> { typedef T type; };
#endif
#if ETL_CPP11_SUPPORTED
template <typename T>
@ -504,6 +507,11 @@ namespace etl
template <bool B, typename T, typename F> struct conditional { typedef T type; };
template <typename T, typename F> struct conditional<false, T, F> { typedef F type; };
#if ETL_CPP11_SUPPORTED
template <bool B, typename T, typename F>
using conditional_t = typename conditional<B, T, F>::type;
#endif
//***************************************************************************
/// make_signed
template <typename T> struct make_signed { typedef T type; };
@ -781,6 +789,7 @@ namespace etl
/// Specialisation of 'alignment_of' for 'void'.
///\ingroup type_traits
template <> struct alignment_of<void> : integral_constant <size_t, 0> {};
template <> struct alignment_of<const void> : integral_constant <size_t, 0> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
@ -1222,6 +1231,11 @@ namespace etl
template <bool B, typename T, typename F> struct conditional { typedef T type; };
template <typename T, typename F> struct conditional<false, T, F> { typedef F type; };
#if ETL_CPP11_SUPPORTED
template <bool B, typename T, typename F>
using conditional_t = typename conditional<B, T, F>::type;
#endif
//***************************************************************************
/// make_signed
///\ingroup type_traits
@ -1617,6 +1631,186 @@ namespace etl
#if ETL_CPP17_SUPPORTED
template <typename T, typename T1, typename... TRest>
inline constexpr bool are_all_same_v = are_all_same<T, T1, TRest...>::value;
#endif
//***************************************************************************
/// conjunction
#if ETL_CPP11_SUPPORTED
template <typename...>
struct conjunction : public etl::true_type
{
};
template <typename T1, typename... Tn>
struct conjunction<T1, Tn...> : public etl::conditional_t<bool(T1::value), etl::conjunction<Tn...>, T1>
{
};
template <typename T>
struct conjunction<T> : public T
{
};
#endif
#if ETL_CPP17_SUPPORTED
template <typename... T>
inline constexpr bool conjunction_v = conjunction<T...>::value;
#endif
//***************************************************************************
/// disjunction
#if ETL_CPP11_SUPPORTED
template <typename...>
struct disjunction : public etl::false_type
{
};
template <typename T1, typename... Tn>
struct disjunction<T1, Tn...> : public etl::conditional_t<bool(T1::value), T1, disjunction<Tn...>>
{
};
template <typename T1> struct disjunction<T1> : public T1
{
};
#endif
#if ETL_CPP17_SUPPORTED
template <typename... T>
inline constexpr bool disjunction_v = etl::disjunction<T...>::value;
#endif
//***************************************************************************
#if ETL_CPP11_SUPPORTED && ETL_USING_STL && !defined(ETL_USE_TYPE_TRAITS_BUILTINS) && ((!defined(ARDUINO) && ETL_NOT_USING_STLPORT) || defined(ETL_GCC_V5_TYPE_TRAITS_SUPPORTED))
//*********************************************
// Use the STL's definitions.
//*********************************************
template<typename T1, typename T2>
struct is_assignable : public std::is_assignable<T1, T2>
{
};
template <typename T1, typename T2>
struct is_lvalue_assignable : public etl::is_assignable<typename etl::add_lvalue_reference<T1>::type,
typename etl::add_lvalue_reference<typename etl::add_const<T2>::type>::type>
{
};
template<typename T, typename... TArgs>
struct is_constructible : public std::is_constructible<T, TArgs...>
{
};
template <typename T>
struct is_copy_constructible : public std::is_copy_constructible<T>
{
};
template <typename T>
struct is_move_constructible : public std::is_move_constructible<T>
{
};
//#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
// template<typename T, typename... TArgs>
// struct is_trivially_constructible : public std::is_trivially_constructible<T, TArgs...>
// {
// };
//#endif
#elif defined(ETL_USE_TYPE_TRAITS_BUILTINS)
//*********************************************
// Use the compiler's builtins.
//*********************************************
template<typename T1, typename T2>
struct is_assignable : public bool_constant<__is_assignable(T1, T2)>
{
};
template <typename T1, typename T2>
struct is_lvalue_assignable : public etl::is_assignable<typename etl::add_lvalue_reference<T1>::type,
typename etl::add_lvalue_reference<typename etl::add_const<T2>::type>::type>
{
};
template<typename T, typename... TArgs>
struct is_constructible : public bool_constant<__is_constructible(T, TArgs...)>
{
};
template <typename T>
struct is_copy_constructible : public etl::is_constructible<T, etl::add_lvalue_reference_t<const T>>
{
};
template <typename T>
struct is_move_constructible : public etl::is_constructible<T, T>
{
};
//template<typename T, typename... TArgs>
//struct is_trivially_constructible : public bool_constant<etl::is_constructible<T, Args...>::value&& __is_trivially_constructible(T, TArgs...)>
//{
//};
#else
//*********************************************
// Force the user to provide specialisations.
//*********************************************
template<typename T, typename... TArgs>
struct is_assignable : public etl::bool_constant<true>
{
};
template <typename T1, typename T2>
struct is_lvalue_assignable : public etl::bool_constant<true>
{
};
template<typename T, typename... TArgs>
struct is_constructible : public etl::bool_constant<true>
{
};
template <typename T>
struct is_copy_constructible : public etl::bool_constant<etl::is_pod<T>::value>
{
};
template <typename T>
struct is_move_constructible : public etl::bool_constant<etl::is_pod<T>::value>
{
};
//template<typename T, typename... TArgs>
//struct is_trivially_constructible : public etl::bool_constant<etl::is_pod<T>::value>
//{
//};
#endif
#if ETL_CPP17_SUPPORTED
template<typename T1, typename T2>
inline constexpr size_t is_assignable_v = etl::is_assignable<T1, T2>::value;
template<typename T1, typename T2>
inline constexpr size_t is_lvalue_assignable_v = etl::is_lvalue_assignable<T1, T2>::value;
template<typename T, typename... TArgs>
inline constexpr size_t is_constructible_v = etl::is_constructible<T, TArgs...>::value;
template<typename T>
inline constexpr size_t is_copy_constructible_v = etl::is_copy_constructible<T>::value;
template<typename T>
inline constexpr size_t is_move_constructible_v = etl::is_move_constructible<T>::value;
//template<typename T, typename... TArgs>
//inline constexpr size_t is_trivially_constructible_v = etl::is_trivially_constructible<T, TArgs...>::value;
#endif
}

94
include/etl/overload.h Normal file
View File

@ -0,0 +1,94 @@
///\file
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2021 jwellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#ifndef ETL_OVERLOAD_INCLUDED
#define ETL_OVERLOAD_INCLUDED
#include "platform.h"
#include "utility.h"
#include "type_traits.h"
namespace etl
{
#if ETL_CPP14_SUPPORTED
#if ETL_CPP17_SUPPORTED && !defined(ETL_OVERLOAD_FORCE_CPP14)
//*************************************************************************
/// Variadic template definition of overload for C++17 and above.
//*************************************************************************
template<typename... TOverloads>
struct overload : TOverloads...
{
using TOverloads::operator()...;
};
//*************************************************************************
/// Make an overload.
//*************************************************************************
template <typename... TOverloads>
constexpr auto make_overload(TOverloads&&... overloads)
{
return overload<TOverloads...>{ etl::forward<TOverloads>(overloads)... };
}
//*************************************************************************
/// Template deduction guide.
//*************************************************************************
template<typename... TOverloads> overload(TOverloads...)->overload<TOverloads...>;
#else
template <typename TFirst, typename... TOthers>
struct overload : TFirst, overload<TOthers...>
{
using TFirst::operator();
using overload<TOthers...>::operator();
};
template <typename TFirst>
struct overload<TFirst> : TFirst
{
using TFirst::operator();
};
//*************************************************************************
/// Make an overload.
//*************************************************************************
template <typename... TOthers>
constexpr auto make_overload(TOthers&&... overloads)
{
return overload<TOthers...>{ etl::forward<TOthers>(overloads)... };
}
#endif
#endif
}
#endif

10
include/etl/parameter_pack.h
View File

@ -77,7 +77,7 @@ namespace etl
static_assert(etl::is_one_of<T, TTypes...>::value, "T is not in parameter pack");
/// The idex value.
/// The index value.
static constexpr size_t value = index_of_type_helper<T, TTypes...>::value - 1;
};
@ -120,6 +120,14 @@ namespace etl
template <size_t I>
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>;
#if ETL_CPP17_SUPPORTED
template <typename T, typename... TTypes>
inline constexpr size_t parameter_pack_v = etl::parameter_pack<TTypes...>::template index_of_type<T>::value;
#endif
}
#endif
#endif

1028
include/etl/private/variant_legacy.h Normal file
View File

File diff suppressed because it is too large Load Diff

1260
include/etl/private/variant_new.h Normal file
View File

File diff suppressed because it is too large Load Diff

196
include/etl/type_traits.h
View File

@ -123,6 +123,9 @@ namespace etl
/// remove_reference
template <typename T> struct remove_reference { typedef T type; };
template <typename T> struct remove_reference<T&> { typedef T type; };
#if ETL_CPP11_SUPPORTED
template <typename T> struct remove_reference<T&&> { typedef T type; };
#endif
#if ETL_CPP11_SUPPORTED
template <typename T>
@ -492,6 +495,11 @@ namespace etl
template <bool B, typename T, typename F> struct conditional { typedef T type; };
template <typename T, typename F> struct conditional<false, T, F> { typedef F type; };
#if ETL_CPP11_SUPPORTED
template <bool B, typename T, typename F>
using conditional_t = typename conditional<B, T, F>::type;
#endif
//***************************************************************************
/// make_signed
template <typename T> struct make_signed { typedef T type; };
@ -769,6 +777,7 @@ namespace etl
/// Specialisation of 'alignment_of' for 'void'.
///\ingroup type_traits
template <> struct alignment_of<void> : integral_constant <size_t, 0> {};
template <> struct alignment_of<const void> : integral_constant <size_t, 0> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
@ -1210,6 +1219,11 @@ namespace etl
template <bool B, typename T, typename F> struct conditional { typedef T type; };
template <typename T, typename F> struct conditional<false, T, F> { typedef F type; };
#if ETL_CPP11_SUPPORTED
template <bool B, typename T, typename F>
using conditional_t = typename conditional<B, T, F>::type;
#endif
//***************************************************************************
/// make_signed
///\ingroup type_traits
@ -1355,6 +1369,7 @@ namespace etl
///\ingroup type_traits
template <typename T> struct alignment_of : std::alignment_of<T> {};
template <> struct alignment_of<void> : std::integral_constant<size_t, 0> {};
template <> struct alignment_of<const void> : integral_constant <size_t, 0> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
@ -1610,6 +1625,187 @@ namespace etl
#if ETL_CPP17_SUPPORTED
template <typename T, typename T1, typename... TRest>
inline constexpr bool are_all_same_v = are_all_same<T, T1, TRest...>::value;
#endif
//***************************************************************************
/// conjunction
#if ETL_CPP11_SUPPORTED
template <typename...>
struct conjunction : public etl::true_type
{
};
template <typename T1, typename... Tn>
struct conjunction<T1, Tn...> : public etl::conditional_t<bool(T1::value), etl::conjunction<Tn...>, T1>
{
};
template <typename T>
struct conjunction<T> : public T
{
};
#endif
#if ETL_CPP17_SUPPORTED
template <typename... T>
inline constexpr bool conjunction_v = conjunction<T...>::value;
#endif
//***************************************************************************
/// disjunction
#if ETL_CPP11_SUPPORTED
template <typename...>
struct disjunction : public etl::false_type
{
};
template <typename T1, typename... Tn>
struct disjunction<T1, Tn...> : public etl::conditional_t<bool(T1::value), T1, disjunction<Tn...>>
{
};
template <typename T1> struct disjunction<T1> : public T1
{
};
#endif
#if ETL_CPP17_SUPPORTED
template <typename... T>
inline constexpr bool disjunction_v = etl::disjunction<T...>::value;
#endif
//***************************************************************************
#if ETL_CPP11_SUPPORTED && ETL_USING_STL && !defined(ETL_USE_TYPE_TRAITS_BUILTINS) && ((!defined(ARDUINO) && ETL_NOT_USING_STLPORT) || defined(ETL_GCC_V5_TYPE_TRAITS_SUPPORTED))
//*********************************************
// Use the STL's definitions.
//*********************************************
template<typename T1, typename T2>
struct is_assignable : public std::is_assignable<T1, T2>
{
};
template <typename T1, typename T2>
struct is_lvalue_assignable : public etl::is_assignable<typename etl::add_lvalue_reference<T1>::type,
typename etl::add_lvalue_reference<typename etl::add_const<T2>::type>::type>
{
};
template<typename T, typename... TArgs>
struct is_constructible : public std::is_constructible<T, TArgs...>
{
};
template <typename T>
struct is_copy_constructible : public std::is_copy_constructible<T>
{
};
template <typename T>
struct is_move_constructible : public std::is_move_constructible<T>
{
};
//#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
// template<typename T, typename... TArgs>
// struct is_trivially_constructible : public std::is_trivially_constructible<T, TArgs...>
// {
// };
//#endif
#elif defined(ETL_USE_TYPE_TRAITS_BUILTINS)
//*********************************************
// Use the compiler's builtins.
//*********************************************
template<typename T1, typename T2>
struct is_assignable : public bool_constant<__is_assignable(T1, T2)>
{
};
template <typename T1, typename T2>
struct is_lvalue_assignable : public etl::is_assignable<typename etl::add_lvalue_reference<T1>::type,
typename etl::add_lvalue_reference<typename etl::add_const<T2>::type>::type>
{
};
template<typename T, typename... TArgs>
struct is_constructible : public bool_constant<__is_constructible(T, TArgs...)>
{
};
template <typename T>
struct is_copy_constructible : public etl::is_constructible<T, etl::add_lvalue_reference_t<const T>>
{
};
template <typename T>
struct is_move_constructible : public etl::is_constructible<T, T>
{
};
//template<typename T, typename... TArgs>
//struct is_trivially_constructible : public bool_constant<etl::is_constructible<T, Args...>::value&& __is_trivially_constructible(T, TArgs...)>
//{
//};
#else
//*********************************************
// Force the user to provide specialisations.
//*********************************************
template<typename T, typename... TArgs>
struct is_assignable : public etl::bool_constant<true>
{
};
template <typename T1, typename T2>
struct is_lvalue_assignable : public etl::bool_constant<true>
{
};
template<typename T, typename... TArgs>
struct is_constructible : public etl::bool_constant<true>
{
};
template <typename T>
struct is_copy_constructible : public etl::bool_constant<etl::is_pod<T>::value>
{
};
template <typename T>
struct is_move_constructible : public etl::bool_constant<etl::is_pod<T>::value>
{
};
//template<typename T, typename... TArgs>
//struct is_trivially_constructible : public etl::bool_constant<etl::is_pod<T>::value>
//{
//};
#endif
#if ETL_CPP17_SUPPORTED
template<typename T1, typename T2>
inline constexpr size_t is_assignable_v = etl::is_assignable<T1, T2>::value;
template<typename T1, typename T2>
inline constexpr size_t is_lvalue_assignable_v = etl::is_lvalue_assignable<T1, T2>::value;
template<typename T, typename... TArgs>
inline constexpr size_t is_constructible_v = etl::is_constructible<T, TArgs...>::value;
template<typename T>
inline constexpr size_t is_copy_constructible_v = etl::is_copy_constructible<T>::value;
template<typename T>
inline constexpr size_t is_move_constructible_v = etl::is_move_constructible<T>::value;
//template<typename T, typename... TArgs>
//inline constexpr size_t is_trivially_constructible_v = etl::is_trivially_constructible<T, TArgs...>::value;
#endif
}

85
include/etl/utility.h
View File

@ -332,8 +332,55 @@ namespace etl
return t;
}
//******************************************************************************
//***************************************************************************
/// integer_sequence
//***************************************************************************
#if ETL_CPP11_SUPPORTED
template <typename T, T... Integers>
class integer_sequence
{
public:
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Integral types only");
typedef T value_type;
static ETL_CONSTEXPR size_t size() ETL_NOEXCEPT
{
return sizeof...(Integers);
}
};
namespace private_integer_sequence
{
template <size_t N, typename IndexSeq>
struct make_index_sequence;
template <size_t N, size_t... Indices>
struct make_index_sequence<N, etl::integer_sequence<size_t, Indices...>>
{
typedef typename make_index_sequence<N - 1, etl::integer_sequence<size_t, N - 1, Indices...>>::type type;
};
template <size_t... Indices>
struct make_index_sequence<0, etl::integer_sequence<size_t, Indices...>>
{
typedef etl::integer_sequence<size_t, Indices...> type;
};
}
//***********************************
template <size_t N>
using make_index_sequence = typename private_integer_sequence::make_index_sequence<N, etl::integer_sequence<size_t>>::type;
//***********************************
template <size_t... Indices>
using index_sequence = etl::integer_sequence<size_t, Indices...>;
#endif
//***************************************************************************
/// 2D coordinate type.
//***************************************************************************
template <typename T>
struct coordinate_2d
{
@ -362,6 +409,42 @@ namespace etl
T x;
T y;
};
//***************************************************************************
/// in_place disambiguation tags.
//***************************************************************************
//*************************
struct in_place_t
{
explicit ETL_CONSTEXPR in_place_t() {}
};
#if ETL_CPP17_SUPPORTED
inline constexpr in_place_t in_place;
#endif
//*************************
template <typename T> struct in_place_type_t
{
explicit ETL_CONSTEXPR in_place_type_t(){};
};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr in_place_type_t<T> in_place_type;
#endif
//*************************
template <std::size_t I> struct in_place_index_t
{
explicit ETL_CONSTEXPR in_place_index_t() {}
};
#if ETL_CPP17_SUPPORTED
template <std::size_t I>
inline constexpr in_place_index_t<I> in_place_index;
#endif
}
#endif

999
include/etl/variant.h
View File

File diff suppressed because it is too large Load Diff

3
test/CMakeLists.txt
View File

@ -236,7 +236,8 @@ set(TEST_SOURCE_FILES
test_user_type.cpp
test_utility.cpp
test_variance.cpp
test_variant.cpp
test_variant_legacy.cpp
test_variant_new.cpp
test_variant_pool.cpp
test_vector.cpp
test_vector_external_buffer.cpp

6
test/etl_profile.h
View File

@ -80,6 +80,8 @@ SOFTWARE.
//#define ETL_NO_STL
#define ETL_USE_TYPE_TRAITS_BUILTINS
#if defined(ETL_FORCE_TEST_CPP03)
#define ETL_FUNCTION_FORCE_CPP03
#define ETL_PRIORITY_QUEUE_FORCE_CPP03
@ -98,6 +100,10 @@ SOFTWARE.
#define ETL_MEM_CAST_FORCE_CPP03
#endif
//#define ETL_OVERLOAD_FORCE_CPP14
//#define ETL_VARIANT_FORCE_CPP11
#define ETL_VARIANT_CPP11_MAX_16_TYPES
#if defined(ETL_NO_STL)
#define ETL_TIMER_SEMAPHORE_TYPE uint32_t
#endif

32
test/runsanitychecks.sh
View File

@ -16,22 +16,22 @@ echo "-----------------------------------------------"
echo "GCC - STL"; } >> ../log.txt
g++ --version | head --lines=1 >> ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake --cmake-clean-cache -DNO_STL=OFF ..
cmake --build bgcc || echo "**** Failed ****" >> ../log.txt
cmake --build bgcc || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "GCC - No STL"; } >> ../log.txt
g++ --version | head --lines=1 >> ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake --cmake-clean-cache -DNO_STL=ON ..
cmake --build bgcc || echo "**** Failed ****" >> ../log.txt
cmake --build bgcc || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "Clang - STL"; } >> ../log.txt
clang++ --version | head --lines=1 >> ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake --cmake-clean-cache -DNO_STL=OFF ..
cmake --build bclang || echo "**** Failed ****" >> ../log.txt
cmake --build bclang || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "Clang - No STL"; } >> ../log.txt
clang++ --version | head --lines=1 >> ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake --cmake-clean-cache -DNO_STL=ON ..
cmake --build bclang || echo "**** Failed ****" >> ../log.txt
cmake --build bclang || echo "****************\n**** Failed ****\n****************" >> ../log.txt
###############################################################################
cd ../c++11 || exit 1
@ -44,22 +44,22 @@ echo "-----------------------------------------------"
echo "GCC - STL"; } >> ../log.txt
g++ --version | head --lines=1 >> ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake --cmake-clean-cache -DNO_STL=OFF ..
cmake --build bgcc || echo "**** Failed ****" >> ../log.txt
cmake --build bgcc || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "GCC - No STL"; } >> ../log.txt
g++ --version | head --lines=1 >> ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake --cmake-clean-cache -DNO_STL=ON ..
cmake --build bgcc || echo "**** Failed ****" >> ../log.txt
cmake --build bgcc || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "Clang - STL"; } >> ../log.txt
clang++ --version | head --lines=1 >> ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake --cmake-clean-cache -DNO_STL=OFF ..
cmake --build bclang || echo "**** Failed ****" >> ../log.txt
cmake --build bclang || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "Clang - No STL"; } >> ../log.txt
clang++ --version | head --lines=1 >> ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake --cmake-clean-cache -DNO_STL=ON ..
cmake --build bclang || echo "**** Failed ****" >> ../log.txt
cmake --build bclang || echo "****************\n**** Failed ****\n****************" >> ../log.txt
###############################################################################
cd ../c++14 || exit 1
@ -72,22 +72,22 @@ echo "-----------------------------------------------"
echo " GCC - STL"; } >> ../log.txt
g++ --version | head --lines=1 >> ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake --cmake-clean-cache -DNO_STL=OFF ..
cmake --build bgcc || echo "**** Failed ****" >> ../log.txt
cmake --build bgcc || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "GCC - No STL"; } >> ../log.txt
g++ --version | head --lines=1 >> ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake --cmake-clean-cache -DNO_STL=ON ..
cmake --build bgcc || echo "**** Failed ****" >> ../log.txt
cmake --build bgcc || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "Clang - STL"; } >> ../log.txt
clang++ --version | head --lines=1 >> ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake --cmake-clean-cache -DNO_STL=OFF ..
cmake --build bclang || echo "**** Failed ****" >> ../log.txt
cmake --build bclang || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "Clang - No STL"; } >> ../log.txt
clang++ --version | head --lines=1 >> ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake --cmake-clean-cache -DNO_STL=ON ..
cmake --build bclang || echo "**** Failed ****" >> ../log.txt
cmake --build bclang || echo "****************\n**** Failed ****\n****************" >> ../log.txt
###############################################################################
cd ../c++17 || exit 1
@ -100,22 +100,22 @@ echo "-----------------------------------------------"
echo "GCC - STL"; } >> ../log.txt
g++ --version | head --lines=1 >> ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake --cmake-clean-cache -DNO_STL=OFF ..
cmake --build bgcc || echo "**** Failed ****" >> ../log.txt
cmake --build bgcc || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "GCC - No STL"; } >> ../log.txt
g++ --version | head --lines=1 >> ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake --cmake-clean-cache -DNO_STL=ON ..
cmake --build bgcc || echo "**** Failed ****" >> ../log.txt
cmake --build bgcc || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "Clang - STL"; } >> ../log.txt
clang++ --version | head --lines=1 >> ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake --cmake-clean-cache -DNO_STL=OFF ..
cmake --build bclang || echo "**** Failed ****" >> ../log.txt
cmake --build bclang || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "Clang - No STL"; } >> ../log.txt
clang++ --version | head --lines=1 >> ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake --cmake-clean-cache -DNO_STL=ON ..
cmake --build bclang || echo "**** Failed ****" >> ../log.txt
cmake --build bclang || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""
echo "-----------------------------------------------"

4
test/sanity-check/c++03/CMakeLists.txt
View File

@ -173,6 +173,7 @@ target_sources(t98 PRIVATE etl_profile.h
../numeric.h.t.cpp
../observer.h.t.cpp
../optional.h.t.cpp
../overload.h.t.cpp
../packet.h.t.cpp
../parameter_pack.h.t.cpp
../parameter_type.h.t.cpp
@ -242,7 +243,8 @@ target_sources(t98 PRIVATE etl_profile.h
../user_type.h.t.cpp
../utility.h.t.cpp
../variance.h.t.cpp
../variant.h.t.cpp
../variant_legacy.h.t.cpp
../variant_new.h.t.cpp
../variant_pool.h.t.cpp
../vector.h.t.cpp
../version.h.t.cpp

4
test/sanity-check/c++11/CMakeLists.txt
View File

@ -173,6 +173,7 @@ target_sources(t11 PRIVATE etl_profile.h
../numeric.h.t.cpp
../observer.h.t.cpp
../optional.h.t.cpp
../overload.h.t.cpp
../packet.h.t.cpp
../parameter_pack.h.t.cpp
../parameter_type.h.t.cpp
@ -242,7 +243,8 @@ target_sources(t11 PRIVATE etl_profile.h
../user_type.h.t.cpp
../utility.h.t.cpp
../variance.h.t.cpp
../variant.h.t.cpp
../variant_legacy.h.t.cpp
../variant_new.h.t.cpp
../variant_pool.h.t.cpp
../vector.h.t.cpp
../version.h.t.cpp

4
test/sanity-check/c++14/CMakeLists.txt
View File

@ -173,6 +173,7 @@ target_sources(t14 PRIVATE etl_profile.h
../numeric.h.t.cpp
../observer.h.t.cpp
../optional.h.t.cpp
../overload.h.t.cpp
../packet.h.t.cpp
../parameter_pack.h.t.cpp
../parameter_type.h.t.cpp
@ -242,7 +243,8 @@ target_sources(t14 PRIVATE etl_profile.h
../user_type.h.t.cpp
../utility.h.t.cpp
../variance.h.t.cpp
../variant.h.t.cpp
../variant_legacy.h.t.cpp
../variant_new.h.t.cpp
../variant_pool.h.t.cpp
../vector.h.t.cpp
../version.h.t.cpp

4
test/sanity-check/c++17/CMakeLists.txt
View File

@ -173,6 +173,7 @@ target_sources(t17 PRIVATE etl_profile.h
../numeric.h.t.cpp
../observer.h.t.cpp
../optional.h.t.cpp
../overload.h.t.cpp
../packet.h.t.cpp
../parameter_pack.h.t.cpp
../parameter_type.h.t.cpp
@ -242,7 +243,8 @@ target_sources(t17 PRIVATE etl_profile.h
../user_type.h.t.cpp
../utility.h.t.cpp
../variance.h.t.cpp
../variant.h.t.cpp
../variant_legacy.h.t.cpp
../variant_new.h.t.cpp
../variant_pool.h.t.cpp
../vector.h.t.cpp
../version.h.t.cpp

29
test/sanity-check/overload.h.t.cpp Normal file
View File

@ -0,0 +1,29 @@
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2021 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#include <etl/overload.h>

29
test/sanity-check/variant_legacy.h.t.cpp Normal file
View File

@ -0,0 +1,29 @@
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2021 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#include <etl/private/variant_legacy.h>

29
test/sanity-check/variant_new.h.t.cpp Normal file
View File

@ -0,0 +1,29 @@
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2021 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#include <etl/private/variant_new.h>

29
test/sanity-check/variant_old.h.t.cpp Normal file
View File

@ -0,0 +1,29 @@
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2021 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#include <etl/private/variant_old.h>

4
test/test_mem_cast.cpp
View File

@ -68,9 +68,7 @@ namespace
using MemCast = etl::mem_cast<Size, Alignment>;
using MemCastTypes = etl::mem_cast_types<char, double, Data>;
char c;
double d;
Data data;
Data data;
SUITE(test_mem_cast)
{

4
test/test_mem_cast_ptr.cpp
View File

@ -65,8 +65,6 @@ namespace
// Test variant types.
using MemCast = etl::mem_cast_ptr;
char c;
double d;
Data data;
char* Ptr(int i)
@ -83,8 +81,6 @@ namespace
{
MemCast memCast;
char* p = nullptr;
memCast.data(Ptr(1));
CHECK_EQUAL(1U , memCast.alignment());

88
test/test_mem_type.cpp Normal file
View File

@ -0,0 +1,88 @@
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2021 jwellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#include "unit_test_framework.h"
#include "etl/experimental/mem_type.h"
#include "etl/largest.h"
#include <array>
#include <vector>
#include <algorithm>
#include <string>
namespace
{
struct Data
{
char c;
short s;
std::array<int, 10> a;
};
// Test variant types.
using MemType = etl::mem_type<etl::largest<char, double, Data>::size,
etl::largest<char, double, Data>::alignment>;
SUITE(test_mem_type)
{
TEST(test_alignment)
{
MemType memType;
CHECK(alignof(char) <= MemType::Alignment);
CHECK(alignof(short) <= MemType::Alignment);
CHECK(alignof(Data) <= MemType::Alignment);
CHECK(alignof(char) <= memType.Alignment);
CHECK(alignof(short) <= memType.Alignment);
CHECK(alignof(Data) <= memType.Alignment);
CHECK(alignof(char) <= memType.alignment());
CHECK(alignof(short) <= memType.alignment());
CHECK(alignof(Data) <= memType.alignment());
}
TEST(test_size)
{
MemType memType;
CHECK(sizeof(char) <= MemType::Size);
CHECK(sizeof(short) <= MemType::Size);
CHECK(sizeof(Data) <= MemType::Size);
CHECK(sizeof(char) <= memType.Size);
CHECK(sizeof(short) <= memType.Size);
CHECK(sizeof(Data) <= memType.Size);
CHECK(sizeof(char) <= memType.size());
CHECK(sizeof(short) <= memType.size());
CHECK(sizeof(Data) <= memType.size());
}
};
}

164
test/test_overload.cpp Normal file
View File

@ -0,0 +1,164 @@
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2015 jwellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#include "unit_test_framework.h"
#include "etl/overload.h"
#include <iostream>
namespace
{
struct Result
{
Result()
: bi(false)
, bd(false)
, bs(false)
{
}
void clear()
{
bi = false;
bd = false;
bs = false;
}
bool bi;
bool bd;
bool bs;
};
Result result;
struct Visitor
{
void operator ()(int i) { result.bi = true; }
void operator ()(double d) { result.bd = true; }
void operator ()(const std::string& s) { result.bs = true; }
};
template <typename T, typename TOverload>
void Function(T value, TOverload& ol)
{
ol(value);
}
SUITE(test_overload)
{
//*************************************************************************
TEST(test_overload_lambdas)
{
auto overload = etl::make_overload([](int i) { result.bi = true; },
[](double d) { result.bd = true; },
[](const std::string& s) { result.bs = true; });
result.clear();
Function(int(1), overload);
CHECK(result.bi == true);
CHECK(result.bd == false);
CHECK(result.bs == false);
result.clear();
Function(double(2.0), overload);
CHECK(result.bi == false);
CHECK(result.bd == true);
CHECK(result.bs == false);
result.clear();
Function(std::string("3"), overload);
CHECK(result.bi == false);
CHECK(result.bd == false);
CHECK(result.bs == true);
}
//*************************************************************************
TEST(test_overload_lambdas_cpp17)
{
#if !defined(ETL_OVERLOAD_FORCE_CPP14)
result.clear();
Function(int(1), etl::overload
{
[](int i) { result.bi = true; },
[](double d) { result.bd = true; },
[](const std::string& s) { result.bs = true; }
});
CHECK(result.bi == true);
CHECK(result.bd == false);
CHECK(result.bs == false);
result.clear();
Function(double(2.0), etl::overload
{
[](int i) { result.bi = true; },
[](double d) { result.bd = true; },
[](const std::string& s) { result.bs = true; }
});
CHECK(result.bi == false);
CHECK(result.bd == true);
CHECK(result.bs == false);
result.clear();
Function(std::string("3"), etl::overload
{
[](int i) { result.bi = true; },
[](double d) { result.bd = true; },
[](const std::string& s) { result.bs = true; }
});
CHECK(result.bi == false);
CHECK(result.bd == false);
CHECK(result.bs == true);
#endif
}
//*************************************************************************
TEST(test_visitor_overload)
{
auto overload = etl::make_overload(Visitor());
result.clear();
Function(int(1), overload);
CHECK(result.bi == true);
CHECK(result.bd == false);
CHECK(result.bs == false);
result.clear();
Function(double(2.0), overload);
CHECK(result.bi == false);
CHECK(result.bd == true);
CHECK(result.bs == false);
result.clear();
Function(std::string("3"), overload);
CHECK(result.bi == false);
CHECK(result.bd == false);
CHECK(result.bs == true);
}
};
}

16
test/test_parameter_pack.cpp
View File

@ -30,8 +30,6 @@ SOFTWARE.
#include "etl/parameter_pack.h"
#include <type_traits>
namespace
{
using Pack = etl::parameter_pack<char, short, int>;
@ -47,6 +45,13 @@ namespace
// Static assert
//CHECK_EQUAL(0U, Pack::index_of_type_v<long>);
CHECK_EQUAL(0U, (etl::parameter_pack_v<char, char, short, int>));
CHECK_EQUAL(1U, (etl::parameter_pack_v<short, char, short, int>));
CHECK_EQUAL(2U, (etl::parameter_pack_v<int, char, short, int>));
// Static assert
//CHECK_EQUAL(0U, (etl::parameter_pack_v<long, char, short, int>));
}
//*************************************************************************
@ -58,6 +63,13 @@ namespace
// Static assert
//CHECK((std::is_same_v<long, typename Pack::type_from_index_t<3U>>));
CHECK((std::is_same_v<char, etl::parameter_pack_t<0U, char, short, int>>));
CHECK((std::is_same_v<short, etl::parameter_pack_t<1U, char, short, int>>));
CHECK((std::is_same_v<int, etl::parameter_pack_t<2U, char, short, int>>));
// Static assert
//CHECK((std::is_same_v<long, etl::parameter_pack_t<3U, char, short, int>>));
}
};
}

2
test/test_variant.cpp → test/test_variant_legacy.cpp
View File

@ -28,7 +28,7 @@ SOFTWARE.
#include "unit_test_framework.h"
#include "etl/variant.h"
#include "etl/private/variant_legacy.h"
#include <array>
#include <vector>

1114
test/test_variant_new.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

59
test/vs2019/etl.vcxproj
View File

@ -1309,6 +1309,7 @@
<ClInclude Include="..\..\include\etl\cumulative_moving_average.h" />
<ClInclude Include="..\..\include\etl\delegate.h" />
<ClInclude Include="..\..\include\etl\delegate_service.h" />
<ClInclude Include="..\..\include\etl\experimental\mem_cast.h" />
<ClInclude Include="..\..\include\etl\file_error_numbers.h" />
<ClInclude Include="..\..\include\etl\flags.h" />
<ClInclude Include="..\..\include\etl\format_spec.h" />
@ -1347,6 +1348,7 @@
<ClInclude Include="..\..\include\etl\mutex\mutex_clang_sync.h" />
<ClInclude Include="..\..\include\etl\mutex\mutex_freertos.h" />
<ClInclude Include="..\..\include\etl\negative.h" />
<ClInclude Include="..\..\include\etl\overload.h" />
<ClInclude Include="..\..\include\etl\placement_new.h" />
<ClInclude Include="..\..\include\etl\null_type.h" />
<ClInclude Include="..\..\include\etl\parameter_pack.h" />
@ -1354,6 +1356,8 @@
<ClInclude Include="..\..\include\etl\private\crc_implementation.h" />
<ClInclude Include="..\..\include\etl\private\crc_parameters.h" />
<ClInclude Include="..\..\include\etl\private\to_string_helper.h" />
<ClInclude Include="..\..\include\etl\private\variant_legacy.h" />
<ClInclude Include="..\..\include\etl\private\variant_new.h" />
<ClInclude Include="..\..\include\etl\profiles\armv7.h" />
<ClInclude Include="..\..\include\etl\profiles\armv7_no_stl.h" />
<ClInclude Include="..\..\include\etl\profiles\clang_generic.h" />
@ -3473,6 +3477,23 @@
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugNoSTLForceNoAdvanced|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="..\sanity-check\overload.h.t.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugLLVMNoSTL|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVCDebugNoSTLAppveyor|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugMSVCSmallStrings|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug No Unit Tests|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugStringTruncationIsError|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='LLVM New|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug LLVM|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC No Checks|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug64|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugNoSTL|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug Clang|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVCDebugAppveyor|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugNoSTLForceNoAdvanced|Win32'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="..\sanity-check\packet.h.t.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugNoSTL|Win32'">true</ExcludedFromBuild>
@ -4349,6 +4370,40 @@
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugNoSTLForceNoAdvanced|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="..\sanity-check\variant_new.h.t.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugLLVMNoSTL|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVCDebugNoSTLAppveyor|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugMSVCSmallStrings|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug No Unit Tests|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugStringTruncationIsError|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='LLVM New|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug LLVM|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC No Checks|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug64|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugNoSTL|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug Clang|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVCDebugAppveyor|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugNoSTLForceNoAdvanced|Win32'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="..\sanity-check\variant_legacy.h.t.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugLLVMNoSTL|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVCDebugNoSTLAppveyor|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugMSVCSmallStrings|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug No Unit Tests|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugStringTruncationIsError|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='LLVM New|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug LLVM|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC No Checks|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug64|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugNoSTL|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug Clang|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVCDebugAppveyor|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugNoSTLForceNoAdvanced|Win32'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="..\sanity-check\variant_pool.h.t.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugNoSTL|Win32'">true</ExcludedFromBuild>
@ -4883,6 +4938,7 @@
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug No Unit Tests|x64'">false</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="..\test_optional.cpp" />
<ClCompile Include="..\test_overload.cpp" />
<ClCompile Include="..\test_packet.cpp" />
<ClCompile Include="..\test_parameter_pack.cpp" />
<ClCompile Include="..\test_parameter_type.cpp" />
@ -4963,7 +5019,8 @@
<ClCompile Include="..\test_user_type.cpp" />
<ClCompile Include="..\test_utility.cpp" />
<ClCompile Include="..\test_variance.cpp" />
<ClCompile Include="..\test_variant.cpp" />
<ClCompile Include="..\test_variant_legacy.cpp" />
<ClCompile Include="..\test_variant_new.cpp" />
<ClCompile Include="..\test_variant_pool.cpp" />
<ClCompile Include="..\test_vector.cpp" />
<ClCompile Include="..\test_vector_external_buffer.cpp" />

49
test/vs2019/etl.vcxproj.filters
View File

@ -1113,9 +1113,30 @@
<ClInclude Include="..\..\include\etl\hfsm.h">
<Filter>ETL\Frameworks</Filter>
</ClInclude>
<ClInclude Include="..\..\include\etl\private\variant_legacy.h">
<Filter>ETL\Private</Filter>
</ClInclude>
<ClInclude Include="..\..\include\etl\private\variant_new.h">
<Filter>ETL\Private</Filter>
</ClInclude>
<ClInclude Include="..\..\include\etl\mem_cast.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\include\etl\private\variant_legacy.h">
<Filter>ETL\Private</Filter>
</ClInclude>
<ClInclude Include="..\..\include\etl\private\variant_new.h">
<Filter>ETL\Private</Filter>
</ClInclude>
<ClInclude Include="..\..\include\etl\overload.h">
<Filter>ETL\Patterns</Filter>
</ClInclude>
<ClInclude Include="..\..\include\etl\overload.h">
<Filter>ETL\Patterns</Filter>
</ClInclude>
<ClInclude Include="..\..\include\etl\experimental\mem_cast.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\main.cpp">
@ -1169,7 +1190,7 @@
<ClCompile Include="..\test_bitset.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_variant.cpp">
<ClCompile Include="..\test_variant_legacy.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_smallest.cpp">
@ -2534,6 +2555,18 @@
<ClCompile Include="..\test_hfsm.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_variant_new.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_mem_cast.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_mem_cast_ptr.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_variant_new.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_mem_cast.cpp">
<Filter>Source Files</Filter>
</ClCompile>
@ -2543,6 +2576,18 @@
<ClCompile Include="..\sanity-check\mem_cast.h.t.cpp">
<Filter>Source Files\Sanity Checks</Filter>
</ClCompile>
<ClCompile Include="..\sanity-check\variant_new.h.t.cpp">
<Filter>Source Files\Sanity Checks</Filter>
</ClCompile>
<ClCompile Include="..\sanity-check\variant_legacy.h.t.cpp">
<Filter>Source Files\Sanity Checks</Filter>
</ClCompile>
<ClCompile Include="..\sanity-check\overload.h.t.cpp">
<Filter>Source Files\Sanity Checks</Filter>
</ClCompile>
<ClCompile Include="..\test_overload.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<None Include="..\..\library.properties">
@ -2687,4 +2732,4 @@
<Filter>Resource Files</Filter>
</Natvis>
</ItemGroup>
</Project>
</Project>

7
test/vs2022/.gitignore vendored Normal file
View File

@ -0,0 +1,7 @@
/random_clcg.csv
/random_lcg.csv
/random_lsfr.csv
/random_mwc.csv
/random_xorshift.csv
/random_pcg.csv
/random_hash.csv

1
test/vs2022/.leu Normal file
View File

@ -0,0 +1 @@
<?xml version="1.0" encoding="utf-8"?><files><file path="D:\Users\John\Documents\Programming\GitHub\etl\test\runtests.sh" dateUnified="637527276086569220" lineEndings="Linux" /><file path="D:\Users\John\Documents\Programming\GitHub\etl\test\runsanitychecks.sh" dateUnified="637511701526275447" lineEndings="Linux" /></files>

3
test/vs2022/NatvisFile.natvis Normal file
View File

@ -0,0 +1,3 @@
<?xml version="1.0" encoding="utf-8"?>
<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
</AutoVisualizer>

40
test/vs2022/cpp.hint Normal file
View File

@ -0,0 +1,40 @@
// Hint files help the Visual Studio IDE interpret Visual C++ identifiers
// such as names of functions and macros.
// For more information see https://go.microsoft.com/fwlink/?linkid=865984
#define ETL_CONSTEXPR
#define ETL_CONSTEXPR14
#define ETL_CONSTEXPR17
#define ETL_IF_CONSTEXPR
#define ETL_DELETE
#define ETL_NOEXCEPT
#define ETL_NOEXCEPT_EXPR
#define ETL_NODISCARD
#define ETL_OVERRIDE
#define ETL_FINAL
#define ETL_DEPRECATED
#define ETL_ERROR_TEXT
#define ETL_ASSERT
#define ETL_ERROR
#define ETL_VERBOSE_ERRORS
#define ETL_FILE
#define ETL_NULLPTR
#define ETL_CPP11_SUPPORTED
#define ETL_CPP14_SUPPORTED
#define ETL_CPP17_SUPPORTED
#define TEST
#define CHECK
#define CHECK_EQUAL
#define CHECK_THROW
// Hint files help the Visual Studio IDE interpret Visual C++ identifiers
// such as names of functions and macros.
// For more information see https://go.microsoft.com/fwlink/?linkid=865984
#define ETL_ASSERT(b, e)
#define ETL_ASSERT(b, e) {if (!(b)) {etl::error_handler::error((e)); throw((e));}}
#define ETL_ASSERT(b, e) {if (!(b)) {throw((e));}}
#define ETL_ASSERT(b, e) {if(!(b)) {etl::error_handler::error((e));}}
#define ETL_ASSERT(b, e) assert((b))
// Hint files help the Visual Studio IDE interpret Visual C++ identifiers
// such as names of functions and macros.
// For more information see https://go.microsoft.com/fwlink/?linkid=865984
#define ETL_NULLPTR

103
test/vs2022/etl.sln Normal file
View File

@ -0,0 +1,103 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.29926.136
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "etl", "etl.vcxproj", "{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug LLVM - No STL|Win32 = Debug LLVM - No STL|Win32
Debug LLVM - No STL|x64 = Debug LLVM - No STL|x64
Debug LLVM|Win32 = Debug LLVM|Win32
Debug LLVM|x64 = Debug LLVM|x64
Debug MSVC - No STL - Force No Advanced|Win32 = Debug MSVC - No STL - Force No Advanced|Win32
Debug MSVC - No STL - Force No Advanced|x64 = Debug MSVC - No STL - Force No Advanced|x64
Debug MSVC - No STL|Win32 = Debug MSVC - No STL|Win32
Debug MSVC - No STL|x64 = Debug MSVC - No STL|x64
Debug MSVC - No Unit Tests|Win32 = Debug MSVC - No Unit Tests|Win32
Debug MSVC - No Unit Tests|x64 = Debug MSVC - No Unit Tests|x64
Debug MSVC - Small Strings|Win32 = Debug MSVC - Small Strings|Win32
Debug MSVC - Small Strings|x64 = Debug MSVC - Small Strings|x64
Debug MSVC - String Truncation Is Error|Win32 = Debug MSVC - String Truncation Is Error|Win32
Debug MSVC - String Truncation Is Error|x64 = Debug MSVC - String Truncation Is Error|x64
Debug MSVC 64|Win32 = Debug MSVC 64|Win32
Debug MSVC 64|x64 = Debug MSVC 64|x64
Debug MSVC No Checks|Win32 = Debug MSVC No Checks|Win32
Debug MSVC No Checks|x64 = Debug MSVC No Checks|x64
Debug MSVC|Win32 = Debug MSVC|Win32
Debug MSVC|x64 = Debug MSVC|x64
LLVM New|Win32 = LLVM New|Win32
LLVM New|x64 = LLVM New|x64
MSVCDebugAppveyor|Win32 = MSVCDebugAppveyor|Win32
MSVCDebugAppveyor|x64 = MSVCDebugAppveyor|x64
MSVCDebugNoSTLAppveyor|Win32 = MSVCDebugNoSTLAppveyor|Win32
MSVCDebugNoSTLAppveyor|x64 = MSVCDebugNoSTLAppveyor|x64
Release|Win32 = Release|Win32
Release|x64 = Release|x64
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug LLVM - No STL|Win32.ActiveCfg = DebugLLVMNoSTL|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug LLVM - No STL|Win32.Build.0 = DebugLLVMNoSTL|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug LLVM - No STL|x64.ActiveCfg = DebugLLVMNoSTL|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug LLVM - No STL|x64.Build.0 = DebugLLVMNoSTL|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug LLVM|Win32.ActiveCfg = Debug LLVM|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug LLVM|Win32.Build.0 = Debug LLVM|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug LLVM|x64.ActiveCfg = Debug LLVM|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug LLVM|x64.Build.0 = Debug LLVM|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - No STL - Force No Advanced|Win32.ActiveCfg = DebugNoSTLForceNoAdvanced|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - No STL - Force No Advanced|Win32.Build.0 = DebugNoSTLForceNoAdvanced|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - No STL - Force No Advanced|x64.ActiveCfg = DebugNoSTLForceNoAdvanced|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - No STL - Force No Advanced|x64.Build.0 = DebugNoSTLForceNoAdvanced|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - No STL|Win32.ActiveCfg = DebugNoSTL|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - No STL|Win32.Build.0 = DebugNoSTL|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - No STL|x64.ActiveCfg = DebugNoSTL|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - No STL|x64.Build.0 = DebugNoSTL|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - No Unit Tests|Win32.ActiveCfg = Debug No Unit Tests|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - No Unit Tests|Win32.Build.0 = Debug No Unit Tests|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - No Unit Tests|x64.ActiveCfg = Debug No Unit Tests|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - No Unit Tests|x64.Build.0 = Debug No Unit Tests|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - Small Strings|Win32.ActiveCfg = DebugMSVCSmallStrings|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - Small Strings|Win32.Build.0 = DebugMSVCSmallStrings|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - Small Strings|x64.ActiveCfg = DebugMSVCSmallStrings|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - Small Strings|x64.Build.0 = DebugMSVCSmall Strings|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - String Truncation Is Error|Win32.ActiveCfg = DebugStringTruncationIsError|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - String Truncation Is Error|Win32.Build.0 = DebugStringTruncationIsError|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - String Truncation Is Error|x64.ActiveCfg = DebugStringTruncationIsError|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - String Truncation Is Error|x64.Build.0 = DebugStringTruncationIsError|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC 64|Win32.ActiveCfg = Debug No Unit Tests|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC 64|Win32.Build.0 = Debug No Unit Tests|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC 64|x64.ActiveCfg = Debug64|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC 64|x64.Build.0 = Debug64|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC No Checks|Win32.ActiveCfg = Debug MSVC No Checks|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC No Checks|Win32.Build.0 = Debug MSVC No Checks|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC No Checks|x64.ActiveCfg = Debug MSVC No Checks|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC No Checks|x64.Build.0 = Debug MSVC No Checks|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC|Win32.ActiveCfg = Debug|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC|Win32.Build.0 = Debug|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC|x64.ActiveCfg = Debug|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC|x64.Build.0 = Debug|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.LLVM New|Win32.ActiveCfg = LLVM New|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.LLVM New|Win32.Build.0 = LLVM New|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.LLVM New|x64.ActiveCfg = LLVM New|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.LLVM New|x64.Build.0 = LLVM New|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.MSVCDebugAppveyor|Win32.ActiveCfg = MSVCDebugAppveyor|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.MSVCDebugAppveyor|Win32.Build.0 = MSVCDebugAppveyor|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.MSVCDebugAppveyor|x64.ActiveCfg = MSVCDebugAppveyor|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.MSVCDebugAppveyor|x64.Build.0 = MSVCDebugAppveyor|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.MSVCDebugNoSTLAppveyor|Win32.ActiveCfg = MSVCDebugNoSTLAppveyor|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.MSVCDebugNoSTLAppveyor|Win32.Build.0 = MSVCDebugNoSTLAppveyor|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.MSVCDebugNoSTLAppveyor|x64.ActiveCfg = MSVCDebugNoSTLAppveyor|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.MSVCDebugNoSTLAppveyor|x64.Build.0 = MSVCDebugNoSTLAppveyor|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Release|Win32.ActiveCfg = Release|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Release|Win32.Build.0 = Release|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Release|x64.ActiveCfg = Release|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Release|x64.Build.0 = Release|x64
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {0E35F961-E9EF-40C4-8E3E-2EC79B1D44B8}
EndGlobalSection
EndGlobal

5091
test/vs2022/etl.vcxproj Normal file
View File

File diff suppressed because it is too large Load Diff

2738
test/vs2022/etl.vcxproj.filters Normal file
View File

File diff suppressed because it is too large Load Diff