Adjusted documentation to refer to etl instead of estd

Author: rolandreichweinbmw

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

@@ -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
 ----------------

libs/bsw/async/doc/user/index.rst

@@ -21,7 +21,7 @@ scheduleAtFixedRate   Allows to schedule a ``async::RunnableType`` to be run per
 
 The ``util/Call.h`` declares a runnable class that allows customized implementation on execution
 by providing callable object (with *function call* operator ``()``).
-For example the predefined ``async::Function`` type is declaring ``::estd::function`` as callable type.
+For example the predefined ``async::Function`` type is declaring ``::etl::inplace_function`` as callable type.
 
 The ``util/MemberCall.h`` provides a ``async::MemberCall`` class, which allows to create a ``async::RunnableType``
 from a member function of a non-runnable class.

libs/bsw/io/doc/user/buffered_writer.rst

@@ -16,7 +16,7 @@ Properties
 * Internally the ``BufferedWriter`` manages slices of ``destination.maxSize()`` bytes and
   provides subslices of it to the user.
 * Call to ``flush()`` required to commit currently buffered data.
-* **Memory consumption**: ``sizeof(::io::IWriter&) + sizeof(::estd::slice<uint8_t>) + sizeof(size_t)``
+* **Memory consumption**: ``sizeof(::io::IWriter&) + sizeof(::etl::span<uint8_t>) + sizeof(size_t)``
 
 Public API
 ----------

libs/bsw/io/doc/user/forwarding_reader.rst

@@ -12,7 +12,7 @@ side, the ``ForwardingReader`` allows forking a data stream at the reader side o
 Properties
 ----------
 
-* **Memory consumption**: ``sizeof(IReader&) + sizeof(IWriter&) + (sizeof(::estd::slice<uint8_t>) * 2)``
+* **Memory consumption**: ``sizeof(IReader&) + sizeof(IWriter&) + (sizeof(::etl::span<uint8_t>) * 2)``
 
 Public API
 ----------