Switch from ESTD to ETL

Author: rolandreichweinbmw

NOTICE.md

@@ -34,6 +34,7 @@ We recommend to read their licenses, as their terms may differ from the terms de
 
 | Project                   | Version | License   | Path                                                                 |
 |---------------------------|---------|-----------|----------------------------------------------------------------------|
+| ETL                       | 20.41.6 | MIT       | ``libs/bsw/3rdparty/etl/LICENSE``                                    |
 | googletest                | 1.12.1  | BSD-3     | ``libs/bsw/3rdparty/googletest/LICENSE``                             |
 | printf                    | 5.2.0   | MIT       | ``libs/bsw/3rdparty/printf/LICENSE``                                 |
 | FreeRTOS Real Time Kernel | 10.6.2  | MIT       | ``platforms/posix/3rdparty/freeRtosPosix/LICENSE.md``                |

doc/codingGuidelines/codeFormatting/for_c++/formatting.rst

@@ -383,10 +383,10 @@ Spaces
 .. code-block:: C++
 
     // good
-    estd::example<uint8_t> numbers{1, 2, 3, 4};
+    etl::example<uint8_t> numbers{1, 2, 3, 4};
 
     // bad
-    estd::example<uint8_t> numbers{ 1, 2, 3, 4 };
+    etl::example<uint8_t> numbers{ 1, 2, 3, 4 };
 
 .. code-block::
     :caption: clang-format settings

doc/codingGuidelines/conventions/classes.rst

@@ -322,24 +322,24 @@ also disable move construction:
 
 
 Before the adoption of the C++11 standard, ``UNCOPYABLE`` macro from ``estd`` library was used.
-Now that functions can be marked as deleted, ``estd/uncopyable.h`` is considered obsolete and should
-be avoided.
 
 
 Indestructible
 --------------
 
-To avoid destructions of objects, use the ``estd::indestructible`` wrapper. The type will
+To avoid destructions of objects, use the ``etl::typed_storage`` wrapper. The type will
 become `trivially destructible
 <http://www.cplusplus.com/reference/type_traits/is_trivially_destructible/>`_.
 
 In the following example the object of type `YourType` will be constructed with placement-new,
 but never destructed even when `wrapper` gets destructed. The destructor of `YourType` will never be
-called:
+called, except if you call destroy() explicitly:
 
 .. code-block:: cpp
 
-    estd::indestructible<YourType> wrapper;
+    etl::typed_storage<YourType> wrapper;
+    wrapper.create();
+
 
 Avoid Protected Data
 --------------------

doc/codingGuidelines/conventions/enumerations.rst

@@ -80,12 +80,12 @@ most cases ``uint8_t``.
 One advantage is that variables can now be compared with the scope resolution operator.
 A drawback is that there is no direct conversion from the values of a scoped enumerator to the
 underlying type.
-Use ``::estd::to_underlying`` from ``estd/type_utils.h`` to cast the enumeration value to the
+Use ``::etl::to_underlying`` from ``etl/utility.h`` to cast the enumeration value to the
 underlying type.
 
 .. code-block:: cpp
 
-    #include <estd/type_utils.h>
+    #include <etl/utility.h>
 
     // recommended definition
     enum class Colors : uint8_t
@@ -104,8 +104,8 @@ underlying type.
         case Colors::BLUE   : printf("Blue color\n"); break;
     }
 
-    // option 1: (recommended) use the estd helper function
-    auto const colorRed = ::estd::to_underlying(Colors::RED);
+    // option 1: (recommended) use the etl helper function
+    auto const colorRed = ::etl::to_underlying(Colors::RED);
     // option 2: explicitly cast using the underlying type
     auto const colorGreen = static_cast<::std::underlying_type<Colors>::type>(Colors::GREEN);
     // option 3: explicitly cast to the specified type

doc/codingGuidelines/conventions/files.rst

@@ -19,8 +19,8 @@ Standard Headers
 ----------------
 
 - See `C++ Standard Library headers <https://en.cppreference.com/w/cpp/header>`_ for details.
-  Note, that not all includes make sense in embedded code. Some parts are replaced by our own
-  ``estd`` library.
+  Note that not all includes make sense in embedded code. Some parts are replaced by the
+  ``etl`` library.
 - :rule:`FILE-010` If a file needs to be compiled for C++ and C, use the C headers.
 - :rule:`FILE-011` For C++ standard types, include ``<platform/estdint.h>``. It'll behave as if you
   included ``<cstdint>`` and ``<cstddef>`` and allow the usage of ``size_t`` directly without the

doc/codingGuidelines/conventions/functions.rst

@@ -113,8 +113,8 @@ Code that uses raw byte arrays and a length are very prone to errors or misuse.
     void start(Connection& conn, uint8_t data[], uint16_t length);
 
 It's unclear from the method signature what will happen to data and length.
-Look for existing buffer classes and reuse one of those, for example ``estd::array<>`` or
-``estd::slice<>``.
+Look for existing buffer classes and reuse one of those, for example ``etl::array<>`` or
+``etl::span<>``.
 
 
 Translation-Unit Local Functions
@@ -147,5 +147,5 @@ where we have the certainty that they are supported.
 
 When using lambdas, be careful about object lifetimes: objects captured by reference within a lambda
 have to be still in scope at the time of lambda execution. Also lambda objects themselves have to
-still exist when they're executed - it might be tricky while using function references like
-``estd::function``.
+still exist when they're executed.  A solution to this issue is implemented in
+``etl::inplace_function``.

doc/codingGuidelines/conventions/naming.rst

@@ -48,7 +48,7 @@ Type Names
     using TcpipEventManager = ::os::EventManager<task_tcpip>;
 
 Any exceptions to this rule need to have a reasonable justification and in that
-case should be applied consistently within a module (e.g. ``estd`` types use
+case should be applied consistently within a module (e.g. ``etl`` types use
 *snake_case* notation in order to match with their STL counterpart). In general
 those exceptions should be rare!
 
@@ -184,7 +184,7 @@ does not provide any functions, you can omit the prefix.
 
     class CanTransceiver    // good
     {
-        ::estd::forward_list<ICanFrameListener> _listeners;
+        ::etl::intrusive_forward_list<ICanFrameListener, ::etl::forward_link<0>> _listeners;
     };
 
     struct Result           // good
@@ -196,7 +196,7 @@ does not provide any functions, you can omit the prefix.
 
     class CanTransceiver    // bad, no member prefix
     {
-        ::estd::forward_list<ICanFrameListener> listeners;
+        ::etl::intrusive_forward_list<ICanFrameListener, ::etl::forward_link<0>> listeners;
     };
 
     struct Result           // bad, suffix and mixed style
@@ -316,7 +316,7 @@ Boolean Variables and Functions
   - might need conversion if propagated to higher levels
 
   Other rarely used types are `bitfields` and `ranges`. For return values of functions it is
-  worth to look at ``::estd::result`` class which combines data and error status in one object.
+  worth to look at ``::etl::expected`` class which combines data and error status in one object.
 
   In most cases using a boolean is the best choice to keep it simple.
 
@@ -328,7 +328,7 @@ type of the variable and the operations that can be performed on its elements.
 
 .. code-block:: cpp
 
-    using ReceiverList = ::estd::forward_list<Receiver>;
+    using ReceiverList = ::etl::intrusive_forward_list<Receiver, ::etl::forward_link<0>>;
 
     vector<Point>  points;
     int            values[];

doc/codingGuidelines/conventions/statements.rst

@@ -184,7 +184,7 @@ memory got corrupted (out of bounds access through operator[]). Comment the usag
 justification.
 
 It might be acceptable during development to use asserts. In this case use ``estd_expect`` instead.
-``estd_expect`` behaves the same as ``estd_assert``, but it must be replaced before SOP with
+``estd_expect`` behaves the same as ``estd_assert``, but it must be replaced for production with
 proper error handling. The usage of ``estd_expect`` is detected by our code analyzers and
 presented in the module overview from Cijack.
 
@@ -211,12 +211,12 @@ which improves readability. Additionally, ``using`` can be used for template ali
 
 .. code-block:: cpp
 
-    using MyArray = ::estd::array<::some::other::Type, 199>; // good - new name comes first
+    using MyArray = ::etl::array<::some::other::Type, 199>; // good - new name comes first
 
-    typedef ::estd::array<::some::other::Type, 199> MyArray; // bad - new name at the end
+    typedef ::etl::array<::some::other::Type, 199> MyArray; // bad - new name at the end
 
     template <typename T>
-    using ArrayOf5 = ::estd::array<T, 5>; // template alias - impossible with typedef
+    using ArrayOf5 = ::etl::array<T, 5>; // template alias - impossible with typedef
 
 OS Specific Code
 ----------------

executables/referenceApp/application/CMakeLists.txt

@@ -44,7 +44,7 @@ target_link_libraries(
             asyncConsole
             bspMcu
             configuration
-            estd
+            etl
             lifecycle
             consoleCommands
             logger

executables/referenceApp/application/include/systems/DoCanSystem.h

@@ -13,6 +13,7 @@
 #include <docan/datalink/DoCanFrameCodec.h>
 #include <docan/transmitter/IDoCanTickGenerator.h>
 #include <docan/transport/DoCanTransportLayerContainer.h>
+#include <etl/vector.h>
 #include <lifecycle/AsyncLifecycleComponent.h>
 
 namespace can
@@ -100,7 +101,7 @@ class DoCanSystem final
     ::docan::DoCanParameters _parameters;
     ::docan::declare::DoCanTransportLayerConfig<DataLinkLayerType, 80U, 15U, 64U>
         _transportLayerConfig;
-    ::estd::declare::vector<DoCanPhysicalCanTransceiver<AddressingType>, NUM_CAN_TRANSPORT_LAYERS>
+    ::etl::vector<DoCanPhysicalCanTransceiver<AddressingType>, NUM_CAN_TRANSPORT_LAYERS>
         _physicalTransceivers;
     TransportLayers _transportLayers;
     TickGeneratorRunnableAdapter _tickGenerator;