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

Removed warning from compilation

Browse Source
This commit is contained in:
John Wellbelove 2021-10-01 18:39:10 +01:00
parent f987d2a287
commit c691991538
33 changed files with 249 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.gitignore vendored
View File

@ -325,3 +325,8 @@ test/vs2019/Test2
test/vs2019/Debug MSVC - Force C++03
test/vs2019/Debug LLVM - No STL
test/vs2019/Debug - No STL
test/meson-info
test/meson-logs
test/meson-private
test/build-make
test/build-ninja

2
include/etl/basic_string.h
View File

@ -2338,7 +2338,7 @@ namespace etl
//*************************************************************************
/// Destructor.
//*************************************************************************
#if defined(ETL_POLYMORPHIC_STRINGS) || defined(ETL_POLYMORPHIC_CONTAINERS)
#if defined(ETL_POLYMORPHIC_STRINGS) || defined(ETL_POLYMORPHIC_CONTAINERS) || defined(ETL_ISTRING_REPAIR_ENABLE)
public:
virtual
#else

10
include/etl/cyclic_value.h
View File

@ -83,6 +83,16 @@ namespace etl
{
}
//*************************************************************************
/// Assignment operator.
//*************************************************************************
cyclic_value& operator =(const cyclic_value<T, FIRST, LAST>& other)
{
value = other.value;
return *this;
}
//*************************************************************************
/// Sets the value.
///\param value The value.

6
include/etl/deque.h
View File

@ -2272,7 +2272,7 @@ namespace etl
//*************************************************************************
/// Destructor.
//*************************************************************************
#if defined(ETL_POLYMORPHIC_DEQUE) || defined(ETL_POLYMORPHIC_CONTAINERS)
#if defined(ETL_POLYMORPHIC_DEQUE) || defined(ETL_POLYMORPHIC_CONTAINERS) || defined(ETL_IDEQUE_REPAIR_ENABLE)
public:
virtual ~ideque()
{
@ -2430,11 +2430,11 @@ namespace etl
//*************************************************************************
/// Fix the internal pointers after a low level memory copy.
//*************************************************************************
#ifdef ETL_ISTRING_REPAIR_ENABLE
#ifdef ETL_IDEQUE_REPAIR_ENABLE
virtual
#endif
void repair()
#ifdef ETL_ISTRING_REPAIR_ENABLE
#ifdef ETL_IDEQUE_REPAIR_ENABLE
ETL_OVERRIDE
#endif
{

8
include/etl/fixed_iterator.h
View File

@ -65,6 +65,14 @@ namespace etl
{
}
//***************************************************************************
/// Copy constructor
//***************************************************************************
fixed_iterator(const fixed_iterator& other)
: it(other.it)
{
}
//***************************************************************************
/// Increment (Does nothing).
//***************************************************************************

2
include/etl/fsm.h
View File

@ -254,7 +254,7 @@ namespace etl
//*******************************************
/// Destructor.
//*******************************************
~ifsm_state()
virtual ~ifsm_state()
{
}

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

@ -280,7 +280,7 @@ namespace etl
//*******************************************
/// Destructor.
//*******************************************
~ifsm_state()
virtual ~ifsm_state()
{
}

7
include/etl/generators/message_router_generator.h
View File

@ -122,8 +122,8 @@ namespace etl
public:
virtual ~imessage_router() {}
virtual void receive(const etl::imessage& message) = 0;
virtual bool accepts(etl::message_id_t id) const = 0;
virtual void receive(const etl::imessage&) = 0;
virtual bool accepts(etl::message_id_t) const = 0;
virtual bool is_null_router() const = 0;
virtual bool is_producer() const = 0;
virtual bool is_consumer() const = 0;
@ -180,7 +180,8 @@ namespace etl
}
imessage_router(etl::message_router_id_t id_, imessage_router& successor_)
: message_router_id(id_)
: successor(successor_)
, message_router_id(id_)
{
}

8
include/etl/instance_count.h
View File

@ -65,6 +65,14 @@ namespace etl
++how_many();
}
//*************************************************************************
/// Assignment operator.
//*************************************************************************
instance_count& operator =(const instance_count&)
{
return *this;
}
//*************************************************************************
/// Destruct and subtract 1.
//*************************************************************************

2
include/etl/memory.h
View File

@ -58,7 +58,7 @@ namespace etl
///\ingroup memory
//*****************************************************************************
template <typename T>
T* addressof(T& t)
ETL_CONSTEXPR T* addressof(T& t)
{
#if ETL_CPP11_SUPPORTED && ETL_USING_STL
return std::addressof(t);

21
include/etl/message_bus.h
View File

@ -430,27 +430,6 @@ namespace etl
{
bus.receive(id, message);
}
//***************************************************************************
/// Send a message to a bus.
//***************************************************************************
inline static void send_message(etl::imessage_router& source,
etl::imessage_bus& bus,
const etl::imessage& message)
{
bus.receive(message);
}
//***************************************************************************
/// Send a message to a bus.
//***************************************************************************
inline static void send_message(etl::imessage_router& source,
etl::imessage_bus& bus,
etl::message_router_id_t id,
const etl::imessage& message)
{
bus.receive(id, message);
}
}
#endif

22
include/etl/message_router.h
View File

@ -110,8 +110,8 @@ namespace etl
public:
virtual ~imessage_router() {}
virtual void receive(const etl::imessage& message) = 0;
virtual bool accepts(etl::message_id_t id) const = 0;
virtual void receive(const etl::imessage&) = 0;
virtual bool accepts(etl::message_id_t) const = 0;
virtual bool is_null_router() const = 0;
virtual bool is_producer() const = 0;
virtual bool is_consumer() const = 0;
@ -168,7 +168,8 @@ namespace etl
}
imessage_router(etl::message_router_id_t id_, imessage_router& successor_)
: message_router_id(id_)
: successor(successor_)
, message_router_id(id_)
{
}
@ -680,7 +681,6 @@ namespace etl
}
}
//**********************************************
using imessage_router::accepts;
@ -815,7 +815,6 @@ namespace etl
}
}
//**********************************************
using imessage_router::accepts;
@ -949,7 +948,6 @@ namespace etl
}
}
//**********************************************
using imessage_router::accepts;
@ -1080,7 +1078,6 @@ namespace etl
}
}
//**********************************************
using imessage_router::accepts;
@ -1210,7 +1207,6 @@ namespace etl
}
}
//**********************************************
using imessage_router::accepts;
@ -1339,7 +1335,6 @@ namespace etl
}
}
//**********************************************
using imessage_router::accepts;
@ -1467,7 +1462,6 @@ namespace etl
}
}
//**********************************************
using imessage_router::accepts;
@ -1592,7 +1586,6 @@ namespace etl
}
}
//**********************************************
using imessage_router::accepts;
@ -1716,7 +1709,6 @@ namespace etl
}
}
//**********************************************
using imessage_router::accepts;
@ -1838,7 +1830,6 @@ namespace etl
}
}
//**********************************************
using imessage_router::accepts;
@ -1959,7 +1950,6 @@ namespace etl
}
}
//**********************************************
using imessage_router::accepts;
@ -2077,7 +2067,6 @@ namespace etl
}
}
//**********************************************
using imessage_router::accepts;
@ -2194,7 +2183,6 @@ namespace etl
}
}
//**********************************************
using imessage_router::accepts;
@ -2310,7 +2298,6 @@ namespace etl
}
}
//**********************************************
using imessage_router::accepts;
@ -2425,7 +2412,6 @@ namespace etl
}
}
//**********************************************
using imessage_router::accepts;

28
include/etl/priority_queue.h
View File

@ -363,6 +363,34 @@ namespace etl
container.clear();
}
//*************************************************************************
/// Assignment operator.
//*************************************************************************
ipriority_queue& operator = (const ipriority_queue& rhs)
{
if (&rhs != this)
{
clone(rhs);
}
return *this;
}
#if ETL_CPP11_SUPPORTED
//*************************************************************************
/// Move assignment operator.
//*************************************************************************
ipriority_queue& operator = (ipriority_queue&& rhs)
{
if (&rhs != this)
{
move(etl::move(rhs));
}
return *this;
}
#endif
protected:
//*************************************************************************

32
include/etl/private/variant_legacy.h
View File

@ -212,6 +212,10 @@ namespace etl
friend class variant;
virtual ~reader_type()
{
}
virtual void read(typename etl::parameter_type<R1>::type value) = 0;
virtual void read(typename etl::parameter_type<R2>::type value) = 0;
virtual void read(typename etl::parameter_type<R3>::type value) = 0;
@ -232,6 +236,10 @@ namespace etl
friend class variant;
virtual ~reader_type()
{
}
virtual void read(typename etl::parameter_type<R1>::type value) = 0;
virtual void read(typename etl::parameter_type<R2>::type value) = 0;
virtual void read(typename etl::parameter_type<R3>::type value) = 0;
@ -255,6 +263,10 @@ namespace etl
friend class variant;
virtual ~reader_type()
{
}
virtual void read(typename etl::parameter_type<R1>::type value) = 0;
virtual void read(typename etl::parameter_type<R2>::type value) = 0;
virtual void read(typename etl::parameter_type<R3>::type value) = 0;
@ -278,6 +290,10 @@ namespace etl
friend class variant;
virtual ~reader_type()
{
}
virtual void read(typename etl::parameter_type<R1>::type value) = 0;
virtual void read(typename etl::parameter_type<R2>::type value) = 0;
virtual void read(typename etl::parameter_type<R3>::type value) = 0;
@ -301,6 +317,10 @@ namespace etl
friend class variant;
virtual ~reader_type()
{
}
virtual void read(typename etl::parameter_type<R1>::type value) = 0;
virtual void read(typename etl::parameter_type<R2>::type value) = 0;
virtual void read(typename etl::parameter_type<R3>::type value) = 0;
@ -324,6 +344,10 @@ namespace etl
friend class variant;
virtual ~reader_type()
{
}
virtual void read(typename etl::parameter_type<R1>::type value) = 0;
virtual void read(typename etl::parameter_type<R2>::type value) = 0;
virtual void read(typename etl::parameter_type<R3>::type value) = 0;
@ -347,6 +371,10 @@ namespace etl
friend class variant;
virtual ~reader_type()
{
}
virtual void read(typename etl::parameter_type<R1>::type value) = 0;
virtual void read(typename etl::parameter_type<R2>::type value) = 0;
@ -370,6 +398,10 @@ namespace etl
friend class variant;
virtual ~reader_type()
{
}
virtual void read(typename etl::parameter_type<R1>::type value) = 0;
private:

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

@ -170,7 +170,7 @@ namespace etl
template <>
struct operation_type<void, Non_Copyable, Non_Moveable>
{
static void do_operation(int operation, char* pstorage, const char* pvalue)
static void do_operation(int , char* , const char* )
{
// This should never occur.
#if defined(ETL_IN_UNIT_TEST)

8
include/etl/private/vector_base.h
View File

@ -155,9 +155,17 @@ namespace etl
//*************************************************************************
/// Destructor.
//*************************************************************************
#if defined(ETL_POLYMORPHIC_VECTOR) || defined(ETL_POLYMORPHIC_CONTAINERS) || defined(ETL_IVECTOR_REPAIR_ENABLE)
public:
virtual ~vector_base()
{
}
#else
protected:
~vector_base()
{
}
#endif
const size_type CAPACITY; ///<The maximum number of elements in the vector.
ETL_DECLARE_DEBUG_COUNT ///< Internal debugging.

17
include/etl/vector.h
View File

@ -1040,22 +1040,7 @@ namespace etl
}
// Disable copy construction.
ivector(const ivector&);
//*************************************************************************
/// Destructor.
//*************************************************************************
#if defined(ETL_POLYMORPHIC_VECTOR) || defined(ETL_POLYMORPHIC_CONTAINERS)
public:
virtual ~ivector()
{
}
#else
protected:
~ivector()
{
}
#endif
ivector(const ivector&) ETL_DELETE;
};
//***************************************************************************

10
meson.build
View File

@ -179,17 +179,19 @@ unittestcpp_dep = dependency('UnitTest++',
disabler: true,
)
threads_dep = dependency('threads')
etl_unit_tests = executable('etl_unit_tests',
include_directories: [
include_directories('test'),
include_directories: [
include_directories('test'),
# Included here instead of with the dependency so we can see
# header-induced warnings when building the tests
include_directories('include')
],
sources: etl_test_sources,
dependencies: unittestcpp_dep,
dependencies: [unittestcpp_dep, threads_dep],
cpp_args: [
'-fexceptions',
'-fexceptions',
'-DENABLE_ETL_UNIT_TESTS',
'-DETL_DEBUG',
],

3
test/data.h
View File

@ -123,6 +123,9 @@ public:
{
}
TestDataNDC(const TestDataNDC&) = default;
TestDataNDC& operator =(const TestDataNDC&) = default;
bool operator < (const TestDataNDC& other) const
{
return value < other.value;

3
test/runtests.sh
View File

@ -1,6 +1,7 @@
#!/bin/sh
#sudo ntpdate ntp.ubuntu.com
cd build || exit 1
mkdir -p build-make || exit 1
cd build-make || exit 1
echo "ETL Tests" > log.txt

33
test/test_delegate.cpp
View File

@ -127,15 +127,6 @@ namespace
return i + j + 1;
}
//*****************************************************************************
// The alternative function returning void.
//*****************************************************************************
void alternative_returning_void(int i, int j)
{
function_called = true;
parameter_correct = (i == VALUE1) && (j == VALUE2);
}
//*****************************************************************************
// The test class with member functions.
//*****************************************************************************
@ -222,20 +213,20 @@ namespace
const Test const_test_static;
}
//*****************************************************************************
// Initialises the test results.
//*****************************************************************************
struct SetupFixture
{
SetupFixture()
{
function_called = false;
parameter_correct = false;
}
};
namespace
{
//*****************************************************************************
// Initialises the test results.
//*****************************************************************************
struct SetupFixture
{
SetupFixture()
{
function_called = false;
parameter_correct = false;
}
};
SUITE(test_delegate)
{
//*************************************************************************

24
test/test_flat_map.cpp
View File

@ -193,21 +193,21 @@ namespace
return true;
}
//*************************************************************************
std::ostream& operator <<(std::ostream& os, const DataNDC::iterator& itr)
{
os << itr->first;
////*************************************************************************
//std::ostream& operator <<(std::ostream& os, const DataNDC::iterator& itr)
//{
// os << itr->first;
return os;
}
// return os;
//}
//*************************************************************************
std::ostream& operator <<(std::ostream& os, const DataNDC::const_iterator& itr)
{
os << itr->first;
////*************************************************************************
//std::ostream& operator <<(std::ostream& os, const DataNDC::const_iterator& itr)
//{
// os << itr->first;
return os;
}
// return os;
//}
SUITE(test_flat_map)
{

64
test/test_flat_set.cpp
View File

@ -144,45 +144,45 @@ namespace
std::string d;
};
bool operator == (const D1& lhs, const D1& rhs)
{
return (lhs.a == rhs.a);
}
//bool operator == (const D1& lhs, const D1& rhs)
//{
// return (lhs.a == rhs.a);
//}
bool operator == (const D2& lhs, const D2& rhs)
{
return (lhs.a == rhs.a) && (lhs.b == rhs.b);
}
//bool operator == (const D2& lhs, const D2& rhs)
//{
// return (lhs.a == rhs.a) && (lhs.b == rhs.b);
//}
bool operator == (const D3& lhs, const D3& rhs)
{
return (lhs.a == rhs.a) && (lhs.b == rhs.b) && (lhs.c == rhs.c);
}
//bool operator == (const D3& lhs, const D3& rhs)
//{
// return (lhs.a == rhs.a) && (lhs.b == rhs.b) && (lhs.c == rhs.c);
//}
bool operator == (const D4& lhs, const D4& rhs)
{
return (lhs.a == rhs.a) && (lhs.b == rhs.b) && (lhs.c == rhs.c) && (lhs.d == rhs.d);
}
//bool operator == (const D4& lhs, const D4& rhs)
//{
// return (lhs.a == rhs.a) && (lhs.b == rhs.b) && (lhs.c == rhs.c) && (lhs.d == rhs.d);
//}
bool operator != (const D1& lhs, const D1& rhs)
{
return !(lhs == rhs);
}
//bool operator != (const D1& lhs, const D1& rhs)
//{
// return !(lhs == rhs);
//}
bool operator != (const D2& lhs, const D2& rhs)
{
return !(lhs == rhs);
}
//bool operator != (const D2& lhs, const D2& rhs)
//{
// return !(lhs == rhs);
//}
bool operator != (const D3& lhs, const D3& rhs)
{
return !(lhs == rhs);
}
//bool operator != (const D3& lhs, const D3& rhs)
//{
// return !(lhs == rhs);
//}
bool operator != (const D4& lhs, const D4& rhs)
{
return !(lhs == rhs);
}
//bool operator != (const D4& lhs, const D4& rhs)
//{
// return !(lhs == rhs);
//}
bool operator < (const D1& lhs, const D1& rhs)
{

2
test/test_hfsm.cpp
View File

@ -284,7 +284,7 @@ namespace
public:
//***********************************
etl::fsm_state_id_t on_event(const EStop& event)
etl::fsm_state_id_t on_event(const EStop&)
{
++get_fsm_context().stopCount;

10
test/test_mem_cast_ptr.cpp
View File

@ -324,16 +324,20 @@ namespace
TEST(test_mem_cast_to_type_no_buffer)
{
MemCast memCast;
char c = 0;
CHECK_THROW(char c = memCast.ref<char>(), etl::mem_cast_nullptr_exception);
CHECK_THROW(c = memCast.ref<char>(), etl::mem_cast_nullptr_exception);
CHECK(c == 0);
}
//*************************************************************************
TEST(test_const_mem_cast_to_type_no_buffer)
{
const MemCast memCast;
CHECK_THROW(char c = memCast.ref<char>(), etl::mem_cast_nullptr_exception);
char c = 0;
CHECK_THROW(c = memCast.ref<char>(), etl::mem_cast_nullptr_exception);
CHECK(c == 0);
}
};
}

2
test/test_memory.cpp
View File

@ -90,7 +90,7 @@ namespace
{
}
void operator()(T* p) const
void operator()(T*) const
{
}
};

2
test/test_message_bus.cpp
View File

@ -211,7 +211,7 @@ namespace
++message5_count;
}
void on_receive_unknown(const etl::imessage& msg)
void on_receive_unknown(const etl::imessage&)
{
++message_unknown_count;
//etl::send_message(msg.callback, response);

19
test/test_message_router.cpp
View File

@ -57,6 +57,7 @@ namespace
//***********************************
struct NotInterface
{
virtual ~NotInterface() {}
virtual int VirtualFunction() const = 0;
};
@ -210,6 +211,18 @@ namespace
}
Router2(etl::imessage_router& successor_)
: message_router(ROUTER2, successor_),
message1_count(0),
message2_count(0),
message4_count(0),
message_unknown_count(0),
callback_count(0),
sender_id(0)
{
}
void on_receive(const Message1& msg)
{
++message1_count;
@ -232,7 +245,7 @@ namespace
etl::send_message(msg.callback, message5);
}
void on_receive(const Message5& msg)
void on_receive(const Message5&)
{
++callback_count;
}
@ -580,7 +593,7 @@ namespace
TEST(message_router_successor)
{
Router1 r1;
Router2 r2;
Router2 r2(r1);
etl::null_message_router null_router;
@ -589,8 +602,6 @@ namespace
Message3 message3(r2);
Message4 message4(r2);
r2.set_successor(r1);
etl::send_message(r2, message1);
CHECK_EQUAL(1, r2.message1_count);
CHECK_EQUAL(0, r2.message2_count);

24
test/test_type_traits.cpp
View File

@ -60,32 +60,32 @@ namespace
struct Copyable
{
Copyable() {}
Copyable(const Copyable& other) noexcept {}
Copyable& operator =(const Copyable& rhs) noexcept { return *this; }
Copyable(const Copyable&) noexcept {}
Copyable& operator =(const Copyable&) noexcept { return *this; }
Copyable(Copyable&& other) = delete;
Copyable& operator =(Copyable& rhs) = delete;
Copyable(Copyable&&) = delete;
Copyable& operator =(Copyable&) = delete;
};
//*********************************************
struct Moveable
{
Moveable() {}
Moveable(Moveable&& other) noexcept { }
Moveable& operator =(Moveable&& rhs) noexcept { return *this; }
Moveable(Moveable&&) noexcept { }
Moveable& operator =(Moveable&&) noexcept { return *this; }
Moveable(const Moveable& other) = delete;
Moveable& operator =(const Moveable& rhs) = delete;
Moveable(const Moveable&) = delete;
Moveable& operator =(const Moveable&) = delete;
};
//*********************************************
struct MoveableCopyable
{
MoveableCopyable() {}
MoveableCopyable(MoveableCopyable&& other) noexcept {}
MoveableCopyable& operator =(MoveableCopyable&& rhs) noexcept { return *this; }
MoveableCopyable(const MoveableCopyable& other) {}
MoveableCopyable& operator =(const MoveableCopyable& rhs) { return *this; }
MoveableCopyable(MoveableCopyable&&) noexcept {}
MoveableCopyable& operator =(MoveableCopyable&&) noexcept { return *this; }
MoveableCopyable(const MoveableCopyable&) {}
MoveableCopyable& operator =(const MoveableCopyable&) { return *this; }
};
}

1
test/test_variant_legacy.cpp
View File

@ -60,6 +60,7 @@ namespace
{
}
virtual ~not_base() {}
virtual void set() = 0;
int value;
};

14
test/test_variant_variadic.cpp
View File

@ -175,14 +175,14 @@ namespace
{
}
Copyable(const Copyable& other) noexcept
Copyable(const Copyable&) noexcept
{
moved_from = false;
moved_to = false;
copied_to = true;
}
Copyable& operator =(const Copyable& rhs) noexcept
Copyable& operator =(const Copyable&) noexcept
{
moved_from = false;
moved_to = false;
@ -268,14 +268,14 @@ namespace
return *this;
}
MoveableCopyable(const MoveableCopyable& other)
MoveableCopyable(const MoveableCopyable&)
{
moved_from = false;
moved_to = false;
copied_to = true;
}
MoveableCopyable& operator =(const MoveableCopyable& rhs)
MoveableCopyable& operator =(const MoveableCopyable&)
{
moved_to = false;
moved_from = false;
@ -840,9 +840,9 @@ namespace
int result_i;
std::string result_s;
auto visitor = etl::make_overload([&result_c](char c) { result_c = 1; },
[&result_i](int i) { result_i = 2; },
[&result_s](const std::string& s) { result_s = "3"; });
auto visitor = etl::make_overload([&result_c](char) { result_c = 1; },
[&result_i](int) { result_i = 2; },
[&result_s](const std::string&) { result_s = "3"; });
test_variant_etl_3 variant_etl;

2
test/test_visitor.cpp
View File

@ -89,7 +89,7 @@ public:
visitor.visit(*this);
}
void accept(LogVisitorType& visitor)
void accept(LogVisitorType&)
{
}
};

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

@ -58,9 +58,6 @@
<Filter Include="Resource Files\Generators">
<UniqueIdentifier>{7371282e-fddc-4269-891b-e909f74ff8e9}</UniqueIdentifier>
</Filter>
<Filter Include="Resource Files\Make">
<UniqueIdentifier>{3353062c-e8dc-4095-b7cf-d11fc952263e}</UniqueIdentifier>
</Filter>
<Filter Include="Resource Files\Images">
<UniqueIdentifier>{4d08353c-b393-47c7-a9eb-c9f2f8c25887}</UniqueIdentifier>
</Filter>
@ -121,6 +118,15 @@
<Filter Include="Source Files\Sanity Checks\Logs">
<UniqueIdentifier>{5b76fd56-eb83-489f-b9a6-798c07c5fa76}</UniqueIdentifier>
</Filter>
<Filter Include="Resource Files\Meson">
<UniqueIdentifier>{690ab671-31ea-446a-bd63-a7a2bf05b409}</UniqueIdentifier>
</Filter>
<Filter Include="Resource Files\CMake">
<UniqueIdentifier>{3353062c-e8dc-4095-b7cf-d11fc952263e}</UniqueIdentifier>
</Filter>
<Filter Include="Resource Files\Conan">
<UniqueIdentifier>{49e974a8-2dcc-40e6-b4ca-bad29f0cde52}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\..\include\etl\enum_type.h">
@ -3074,7 +3080,7 @@
<Filter>Resource Files\CI\CircleCI</Filter>
</None>
<None Include="..\cmake\unit-test_external_project.cmake">
<Filter>Resource Files\Make</Filter>
<Filter>Resource Files\CMake</Filter>
</None>
<None Include="..\..\appveyor.yml">
<Filter>Resource Files\CI\Appveyor</Filter>
@ -3088,12 +3094,6 @@
<None Include="..\..\.github\workflows\vs2019.yml">
<Filter>Resource Files\CI\Github</Filter>
</None>
<None Include="..\..\meson.build">
<Filter>Resource Files</Filter>
</None>
<None Include="..\..\conanfile.py">
<Filter>Resource Files</Filter>
</None>
<None Include="..\..\arduino\create_arduino_library.py">
<Filter>ETL\Arduino</Filter>
</None>
@ -3109,19 +3109,22 @@
<None Include="..\..\arduino\examples\Vector_Examples\Example_Vector_1_simple_use\Example_Vector_1_simple_use.ino">
<Filter>ETL\Arduino\Examples\Vector_Examples\Example_Vector_1_simple_use</Filter>
</None>
<None Include="..\..\meson.build">
<Filter>Resource Files\Meson</Filter>
</None>
<None Include="..\..\conanfile.py">
<Filter>Resource Files\Conan</Filter>
</None>
</ItemGroup>
<ItemGroup>
<Text Include="..\..\support\Release notes.txt">
<Filter>Resource Files</Filter>
</Text>
<Text Include="..\CMakeLists.txt">
<Filter>Source Files</Filter>
</Text>
<Text Include="..\..\todo.txt">
<Filter>Resource Files</Filter>
</Text>
<Text Include="..\..\CMakeLists.txt">
<Filter>Resource Files\Make</Filter>
<Filter>Resource Files\CMake</Filter>
</Text>
<Text Include="..\sanity-check\c++03\CMakeLists.txt">
<Filter>Source Files\Sanity Checks\C++03</Filter>
@ -3138,6 +3141,9 @@
<Text Include="..\sanity-check\log.txt">
<Filter>Source Files\Sanity Checks\Logs</Filter>
</Text>
<Text Include="..\CMakeLists.txt">
<Filter>Resource Files\CMake</Filter>
</Text>
</ItemGroup>
<ItemGroup>
<Image Include="..\..\etl.ico">