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

Type traits refactor

Browse Source
This commit is contained in:
John Wellbelove 2021-07-26 17:17:22 +01:00
parent 8f570d81cd
commit fd89f51621
15 changed files with 4819 additions and 2472 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -316,3 +316,5 @@ test/vs2019/Debug LLVM
test/vs2019/DebugLLVMNoSTL
test/vs2019/DebugNoSTL
test/vs2022/Debug LLVM
test/vs2019/Debug MSVC - No STL - Built-ins/etl.exe
test/vs2019/Debug-LLVM-NoSTL-Builtins/etl.exe

2
examples/ArmTimerCallbacks - C++/ArmTimerCallbacks.uvoptx
View File

@ -103,7 +103,7 @@
<bEvRecOn>1</bEvRecOn>
<bSchkAxf>0</bSchkAxf>
<bTchkAxf>0</bTchkAxf>
<nTsel>5</nTsel>
<nTsel>6</nTsel>
<sDll></sDll>
<sDllPa></sDllPa>
<sDlgDll></sDlgDll>

24
examples/ArmTimerCallbacks - C++/ArmTimerCallbacks.uvprojx
View File

@ -16,7 +16,7 @@
<TargetCommonOption>
<Device>STM32F401RETx</Device>
<Vendor>STMicroelectronics</Vendor>
<PackID>Keil.STM32F4xx_DFP.2.14.0</PackID>
<PackID>Keil.STM32F4xx_DFP.2.15.0</PackID>
<PackURL>http://www.keil.com/pack/</PackURL>
<Cpu>IRAM(0x20000000,0x18000) IROM(0x08000000,0x80000) CPUTYPE("Cortex-M4") FPU2 CLOCK(12000000) ELITTLE</Cpu>
<FlashUtilSpec></FlashUtilSpec>
@ -185,6 +185,7 @@
<uocXRam>0</uocXRam>
<RvdsVP>2</RvdsVP>
<RvdsMve>0</RvdsMve>
<RvdsCdeCp>0</RvdsCdeCp>
<hadIRAM2>0</hadIRAM2>
<hadIROM2>0</hadIROM2>
<StupSel>8</StupSel>
@ -351,7 +352,7 @@
<NoWarn>0</NoWarn>
<uSurpInc>0</uSurpInc>
<useXO>0</useXO>
<uClangAs>0</uClangAs>
<ClangAsOpt>4</ClangAsOpt>
<VariousControls>
<MiscControls></MiscControls>
<Define></Define>
@ -452,7 +453,7 @@
<file attr="config" category="source" condition="STM32F401xE_ARMCC" name="Drivers\CMSIS\Device\ST\STM32F4xx\Source\Templates\arm\startup_stm32f401xe.s" version="2.6.0">
<instance index="0">RTE\Device\STM32F401RETx\startup_stm32f401xe.s</instance>
<component Cclass="Device" Cgroup="Startup" Cvendor="Keil" Cversion="2.6.3" condition="STM32F4 CMSIS"/>
<package name="STM32F4xx_DFP" schemaVersion="1.4" url="http://www.keil.com/pack/" vendor="Keil" version="2.14.0"/>
<package name="STM32F4xx_DFP" schemaVersion="1.6.3" url="http://www.keil.com/pack/" vendor="Keil" version="2.15.0"/>
<targetInfos>
<targetInfo name="Target 1"/>
</targetInfos>
@ -460,7 +461,7 @@
<file attr="config" category="source" name="Drivers\CMSIS\Device\ST\STM32F4xx\Source\Templates\system_stm32f4xx.c" version="2.6.0">
<instance index="0">RTE\Device\STM32F401RETx\system_stm32f4xx.c</instance>
<component Cclass="Device" Cgroup="Startup" Cvendor="Keil" Cversion="2.6.3" condition="STM32F4 CMSIS"/>
<package name="STM32F4xx_DFP" schemaVersion="1.4" url="http://www.keil.com/pack/" vendor="Keil" version="2.14.0"/>
<package name="STM32F4xx_DFP" schemaVersion="1.6.3" url="http://www.keil.com/pack/" vendor="Keil" version="2.15.0"/>
<targetInfos>
<targetInfo name="Target 1"/>
</targetInfos>
@ -468,4 +469,19 @@
</files>
</RTE>
<LayerInfo>
<Layers>
<Layer>
<LayName>&lt;Project Info&gt;</LayName>
<LayDesc></LayDesc>
<LayUrl></LayUrl>
<LayKeys></LayKeys>
<LayCat></LayCat>
<LayLic></LayLic>
<LayTarg>0</LayTarg>
<LayPrjMark>1</LayPrjMark>
</Layer>
</Layers>
</LayerInfo>
</Project>

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

@ -452,56 +452,6 @@ namespace etl
inline constexpr bool is_pod_v = etl::is_pod<T>::value;
#endif
//***************************************************************************
/// is_trivially_constructible
/// Only POD types are recognised.
template <typename T> struct is_trivially_constructible : etl::is_pod<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_constructible_v = etl::is_trivially_constructible<T>::value;
#endif
//***************************************************************************
/// is_trivially_copy_constructible
/// Only POD types are recognised.
template <typename T> struct is_trivially_copy_constructible : etl::is_pod<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_copy_constructible_v = etl::is_trivially_copy_constructible<T>::value;
#endif
//***************************************************************************
/// is_trivially_destructible
/// Only POD types are recognised.
template <typename T> struct is_trivially_destructible : etl::is_pod<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_destructible_v = etl::is_trivially_destructible<T>::value;
#endif
//***************************************************************************
/// is_trivially_copy_assignable
/// Only POD types are recognised.
template <typename T> struct is_trivially_copy_assignable : etl::is_pod<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_copy_assignable_v = etl::is_trivially_copy_assignable<T>::value;
#endif
//***************************************************************************
/// is_trivially_copyable
/// Only POD types are recognised.
template <typename T> struct is_trivially_copyable : etl::is_pod<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_copyable_v = etl::is_trivially_copyable<T>::value;
#endif
//***************************************************************************
/// conditional
template <bool B, typename T, typename F> struct conditional { typedef T type; };
@ -653,7 +603,7 @@ namespace etl
/// is_base_of
template<typename TBase,
typename TDerived,
const bool IsFundamental = (etl::is_fundamental<TBase>::value || etl::is_fundamental<TDerived>::value)>
const bool IsFundamental = (etl::is_fundamental<TBase>::value || etl::is_fundamental<TDerived>::value || etl::is_array<TDerived>::value)>
struct is_base_of
{
private:
@ -661,8 +611,10 @@ namespace etl
template<typename T> struct dummy {};
struct internal: TDerived, dummy<int>{};
static TBase* check(TBase*);
template<typename T> static char check(dummy<T>*);
static TBase* check(TBase*) { return (TBase*)0; }
template<typename T>
static char check(dummy<T>*) { return 0; }
public:
@ -1103,128 +1055,6 @@ namespace etl
#endif
#endif
#if !defined(ARDUINO) && ETL_NOT_USING_STLPORT && defined(ETL_GCC_V5_TYPE_TRAITS_SUPPORTED)
//***************************************************************************
/// is_trivially_constructible
///\ingroup type_traits
template <typename T> struct is_trivially_constructible : std::is_trivially_constructible<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_constructible_v = std::is_trivially_constructible_v<T>;
#endif
//***************************************************************************
/// is_trivially_copy_constructible
///\ingroup type_traits
template <typename T> struct is_trivially_copy_constructible : std::is_trivially_copy_constructible<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_copy_constructible_v = std::is_trivially_copy_constructible_v<T>;
#endif
//***************************************************************************
/// is_trivially_destructible
///\ingroup type_traits
template <typename T> struct is_trivially_destructible : std::is_trivially_destructible<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_destructible_v = std::is_trivially_destructible_v<T>;
#endif
//***************************************************************************
/// is_trivially_copy_assignable
///\ingroup type_traits
template <typename T> struct is_trivially_copy_assignable : std::is_trivially_copy_assignable<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_copy_assignable_v = std::is_trivially_copy_assignable_v<T>;
#endif
//***************************************************************************
/// is_trivially_copyable
///\ingroup type_traits
template <typename T> struct is_trivially_copyable : std::is_trivially_copyable<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_copyable_v = std::is_trivially_copyable_v<T>;
#endif
#else
//***************************************************************************
/// is_trivially_constructible
///\ingroup type_traits
#if ETL_CPP11_SUPPORTED && ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T> struct is_trivially_constructible : std::is_trivially_constructible<T> {};
#else
template <typename T> struct is_trivially_constructible : std::is_pod<T> {};
#endif
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_constructible_v = etl::is_trivially_constructible<T>::value;
#endif
//***************************************************************************
/// is_trivially_copy_constructible
///\ingroup type_traits
#if ETL_CPP11_SUPPORTED && ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T> struct is_trivially_copy_constructible : std::is_trivially_copy_constructible<T> {};
#else
template <typename T> struct is_trivially_copy_constructible : std::is_pod<T> {};
#endif
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_copy_constructible_v = etl::is_trivially_copy_constructible<T>::value;
#endif
//***************************************************************************
/// is_trivially_destructible
///\ingroup type_traits
#if ETL_CPP11_SUPPORTED && ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T> struct is_trivially_destructible : std::is_trivially_destructible<T> {};
#else
template <typename T> struct is_trivially_destructible : std::is_pod<T> {};
#endif
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_destructible_v = etl::is_trivially_destructible<T>::value;
#endif
//***************************************************************************
/// is_trivially_copy_assignable
///\ingroup type_traits
#if ETL_CPP11_SUPPORTED && ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T> struct is_trivially_copy_assignable : std::is_trivially_copy_assignable<T> {};
#else
template <typename T> struct is_trivially_copy_assignable : std::is_pod<T> {};
#endif
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_copy_assignable_v = etl::is_trivially_copy_assignable<T>::value;
#endif
//***************************************************************************
/// is_trivially_copyable
///\ingroup type_traits
#if ETL_CPP11_SUPPORTED && ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T> struct is_trivially_copyable : std::is_trivially_copyable<T> {};
#else
template <typename T> struct is_trivially_copyable : std::is_pod<T> {};
#endif
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_copyable_v = etl::is_trivially_copyable<T>::value;
#endif
#endif
//***************************************************************************
/// conditional
///\ingroup type_traits
@ -1681,68 +1511,224 @@ namespace etl
#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))
#if ETL_CPP11_SUPPORTED && ETL_USING_STL && !defined(ETL_USE_TYPE_TRAITS_BUILTINS) && !defined(ETL_USER_DEFINED_TYPE_TRAITS) && ((!defined(ARDUINO) && ETL_NOT_USING_STLPORT) || defined(ETL_GCC_V5_TYPE_TRAITS_SUPPORTED))
//*********************************************
// Use the STL's definitions.
//*********************************************
//*********************************************
// is_assignable
template<typename T1, typename T2>
struct is_assignable : public std::is_assignable<T1, T2>
{
};
//*********************************************
// is_constructible
template<typename T, typename... TArgs>
struct is_constructible : public std::is_constructible<T, TArgs...>
{
};
//*********************************************
// is_copy_constructible
template <typename T>
struct is_copy_constructible : public std::is_copy_constructible<T>
{
};
//*********************************************
// is_move_constructible
template <typename T>
struct is_move_constructible : public 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>
{
};
#else
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_constructible;
template <typename T>
struct is_trivially_constructible<T, true> : public etl::true_type
{
};
template <typename T>
struct is_trivially_constructible<T, false>;
#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>
{
};
#else
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_copy_constructible;
template <typename T>
struct is_trivially_copy_constructible<T, true> : public etl::true_type
{
};
template <typename T>
struct is_trivially_copy_constructible<T, false>;
#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>
{
};
#else
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_destructible;
template <typename T>
struct is_trivially_destructible<T, true> : public etl::true_type
{
};
template <typename T>
struct is_trivially_destructible<T, false>;
#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>
{
};
#else
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_copy_assignable;
template <typename T>
struct is_trivially_copy_assignable<T, true> : public etl::true_type
{
};
template <typename T>
struct is_trivially_copy_assignable<T, false>;
#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>
{
};
#else
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_copyable;
template <typename T>
struct is_trivially_copyable<T, true> : public etl::true_type
{
};
template <typename T>
struct is_trivially_copyable<T, false>;
#endif
#elif defined(ETL_USE_TYPE_TRAITS_BUILTINS)
//*********************************************
// Use the compiler's builtins.
//*********************************************
//*********************************************
// is_assignable
template<typename T1, typename T2>
struct is_assignable : public bool_constant<__is_assignable(T1, T2)>
struct is_assignable : public etl::bool_constant<__is_assignable(T1, T2)>
{
};
#if ETL_CPP11_SUPPORTED
//*********************************************
// is_constructible
template<typename T, typename... TArgs>
struct is_constructible : public bool_constant<__is_constructible(T, TArgs...)>
struct is_constructible : public etl::bool_constant<__is_constructible(T, TArgs...)>
{
};
#endif
//*********************************************
// is_copy_constructible
template <typename T>
struct is_copy_constructible : public etl::is_constructible<T, etl::add_lvalue_reference_t<const T>>
{
};
//*********************************************
// is_move_constructible
template <typename T>
struct is_move_constructible : public etl::is_constructible<T, T>
{
};
#else
//*********************************************
// is_trivially_constructible
template <typename T>
struct is_trivially_constructible : public etl::bool_constant<__is_trivially_constructible(T)>
{
};
//***************************************************************************
// is_trivially_copy_constructible
template <typename T>
struct is_trivially_copy_constructible : public etl::bool_constant<__is_trivially_copyable(T)>
{
};
//***************************************************************************
// is_trivially_destructible
template <typename T>
struct is_trivially_destructible : public etl::bool_constant<__is_trivially_destructible(T)>
{
};
//***************************************************************************
// is_trivially_copy_assignable
template <typename T>
struct is_trivially_copy_assignable : public etl::bool_constant<__is_trivially_copyable(T)>
{
};
//***************************************************************************
// is_trivially_copyable
template <typename T>
struct is_trivially_copyable : public etl::bool_constant<__is_trivially_copyable(T)>
{
};
#elif defined(ETL_USER_DEFINED_TYPE_TRAITS)
//*********************************************
// Force the user to provide specialisations for
// anything other than arithmetics and pointers.
//*********************************************
//*********************************************
// is_assignable
template <typename T1,
typename T2,
bool B = (etl::is_arithmetic<T1>::value || etl::is_pointer<T1>::value) && (etl::is_arithmetic<T2>::value || etl::is_pointer<T2>::value)>
struct is_assignable;
typename T2,
bool B = (etl::is_arithmetic<T1>::value || etl::is_pointer<T1>::value) && (etl::is_arithmetic<T2>::value || etl::is_pointer<T2>::value)>
struct is_assignable;
template <typename T1, typename T2>
struct is_assignable<T1, T2, true> : public etl::true_type
@ -1754,6 +1740,7 @@ namespace etl
#if ETL_CPP11_SUPPORTED
//*********************************************
// is_constructible
template <typename T, bool B, typename... TArgs>
struct is_constructible_helper;
@ -1772,6 +1759,7 @@ namespace etl
#endif
//*********************************************
// is_copy_constructible
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_copy_constructible;
@ -1784,6 +1772,7 @@ namespace etl
struct is_copy_constructible<T, false>;
//*********************************************
// is_move_constructible
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_move_constructible;
@ -1795,21 +1784,182 @@ namespace etl
template <typename T>
struct is_move_constructible<T, false>;
//*********************************************
// is_trivially_constructible
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_constructible;
template <typename T>
struct is_trivially_constructible<T, true> : public etl::true_type
{
};
template <typename T>
struct is_trivially_constructible<T, false>;
//***************************************************************************
// is_trivially_copy_constructible
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_copy_constructible;
template <typename T>
struct is_trivially_copy_constructible<T, true> : public etl::true_type
{
};
template <typename T>
struct is_trivially_copy_constructible<T, false>;
//***************************************************************************
// is_trivially_destructible
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_destructible;
template <typename T>
struct is_trivially_destructible<T, true> : public etl::true_type
{
};
template <typename T>
struct is_trivially_destructible<T, false>;
//***************************************************************************
// is_trivially_copy_assignable
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_copy_assignable;
template <typename T>
struct is_trivially_copy_assignable<T, true> : public etl::true_type
{
};
template <typename T>
struct is_trivially_copy_assignable<T, false>;
//***************************************************************************
// is_trivially_copyable
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_copyable;
template <typename T>
struct is_trivially_copyable<T, true> : public etl::true_type
{
};
template <typename T>
struct is_trivially_copyable<T, false>;
#else
//*********************************************
// Assume that anything other than arithmetics
// and pointers return false for the traits.
//*********************************************
//*********************************************
// is_assignable
template <typename T1, typename T2>
struct is_assignable : public etl::bool_constant<(etl::is_arithmetic<T1>::value || etl::is_pointer<T1>::value) && (etl::is_arithmetic<T2>::value || etl::is_pointer<T2>::value)>
{
};
#if ETL_CPP11_SUPPORTED
//*********************************************
// is_constructible
template <typename T, typename... TArgs>
struct is_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
#endif
//*********************************************
// is_copy_constructible
template <typename T>
struct is_copy_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
//*********************************************
// is_move_constructible
template <typename T>
struct is_move_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
//*********************************************
// is_trivially_constructible
template <typename T>
struct is_trivially_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
//***************************************************************************
// is_trivially_copy_constructible
template <typename T>
struct is_trivially_copy_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
//***************************************************************************
// is_trivially_destructible
template <typename T>
struct is_trivially_destructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
//***************************************************************************
// is_trivially_copy_assignable
template <typename T>
struct is_trivially_copy_assignable : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
//***************************************************************************
// is_trivially_copyable
template <typename T>
struct is_trivially_copyable : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
#endif
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>
{
};
#if ETL_CPP17_SUPPORTED
template <typename T1, typename T2>
inline constexpr size_t is_assignable_v = etl::is_assignable<T1, T2>::value;
inline constexpr bool is_assignable_v = etl::is_assignable<T1, T2>::value;
template <typename T1, typename T2>
inline constexpr bool 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;
inline constexpr bool 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;
inline constexpr bool 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;
inline constexpr bool is_move_constructible_v = etl::is_move_constructible<T>::value;
template <typename T>
inline constexpr bool is_trivially_constructible_v = etl::is_trivially_constructible<T>::value;
template <typename T>
inline constexpr bool is_trivially_copy_constructible_v = etl::is_trivially_copy_constructible<T>::value;
template <typename T>
inline constexpr bool is_trivially_destructible_v = etl::is_trivially_destructible<T>::value;
template <typename T>
inline constexpr bool is_trivially_copy_assignable_v = etl::is_trivially_copy_assignable<T>::value;
template <typename T>
inline constexpr bool is_trivially_copyable_v = etl::is_trivially_copyable<T>::value;
#endif
}

631
include/etl/type_traits.h
View File

@ -440,56 +440,6 @@ namespace etl
inline constexpr bool is_pod_v = etl::is_pod<T>::value;
#endif
//***************************************************************************
/// is_trivially_constructible
/// Only POD types are recognised.
template <typename T> struct is_trivially_constructible : etl::is_pod<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_constructible_v = etl::is_trivially_constructible<T>::value;
#endif
//***************************************************************************
/// is_trivially_copy_constructible
/// Only POD types are recognised.
template <typename T> struct is_trivially_copy_constructible : etl::is_pod<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_copy_constructible_v = etl::is_trivially_copy_constructible<T>::value;
#endif
//***************************************************************************
/// is_trivially_destructible
/// Only POD types are recognised.
template <typename T> struct is_trivially_destructible : etl::is_pod<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_destructible_v = etl::is_trivially_destructible<T>::value;
#endif
//***************************************************************************
/// is_trivially_copy_assignable
/// Only POD types are recognised.
template <typename T> struct is_trivially_copy_assignable : etl::is_pod<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_copy_assignable_v = etl::is_trivially_copy_assignable<T>::value;
#endif
//***************************************************************************
/// is_trivially_copyable
/// Only POD types are recognised.
template <typename T> struct is_trivially_copyable : etl::is_pod<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_copyable_v = etl::is_trivially_copyable<T>::value;
#endif
//***************************************************************************
/// conditional
template <bool B, typename T, typename F> struct conditional { typedef T type; };
@ -509,10 +459,10 @@ namespace etl
template <> struct make_signed<wchar_t>
{
typedef etl::conditional<sizeof(wchar_t) == sizeof(int16_t),
int16_t,
etl::conditional<sizeof(wchar_t) == sizeof(int32_t),
int32_t,
void>::type>::type type;
int16_t,
etl::conditional<sizeof(wchar_t) == sizeof(int32_t),
int32_t,
void>::type>::type type;
};
template <> struct make_signed<unsigned short> { typedef short type; };
@ -641,7 +591,7 @@ namespace etl
/// is_base_of
template<typename TBase,
typename TDerived,
const bool IsFundamental = (etl::is_fundamental<TBase>::value || etl::is_fundamental<TDerived>::value)>
const bool IsFundamental = (etl::is_fundamental<TBase>::value || etl::is_fundamental<TDerived>::value || etl::is_array<TDerived>::value)>
struct is_base_of
{
private:
@ -649,8 +599,10 @@ namespace etl
template<typename T> struct dummy {};
struct internal: TDerived, dummy<int>{};
static TBase* check(TBase*);
template<typename T> static char check(dummy<T>*);
static TBase* check(TBase*) { return (TBase*)0; }
template<typename T>
static char check(dummy<T>*) { return 0; }
public:
@ -1091,128 +1043,6 @@ namespace etl
#endif
#endif
#if !defined(ARDUINO) && ETL_NOT_USING_STLPORT && defined(ETL_GCC_V5_TYPE_TRAITS_SUPPORTED)
//***************************************************************************
/// is_trivially_constructible
///\ingroup type_traits
template <typename T> struct is_trivially_constructible : std::is_trivially_constructible<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_constructible_v = std::is_trivially_constructible_v<T>;
#endif
//***************************************************************************
/// is_trivially_copy_constructible
///\ingroup type_traits
template <typename T> struct is_trivially_copy_constructible : std::is_trivially_copy_constructible<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_copy_constructible_v = std::is_trivially_copy_constructible_v<T>;
#endif
//***************************************************************************
/// is_trivially_destructible
///\ingroup type_traits
template <typename T> struct is_trivially_destructible : std::is_trivially_destructible<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_destructible_v = std::is_trivially_destructible_v<T>;
#endif
//***************************************************************************
/// is_trivially_copy_assignable
///\ingroup type_traits
template <typename T> struct is_trivially_copy_assignable : std::is_trivially_copy_assignable<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_copy_assignable_v = std::is_trivially_copy_assignable_v<T>;
#endif
//***************************************************************************
/// is_trivially_copyable
///\ingroup type_traits
template <typename T> struct is_trivially_copyable : std::is_trivially_copyable<T> {};
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_copyable_v = std::is_trivially_copyable_v<T>;
#endif
#else
//***************************************************************************
/// is_trivially_constructible
///\ingroup type_traits
#if ETL_CPP11_SUPPORTED && ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T> struct is_trivially_constructible : std::is_trivially_constructible<T> {};
#else
template <typename T> struct is_trivially_constructible : std::is_pod<T> {};
#endif
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_constructible_v = etl::is_trivially_constructible<T>::value;
#endif
//***************************************************************************
/// is_trivially_copy_constructible
///\ingroup type_traits
#if ETL_CPP11_SUPPORTED && ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T> struct is_trivially_copy_constructible : std::is_trivially_copy_constructible<T> {};
#else
template <typename T> struct is_trivially_copy_constructible : std::is_pod<T> {};
#endif
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_copy_constructible_v = etl::is_trivially_copy_constructible<T>::value;
#endif
//***************************************************************************
/// is_trivially_destructible
///\ingroup type_traits
#if ETL_CPP11_SUPPORTED && ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T> struct is_trivially_destructible : std::is_trivially_destructible<T> {};
#else
template <typename T> struct is_trivially_destructible : std::is_pod<T> {};
#endif
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_destructible_v = etl::is_trivially_destructible<T>::value;
#endif
//***************************************************************************
/// is_trivially_copy_assignable
///\ingroup type_traits
#if ETL_CPP11_SUPPORTED && ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T> struct is_trivially_copy_assignable : std::is_trivially_copy_assignable<T> {};
#else
template <typename T> struct is_trivially_copy_assignable : std::is_pod<T> {};
#endif
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_copy_assignable_v = etl::is_trivially_copy_assignable<T>::value;
#endif
//***************************************************************************
/// is_trivially_copyable
///\ingroup type_traits
#if ETL_CPP11_SUPPORTED && ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T> struct is_trivially_copyable : std::is_trivially_copyable<T> {};
#else
template <typename T> struct is_trivially_copyable : std::is_pod<T> {};
#endif
#if ETL_CPP17_SUPPORTED
template <typename T>
inline constexpr bool is_trivially_copyable_v = etl::is_trivially_copyable<T>::value;
#endif
#endif
//***************************************************************************
/// conditional
///\ingroup type_traits
@ -1675,7 +1505,7 @@ namespace etl
#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))
#if ETL_CPP11_SUPPORTED && ETL_USING_STL && !defined(ETL_USE_TYPE_TRAITS_BUILTINS) && !defined(ETL_USER_DEFINED_TYPE_TRAITS) && ((!defined(ARDUINO) && ETL_NOT_USING_STLPORT) || defined(ETL_GCC_V5_TYPE_TRAITS_SUPPORTED))
//*********************************************
// Use the STL's definitions.
@ -1709,124 +1539,178 @@ namespace etl
{
};
// //*********************************************
// // is_trivially_constructible
//#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
// template <typename T>
// struct is_trivially_constructible : public std::is_trivially_constructible<T>
//#else
// template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
// struct is_trivially_constructible;
//
// template <typename T>
// struct is_trivially_constructible<T, true> : public etl::true_type
// {
// };
//
// template <typename T>
// struct is_trivially_constructible<T, false>;
//#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>
//#else
// template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
// struct is_trivially_copy_constructible;
//
// template <typename T>
// struct is_trivially_copy_constructible<T, true> : public etl::true_type
// {
// };
//
// template <typename T>
// struct is_trivially_copy_constructible<T, false>;
//#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>
//#else
// template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
// struct is_trivially_destructible;
//
// template <typename T>
// struct is_trivially_destructible<T, true> : public etl::true_type
// {
// };
//
// template <typename T>
// struct is_trivially_destructible<T, false>;
//#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>
//#else
// template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
// struct is_trivially_copy_assignable;
//
// template <typename T>
// struct is_trivially_copy_assignable<T, true> : public etl::true_type
// {
// };
//
// template <typename T>
// struct is_trivially_copy_assignable<T, false>;
//#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>
//#else
// template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
// struct is_trivially_copyable;
//
// template <typename T>
// struct is_trivially_copyable<T, true> : public etl::true_type
// {
// };
//
// template <typename T>
// struct is_trivially_copyable<T, false>;
//#endif
//*********************************************
// is_trivially_constructible
#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
template <typename T>
struct is_trivially_constructible : public std::is_trivially_constructible<T>
{
};
#else
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_constructible;
#elif defined(ETL_USE_TYPE_TRAITS_BUILTINS)
template <typename T>
struct is_trivially_constructible<T, true> : public etl::true_type
{
};
template <typename T>
struct is_trivially_constructible<T, false>;
#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>
{
};
#else
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_copy_constructible;
template <typename T>
struct is_trivially_copy_constructible<T, true> : public etl::true_type
{
};
template <typename T>
struct is_trivially_copy_constructible<T, false>;
#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>
{
};
#else
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_destructible;
template <typename T>
struct is_trivially_destructible<T, true> : public etl::true_type
{
};
template <typename T>
struct is_trivially_destructible<T, false>;
#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>
{
};
#else
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_copy_assignable;
template <typename T>
struct is_trivially_copy_assignable<T, true> : public etl::true_type
{
};
template <typename T>
struct is_trivially_copy_assignable<T, false>;
#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>
{
};
#else
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_copyable;
template <typename T>
struct is_trivially_copyable<T, true> : public etl::true_type
{
};
template <typename T>
struct is_trivially_copyable<T, false>;
#endif
#elif defined(ETL_USE_TYPE_TRAITS_BUILTINS) && !defined(ETL_USER_DEFINED_TYPE_TRAITS)
//*********************************************
// Use the compiler's builtins.
//*********************************************
//*********************************************
// is_assignable
template<typename T1, typename T2>
struct is_assignable : public bool_constant<__is_assignable(T1, T2)>
struct is_assignable : public etl::bool_constant<__is_assignable(T1, T2)>
{
};
#if ETL_CPP11_SUPPORTED
//*********************************************
// is_constructible
template<typename T, typename... TArgs>
struct is_constructible : public bool_constant<__is_constructible(T, TArgs...)>
struct is_constructible : public etl::bool_constant<__is_constructible(T, TArgs...)>
{
};
#endif
//*********************************************
// is_copy_constructible
template <typename T>
struct is_copy_constructible : public etl::is_constructible<T, etl::add_lvalue_reference_t<const T>>
{
};
//*********************************************
// is_move_constructible
template <typename T>
struct is_move_constructible : public etl::is_constructible<T, T>
{
};
#else
//*********************************************
// is_trivially_constructible
template <typename T>
struct is_trivially_constructible : public etl::bool_constant<__is_trivially_constructible(T)>
{
};
//***************************************************************************
// is_trivially_copy_constructible
template <typename T>
struct is_trivially_copy_constructible : public etl::bool_constant<__is_trivially_copyable(T)>
{
};
//***************************************************************************
// is_trivially_destructible
template <typename T>
struct is_trivially_destructible : public etl::bool_constant<__is_trivially_destructible(T)>
{
};
//***************************************************************************
// is_trivially_copy_assignable
template <typename T>
struct is_trivially_copy_assignable : public etl::bool_constant<__is_trivially_copyable(T)>
{
};
//***************************************************************************
// is_trivially_copyable
template <typename T>
struct is_trivially_copyable : public etl::bool_constant<__is_trivially_copyable(T)>
{
};
#elif defined(ETL_USER_DEFINED_TYPE_TRAITS) && !defined(ETL_USE_TYPE_TRAITS_BUILTINS)
//*********************************************
// Force the user to provide specialisations for
@ -1894,78 +1778,159 @@ namespace etl
template <typename T>
struct is_move_constructible<T, false>;
////*********************************************
//// is_trivially_constructible
//template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
//struct is_trivially_constructible;
//*********************************************
// is_trivially_constructible
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_constructible;
//template <typename T>
//struct is_trivially_constructible<T, true> : public etl::true_type
//{
//};
template <typename T>
struct is_trivially_constructible<T, true> : public etl::true_type
{
};
//template <typename T>
//struct is_trivially_constructible<T, false>;
template <typename T>
struct is_trivially_constructible<T, false>;
////***************************************************************************
//// is_trivially_copy_constructible
//template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
//struct is_trivially_copy_constructible;
//***************************************************************************
// is_trivially_copy_constructible
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_copy_constructible;
//template <typename T>
//struct is_trivially_copy_constructible<T, true> : public etl::true_type
//{
//};
template <typename T>
struct is_trivially_copy_constructible<T, true> : public etl::true_type
{
};
//template <typename T>
//struct is_trivially_copy_constructible<T, false>;
template <typename T>
struct is_trivially_copy_constructible<T, false>;
////***************************************************************************
//// is_trivially_destructible
//template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
//struct is_trivially_destructible;
//***************************************************************************
// is_trivially_destructible
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_destructible;
//template <typename T>
//struct is_trivially_destructible<T, true> : public etl::true_type
//{
//};
template <typename T>
struct is_trivially_destructible<T, true> : public etl::true_type
{
};
//template <typename T>
//struct is_trivially_destructible<T, false>;
template <typename T>
struct is_trivially_destructible<T, false>;
////***************************************************************************
//// is_trivially_copy_assignable
//template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
//struct is_trivially_copy_assignable;
//***************************************************************************
// is_trivially_copy_assignable
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_copy_assignable;
//template <typename T>
//struct is_trivially_copy_assignable<T, true> : public etl::true_type
//{
//};
template <typename T>
struct is_trivially_copy_assignable<T, true> : public etl::true_type
{
};
//template <typename T>
//struct is_trivially_copy_assignable<T, false>;
template <typename T>
struct is_trivially_copy_assignable<T, false>;
////***************************************************************************
//// is_trivially_copyable
//template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
//struct is_trivially_copyable;
//***************************************************************************
// is_trivially_copyable
template <typename T, bool B = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_copyable;
//template <typename T>
//struct is_trivially_copyable<T, true> : public etl::true_type
//{
//};
template <typename T>
struct is_trivially_copyable<T, true> : public etl::true_type
{
};
//template <typename T>
//struct is_trivially_copyable<T, false>;
template <typename T>
struct is_trivially_copyable<T, false>;
#else
//*********************************************
// Assume that anything other than arithmetics
// and pointers return false for the traits.
//*********************************************
//*********************************************
// is_assignable
template <typename T1, typename T2>
struct is_assignable : public etl::bool_constant<(etl::is_arithmetic<T1>::value || etl::is_pointer<T1>::value) && (etl::is_arithmetic<T2>::value || etl::is_pointer<T2>::value)>
{
};
#if ETL_CPP11_SUPPORTED
//*********************************************
// is_constructible
template <typename T, typename... TArgs>
struct is_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
#endif
//*********************************************
// is_copy_constructible
template <typename T>
struct is_copy_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
//*********************************************
// is_move_constructible
template <typename T>
struct is_move_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
//*********************************************
// is_trivially_constructible
template <typename T>
struct is_trivially_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
//***************************************************************************
// is_trivially_copy_constructible
template <typename T>
struct is_trivially_copy_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
//***************************************************************************
// is_trivially_destructible
template <typename T>
struct is_trivially_destructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
//***************************************************************************
// is_trivially_copy_assignable
template <typename T>
struct is_trivially_copy_assignable : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
//***************************************************************************
// is_trivially_copyable
template <typename T>
struct is_trivially_copyable : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
#endif
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>
{
};
#if ETL_CPP17_SUPPORTED
template <typename T1, typename T2>
inline constexpr bool is_assignable_v = etl::is_assignable<T1, T2>::value;
template <typename T1, typename T2>
inline constexpr bool is_lvalue_assignable_v = etl::is_lvalue_assignable<T1, T2>::value;
template<typename T, typename... TArgs>
inline constexpr bool is_constructible_v = etl::is_constructible<T, TArgs...>::value;
@ -1975,20 +1940,20 @@ namespace etl
template<typename T>
inline constexpr bool is_move_constructible_v = etl::is_move_constructible<T>::value;
//template <typename T>
//inline constexpr bool is_trivially_constructible_v = etl::is_trivially_constructible<T>::value;
template <typename T>
inline constexpr bool is_trivially_constructible_v = etl::is_trivially_constructible<T>::value;
//template <typename T>
//inline constexpr bool is_trivially_copy_constructible_v = etl::is_trivially_copy_constructible<T>::value;
template <typename T>
inline constexpr bool is_trivially_copy_constructible_v = etl::is_trivially_copy_constructible<T>::value;
//template <typename T>
//inline constexpr bool is_trivially_destructible_v = etl::is_trivially_destructible<T>::value;
template <typename T>
inline constexpr bool is_trivially_destructible_v = etl::is_trivially_destructible<T>::value;
//template <typename T>
//inline constexpr bool is_trivially_copy_assignable_v = etl::is_trivially_copy_assignable<T>::value;
template <typename T>
inline constexpr bool is_trivially_copy_assignable_v = etl::is_trivially_copy_assignable<T>::value;
//template <typename T>
//inline constexpr bool is_trivially_copyable_v = etl::is_trivially_copyable<T>::value;
template <typename T>
inline constexpr bool is_trivially_copyable_v = etl::is_trivially_copyable<T>::value;
#endif
}

3
support/Release notes.txt
View File

@ -2,8 +2,7 @@
20.14.0
Added a vaiadic version of etl::variant. Usable for C++11 and up.
Added etl::overload pattern class. Groups lambdas into a functor class.
Added etl::is_assignable, etl::is_lvalue_assignable, etl::is_constructible, etl::is_copy_constructible
and etl::is_move_constructible to type_traits.h. Uses STL, compiler built-ins or user defined specialisations, dependent on settings.
Refactored type_traits.h. Uses STL, compiler built-ins or user defined specialisations, dependent on settings.
Added etl::conditional_t to type_traits.h
Added etl::conjunction and etl::disjunction to type_traits.h
Added etl::integer_sequence to utility.h

4
test/etl_profile.h
View File

@ -78,10 +78,6 @@ SOFTWARE.
//#define ETL_MESSAGES_ARE_VIRTUAL
//#define ETL_POLYMORPHIC_MESSAGES
//#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

84
test/runsanitychecks.sh
View File

@ -23,6 +23,16 @@ 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 "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "GCC - No STL - Builtins"; } >> ../log.txt
g++ --version | head --lines=1 >> ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake --cmake-clean-cache -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON ..
cmake --build bgcc || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "GCC - No STL - User defined traits"; } >> ../log.txt
g++ --version | head --lines=1 >> ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake --cmake-clean-cache -DNO_STL=ON -DETL_USER_DEFINED_TYPE_TRAITS=ON ..
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 ..
@ -33,6 +43,16 @@ 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 "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "Clang - No STL - Builtins"; } >> ../log.txt
clang++ --version | head --lines=1 >> ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake --cmake-clean-cache -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON ..
cmake --build bclang || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "Clang - No STL - User defined traits"; } >> ../log.txt
clang++ --version | head --lines=1 >> ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake --cmake-clean-cache -DNO_STL=ON -DETL_USER_DEFINED_TYPE_TRAITS=ON ..
cmake --build bclang || echo "****************\n**** Failed ****\n****************" >> ../log.txt
###############################################################################
cd ../c++11 || exit 1
cmake -E make_directory bgcc bclang
@ -51,6 +71,16 @@ 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 "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "GCC - No STL - Builtins"; } >> ../log.txt
g++ --version | head --lines=1 >> ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake --cmake-clean-cache -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON ..
cmake --build bgcc || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "GCC - No STL - User defined traits"; } >> ../log.txt
g++ --version | head --lines=1 >> ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake --cmake-clean-cache -DNO_STL=ON -DETL_USER_DEFINED_TYPE_TRAITS=ON ..
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 ..
@ -61,6 +91,16 @@ 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 "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "Clang - No STL - Builtins"; } >> ../log.txt
clang++ --version | head --lines=1 >> ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake --cmake-clean-cache -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON ..
cmake --build bclang || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "Clang - No STL - User defined traits"; } >> ../log.txt
clang++ --version | head --lines=1 >> ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake --cmake-clean-cache -DNO_STL=ON -DETL_USER_DEFINED_TYPE_TRAITS=ON ..
cmake --build bclang || echo "****************\n**** Failed ****\n****************" >> ../log.txt
###############################################################################
cd ../c++14 || exit 1
cmake -E make_directory bgcc bclang
@ -69,7 +109,7 @@ echo "-----------------------------------------------"
echo " C++14"
echo "-----------------------------------------------"
echo " GCC - STL"; } >> ../log.txt
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 "****************\n**** Failed ****\n****************" >> ../log.txt
@ -79,6 +119,16 @@ 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 "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "GCC - No STL - Builtins"; } >> ../log.txt
g++ --version | head --lines=1 >> ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake --cmake-clean-cache -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON ..
cmake --build bgcc || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "GCC - No STL - User defined traits"; } >> ../log.txt
g++ --version | head --lines=1 >> ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake --cmake-clean-cache -DNO_STL=ON -DETL_USER_DEFINED_TYPE_TRAITS=ON ..
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 ..
@ -89,7 +139,17 @@ 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 "****************\n**** Failed ****\n****************" >> ../log.txt
###############################################################################
{ echo ""; echo "Clang - No STL - Builtins"; } >> ../log.txt
clang++ --version | head --lines=1 >> ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake --cmake-clean-cache -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON ..
cmake --build bclang || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "Clang - No STL - User defined traits"; } >> ../log.txt
clang++ --version | head --lines=1 >> ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake --cmake-clean-cache -DNO_STL=ON -DETL_USER_DEFINED_TYPE_TRAITS=ON ..
cmake --build bclang || echo "****************\n**** Failed ****\n****************" >> ../log.txt
###############################################################################
cd ../c++17 || exit 1
cmake -E make_directory bgcc bclang
{ echo ""
@ -107,6 +167,16 @@ 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 "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "GCC - No STL - Builtins"; } >> ../log.txt
g++ --version | head --lines=1 >> ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake --cmake-clean-cache -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON ..
cmake --build bgcc || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "GCC - No STL - User defined traits"; } >> ../log.txt
g++ --version | head --lines=1 >> ../log.txt
CC=gcc CXX=g++ cmake -E chdir bgcc cmake --cmake-clean-cache -DNO_STL=ON -DETL_USER_DEFINED_TYPE_TRAITS=ON ..
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 ..
@ -117,6 +187,16 @@ 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 "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "Clang - No STL - Builtins"; } >> ../log.txt
clang++ --version | head --lines=1 >> ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake --cmake-clean-cache -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON ..
cmake --build bclang || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""; echo "Clang - No STL - User defined traits"; } >> ../log.txt
clang++ --version | head --lines=1 >> ../log.txt
CC=clang CXX=clang++ cmake -E chdir bclang cmake --cmake-clean-cache -DNO_STL=ON -DETL_USER_DEFINED_TYPE_TRAITS=ON ..
cmake --build bclang || echo "****************\n**** Failed ****\n****************" >> ../log.txt
{ echo ""
echo "-----------------------------------------------"
echo " Completed"

12
test/runtests.sh
View File

@ -9,7 +9,7 @@ echo " GCC" >> log.txt
echo "-----------------------------------------------" >> log.txt
gcc --version | grep gcc >> log.txt
CC=gcc CXX=g++ cmake --cmake-clean-cache -DNO_STL=OFF ..
make -j8
make -j8 || echo "****************\n**** Failed ****\n****************" >> ../log.txt
./etl_tests | tee log.txt
echo ""
echo "-----------------------------------------------" >> log.txt
@ -17,7 +17,7 @@ echo " GCC - No STL" >> log.txt
echo "-----------------------------------------------" >> log.txt
gcc --version | grep gcc >> log.txt
CC=gcc CXX=g++ cmake --cmake-clean-cache -DNO_STL=ON ..
make -j8
make -j8 || echo "****************\n**** Failed ****\n****************" >> ../log.txt
./etl_tests | tee log.txt
echo ""
echo "-----------------------------------------------" >> log.txt
@ -25,7 +25,7 @@ echo " GCC - No STL - Builtins" >> log.txt
echo "-----------------------------------------------" >> log.txt
gcc --version | grep gcc >> log.txt
CC=gcc CXX=g++ cmake --cmake-clean-cache -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON ..
make -j8
make -j8 || echo "****************\n**** Failed ****\n****************" >> ../log.txt
./etl_tests | tee log.txt
echo ""
echo "-----------------------------------------------" >> log.txt
@ -33,7 +33,7 @@ echo " Clang" >> log.txt
echo "-----------------------------------------------" >> log.txt
clang --version | grep clang >> log.txt
CC=clang CXX=clang++ cmake --cmake-clean-cache -DNO_STL=OFF ..
make -j8
make -j8 || echo "****************\n**** Failed ****\n****************" >> ../log.txt
./etl_tests | tee log.txt
echo ""
echo "-----------------------------------------------" >> log.txt
@ -41,7 +41,7 @@ echo " Clang - No STL" >> log.txt
echo "-----------------------------------------------" >> log.txt
clang --version | grep clang >> log.txt
CC=clang CXX=clang++ cmake --cmake-clean-cache -DNO_STL=ON ..
make -j8
make -j8 || echo "****************\n**** Failed ****\n****************" >> ../log.txt
./etl_tests | tee log.txt
echo ""
echo "-----------------------------------------------" >> log.txt
@ -49,7 +49,7 @@ echo " Clang - No STL - Builtins" >> log.txt
echo "-----------------------------------------------" >> log.txt
clang --version | grep clang >> log.txt
CC=clang CXX=clang++ cmake --cmake-clean-cache -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON ..
make -j8
make -j8 || echo "****************\n**** Failed ****\n****************" >> ../log.txt
./etl_tests | tee log.txt
echo ""
echo "-----------------------------------------------" >> log.txt

21
test/test_pool.cpp
View File

@ -448,6 +448,27 @@ namespace
int* i = pool.allocate();
pool.release(i);
}
//*************************************************************************
TEST(test_issue_406_pool_of_c_array)
{
using elem_type = uint8_t[10];
etl::pool<elem_type, 3> memPool{};
CHECK_EQUAL(3, memPool.available());
CHECK_EQUAL(0, memPool.size());
elem_type* memory = memPool.allocate();
CHECK_EQUAL(2, memPool.available());
CHECK_EQUAL(1, memPool.size());
memPool.release(memory);
CHECK_EQUAL(3, memPool.available());
CHECK_EQUAL(0, memPool.size());
}
}

160
test/test_type_traits.cpp
View File

@ -98,67 +98,67 @@ using etl::is_copy_constructible;
using etl::is_move_constructible;
//*************************
template <>
struct etl::is_assignable<Copyable, Copyable> : public etl::true_type
{
};
template <>
struct etl::is_assignable<Copyable, Copyable> : public etl::true_type
{
};
template <>
struct etl::is_constructible<Copyable> : public etl::true_type
{
};
template <>
struct etl::is_constructible<Copyable> : public etl::true_type
{
};
template <>
struct etl::is_copy_constructible<Copyable> : public etl::true_type
{
};
template <>
struct etl::is_copy_constructible<Copyable> : public etl::true_type
{
};
template <>
struct etl::is_move_constructible<Copyable> : public etl::false_type
{
};
template <>
struct etl::is_move_constructible<Copyable> : public etl::false_type
{
};
//*************************
template <>
struct etl::is_assignable<Moveable, Moveable> : public etl::true_type
{
};
//*************************
template <>
struct etl::is_assignable<Moveable, Moveable> : public etl::true_type
{
};
template <>
struct etl::is_constructible<Moveable> : public etl::true_type
{
};
template <>
struct etl::is_constructible<Moveable> : public etl::true_type
{
};
template <>
struct etl::is_copy_constructible<Moveable> : public etl::false_type
{
};
template <>
struct etl::is_copy_constructible<Moveable> : public etl::false_type
{
};
template <>
struct etl::is_move_constructible<Moveable> : public etl::true_type
{
};
template <>
struct etl::is_move_constructible<Moveable> : public etl::true_type
{
};
//*************************
template <>
struct etl::is_assignable<MoveableCopyable, MoveableCopyable> : public etl::true_type
{
};
//*************************
template <>
struct etl::is_assignable<MoveableCopyable, MoveableCopyable> : public etl::true_type
{
};
template <>
struct etl::is_constructible<MoveableCopyable> : public etl::true_type
{
};
template <>
struct etl::is_constructible<MoveableCopyable> : public etl::true_type
{
};
template <>
struct etl::is_copy_constructible<MoveableCopyable, false> : public etl::true_type
{
};
template <>
struct etl::is_copy_constructible<MoveableCopyable> : public etl::true_type
{
};
template <>
struct etl::is_move_constructible<MoveableCopyable> : public etl::true_type
{
};
template <>
struct etl::is_move_constructible<MoveableCopyable> : public etl::true_type
{
};
#endif
namespace
@ -1001,6 +1001,16 @@ namespace
CHECK((etl::is_assignable_v<MoveableCopyable, MoveableCopyable>) == (std::is_assignable_v<MoveableCopyable, MoveableCopyable>));
}
//*************************************************************************
TEST(test_is_lvalue_assignable)
{
#if ETL_USING_STL || defined(ETL_USE_TYPE_TRAITS_BUILTINS) || defined(ETL_USER_DEFINED_TYPE_TRAITS)
CHECK((etl::is_lvalue_assignable_v<Copyable, Copyable>));
CHECK(!(etl::is_lvalue_assignable_v<Moveable, Moveable>));
CHECK((etl::is_lvalue_assignable_v<MoveableCopyable, MoveableCopyable>));
#endif
}
//*************************************************************************
TEST(test_is_constructible)
{
@ -1024,4 +1034,54 @@ namespace
CHECK((etl::is_move_constructible_v<Moveable>) == (std::is_move_constructible_v<Moveable>));
CHECK((etl::is_move_constructible_v<MoveableCopyable>) == (std::is_move_constructible_v<MoveableCopyable>));
}
//*************************************************************************
TEST(test_is_trivially_constructible)
{
#if ETL_USING_STL || defined(ETL_USE_TYPE_TRAITS_BUILTINS) || defined(ETL_USER_DEFINED_TYPE_TRAITS)
CHECK((etl::is_trivially_constructible_v<Copyable>) == (std::is_trivially_constructible_v<Copyable>));
CHECK((etl::is_trivially_constructible_v<Moveable>) == (std::is_trivially_constructible_v<Moveable>));
CHECK((etl::is_trivially_constructible_v<MoveableCopyable>) == (std::is_trivially_constructible_v<MoveableCopyable>));
#endif
}
//*************************************************************************
TEST(test_is_trivially_copy_constructible)
{
#if ETL_USING_STL || defined(ETL_USE_TYPE_TRAITS_BUILTINS) || defined(ETL_USER_DEFINED_TYPE_TRAITS)
CHECK((etl::is_trivially_copy_constructible_v<Copyable>) == (std::is_trivially_copy_constructible_v<Copyable>));
CHECK((etl::is_trivially_copy_constructible_v<Moveable>) == (std::is_trivially_copy_constructible_v<Moveable>));
CHECK((etl::is_trivially_copy_constructible_v<MoveableCopyable>) == (std::is_trivially_copy_constructible_v<MoveableCopyable>));
#endif
}
//*************************************************************************
TEST(test_is_trivially_destructible)
{
#if ETL_USING_STL || defined(ETL_USE_TYPE_TRAITS_BUILTINS) || defined(ETL_USER_DEFINED_TYPE_TRAITS)
CHECK((etl::is_trivially_destructible_v<Copyable>) == (std::is_trivially_destructible_v<Copyable>));
CHECK((etl::is_trivially_destructible_v<Moveable>) == (std::is_trivially_destructible_v<Moveable>));
CHECK((etl::is_trivially_destructible_v<MoveableCopyable>) == (std::is_trivially_destructible_v<MoveableCopyable>));
#endif
}
//*************************************************************************
TEST(test_is_trivially_copy_assignable)
{
#if ETL_USING_STL || defined(ETL_USE_TYPE_TRAITS_BUILTINS) || defined(ETL_USER_DEFINED_TYPE_TRAITS)
CHECK((etl::is_trivially_copy_assignable_v<Copyable>) == (std::is_trivially_copy_assignable_v<Copyable>));
CHECK((etl::is_trivially_copy_assignable_v<Moveable>) == (std::is_trivially_copy_assignable_v<Moveable>));
CHECK((etl::is_trivially_copy_assignable_v<MoveableCopyable>) == (std::is_trivially_copy_assignable_v<MoveableCopyable>));
#endif
}
//*************************************************************************
TEST(test_is_trivially_copyable)
{
#if ETL_USING_STL || defined(ETL_USE_TYPE_TRAITS_BUILTINS) || defined(ETL_USER_DEFINED_TYPE_TRAITS)
CHECK((etl::is_trivially_copyable_v<Copyable>) == (std::is_trivially_copyable_v<Copyable>));
CHECK((etl::is_trivially_copyable_v<Moveable>) == (std::is_trivially_copyable_v<Moveable>));
CHECK((etl::is_trivially_copyable_v<MoveableCopyable>) == (std::is_trivially_copyable_v<MoveableCopyable>));
#endif
}
}

2
test/test_variant_new.cpp
View File

@ -375,7 +375,7 @@ struct etl::is_move_constructible<Moveable> : public etl::true_type
//*************************
template <>
struct etl::is_copy_constructible<MoveableCopyable, false> : public etl::true_type
struct etl::is_copy_constructible<MoveableCopyable> : public etl::true_type
{
};

14
test/vs2019/etl.sln
View File

@ -11,6 +11,8 @@ Global
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 - Builtins|Win32 = Debug MSVC - No STL - Builtins|Win32
Debug MSVC - No STL - Builtins|x64 = Debug MSVC - No STL - Builtins|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
@ -27,6 +29,8 @@ Global
Debug MSVC No Checks|x64 = Debug MSVC No Checks|x64
Debug MSVC|Win32 = Debug MSVC|Win32
Debug MSVC|x64 = Debug MSVC|x64
Debug LLVM - No STL - Builtins|Win32 = Debug LLVM - No STL - Builtins|Win32
Debug LLVM - No STL - Builtins|x64 = Debug LLVM - No STL - Builtins|x64
LLVM New|Win32 = LLVM New|Win32
LLVM New|x64 = LLVM New|x64
MSVCDebugAppveyor|Win32 = MSVCDebugAppveyor|Win32
@ -45,6 +49,10 @@ Global
{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 - Builtins|Win32.ActiveCfg = Debug|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - No STL - Builtins|Win32.Build.0 = Debug|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - No STL - Builtins|x64.ActiveCfg = Debug-MSVC-No-STL-Builtins|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC - No STL - Builtins|x64.Build.0 = Debug-MSVC-No-STL-Builtins|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
@ -60,7 +68,7 @@ Global
{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 - Small Strings|x64.Build.0 = DebugMSVCSmallStrings|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
@ -77,6 +85,10 @@ Global
{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}.Debug LLVM - No STL - Builtins|Win32.ActiveCfg = Debug-LLVM-NoSTL-Builtins|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug LLVM - No STL - Builtins|Win32.Build.0 = Debug-LLVM-NoSTL-Builtins|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug LLVM - No STL - Builtins|x64.ActiveCfg = Debug-LLVM-NoSTL-Builtins|x64
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug LLVM - No STL - Builtins|x64.Build.0 = Debug-LLVM-NoSTL-Builtins|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

4408
test/vs2019/etl.vcxproj
View File

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff