Merge pull request #1858 from ApexAI/iox-1560-split-up-helplets

iox-1560 Split up `helplets.hpp`

Author: mossmaurice-apexai

doc/design/error-handling.md

@@ -217,7 +217,7 @@ int32_t myAlgorithm(int32_t* ptr) {
 }
 ```
 
-Note that in the case of ``nullptr`` checks it is also an option to use references in arguments (or ``not_null`` if it is supposed to be stored since references are not copyable). It should be considered that ``not_null`` incurs a runtime cost, which may be undesirable.
+Note that in the case of ``nullptr`` checks it is also an option to use references in arguments (or ``iox::not_null`` if it is supposed to be stored since references are not copyable). It should be considered that ``iox::not_null`` incurs a runtime cost, which may be undesirable.
 When Expects and Ensures are implemented to leave no trace in release mode, we do not incur a runtime cost using them. For this reason, it is advised to use them to document and verify assumptions where appropriate.
 
 ### `expected`

doc/website/release-notes/iceoryx-unreleased.md

@@ -318,16 +318,85 @@
     }
     ```
 
-14. Remove `forEach` from helplets
+14. Moved or removed various functions from helplets
 
     ```cpp
     // before
+    #include "iceoryx_hoofs/cxx/helplets.hpp"
     iox::cxx::forEach(container, [&] (element) { /* do stuff with element */ });
 
     // after
     for (const auto& element: container) { /* do stuff with element */ }
     ```
 
+    ```cpp
+    // before
+    #include "iceoryx_hoofs/cxx/helplets.hpp"
+    iox::cxx::greater_or_equal(..);
+    iox::cxx::range(..);
+    iox::cxx::BestFittingType(..);
+    iox::cxx::isPowerOfTwo(..);
+
+    // after
+    #include "iceoryx_hoofs/cxx/algorithm.hpp"
+    iox::greater_or_equal(..);
+    iox::range(..);
+    iox::BestFittingType(..);
+    iox::isPowerOfTwo(..);
+    ```
+
+    ```cpp
+    // before
+    #include "iceoryx_hoofs/cxx/helplets.hpp"
+    iox::cxx::align(..);
+    iox::cxx::alignedAlloc(..);
+    iox::cxx::alignedFree(..);
+    iox::cxx::maxAlignment(..);
+    iox::cxx::maxSize(..);
+
+    // after
+    #include "iox/memory.hpp"
+    iox::align(..);
+    iox::alignedAlloc(..);
+    iox::alignedFree(..);
+    iox::maxAlignment(..);
+    iox::maxSize(..);
+    ```
+
+    ```cpp
+    // before
+    #include "iceoryx_hoofs/cxx/helplets.hpp"
+    iox::cxx::isValidPathEntry(..);
+    iox::cxx::isValidFileName(..);
+    iox::cxx::isValidPathToFile(..);
+    iox::cxx::isValidPathToDirectory(..);
+    iox::cxx::doesEndWithPathSeparator(..);
+    
+    // after
+    #include "iceoryx_hoofs/cxx/filesystem.hpp"
+    iox::cxx::isValidPathEntry(..);
+    iox::cxx::isValidFileName(..);
+    iox::cxx::isValidPathToFile(..);
+    iox::cxx::isValidPathToDirectory(..);
+    iox::cxx::doesEndWithPathSeparator(..);
+    ```
+
+    ```cpp
+    // before
+    #include "iceoryx_hoofs/cxx/helplets.hpp"
+    template <>
+    constexpr DestType
+    iox::cxx::from<SourceType, DestType>(const SourceType value);
+    iox::cxx::into(..);
+
+    // after
+    #include "iox/into.hpp"
+    template <>
+    constexpr DestType
+    iox::from<SourceType, DestType>(const SourceType value);
+    iox::into(..);
+    ```
+
 15. Remove `enumTypeAsUnderlyingType`
 
     ```cpp
@@ -352,7 +421,7 @@
     std::cout << SOME_ENUM_STRINGS[static_cast<uint64_t>(someEnum)] << std::endl;
     ```
 
-17. Replace `strlen2` with more generic `arrayCapacity`
+17. Replace `strlen2` with more generic `iox::size`
 
     ```cpp
     constexpr const char LITERAL1[] {"FOO"};
@@ -364,9 +433,10 @@
     std::cout << iox::cxx::strlen2(LITERAL2) << std::endl; // prints 19
 
     // after
-    std::cout << arrayCapacity(LITERAL1) << std::endl; // prints 4
-    std::cout << arrayCapacity(LITERAL2) << std::endl; // prints 20
-    std::cout << arrayCapacity(ARRAY) << std::endl;    // prints 42
+    #include "iox/size.hpp"
+    std::cout << iox::size(LITERAL1) << std::endl; // prints 4
+    std::cout << iox::size(LITERAL2) << std::endl; // prints 20
+    std::cout << iox::size(ARRAY) << std::endl;    // prints 42
     ```
 
 18. Rename `cxx::GenericRAII` to `cxx::ScopeGuard`
@@ -890,6 +960,23 @@
 
     // after
     #include "iceoryx_dust/posix_wrapper/signal_watcher.hpp"
+    ```
+
+    ```cpp
+    // before
+    #include "iceoryx_hoofs/cxx/serialization.hpp"
+
+    // after
+    #include "iceoryx_dust/cxx/serialization.hpp"
+    ```
+
+    ```cpp
+    // before
+    #include "iceoryx_hoofs/cxx/convert.hpp"
+
+    // after
+    #include "iceoryx_dust/cxx/convert.hpp"
+    ```
 
 43. Move the conversions functions for `std::string` to `iceoryx_dust`:
 
@@ -906,7 +993,7 @@
 
     std::string myStdString("foo");
     // std::string to iox::string
-    iox::string<3> myIoxString = iox::cxx::into<iox::string<3>>(myStdString);
+    iox::string<3> myIoxString = iox::into<iox::string<3>>(myStdString);
     // iox::string to std::string
-    std::string myConvertedIoxString = iox::cxx::into<std::string>(myIoxString);
+    std::string myConvertedIoxString = iox::into<std::string>(myIoxString);
     ```

iceoryx_dust/README.md

@@ -7,13 +7,15 @@ Compared to hoofs classes in `iceoryx_dust`, the difference is that the classes
 There are a wide variety of building blocks
 grouped together in categories or namespace, depending on where or how they are used.
 
-| class/file            | description                                                                                                             |
-|:---------------------:|:------------------------------------------------------------------------------------------------------------------------|
-|`forward_list`         | Heap and exception free, relocatable implementation of `std::forward_list`                                              |
-|`ObjectPool`           | Container which stores raw objects without calling the ctor of the objects.                                             |
-|`FileReader`           | Wrapper for opening files and reading them.                                                                             |
-|`MessageQueue`         | Interface for Message Queues, see [ManPage mq_overview](https://www.man7.org/linux/man-pages/man7/mq_overview.7.html).  |
-|`SignalWatcher`        | Batteries included signal handling with polling and optional blocking wait for `SIGINT` and `SIGTERM`.                  |
-|`NamedPipe`            | Shared memory based ipc channel. Mainly a `UnixDomainSocket` replacement on Windows.                                    |
-|`relocatable_ptr`      |                                                                                                                         |
-|`static_storage`       | Untyped aligned static storage.                                                                                         |
+| class/file            | description                                                                                                                                                                                                                                                                                                           |
+|:---------------------:|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+|`forward_list`         | Heap and exception free, relocatable implementation of `std::forward_list`                                                                                                                                                                                                                                            |
+|`ObjectPool`           | Container which stores raw objects without calling the ctor of the objects.                                                                                                                                                                                                                                           |
+|`FileReader`           | Wrapper for opening files and reading them.                                                                                                                                                                                                                                                                           |
+|`MessageQueue`         | Interface for Message Queues, see [ManPage mq_overview](https://www.man7.org/linux/man-pages/man7/mq_overview.7.html).                                                                                                                                                                                                |
+|`SignalWatcher`        | Batteries included signal handling with polling and optional blocking wait for `SIGINT` and `SIGTERM`.                                                                                                                                                                                                                |
+|`NamedPipe`            | Shared memory based IPC channel. Mainly a `UnixDomainSocket` replacement on Windows.                                                                                                                                                                                                                                  |
+|`relocatable_ptr`      |                                                                                                                                                                                                                                                                                                                       |
+|`static_storage`       | Untyped aligned static storage.                                                                                                                                                                                                                                                                                       |
+|`convert`              | Converting a number into a string is easy, converting it back can be hard. You can use functions like `strtoll`, but you still have to handle errors like under- and overflow, or converting invalid strings into number. Here we abstract all the error handling so that you can convert strings into numbers safely. |
+|`serialization`        | Implements a simple serialization concept for classes based on the idea presented here [ISOCPP serialization](https://isocpp.org/wiki/faq/serialization#serialize-text-format).                                                                                                                                       |

iceoryx_hoofs/include/iceoryx_hoofs/cxx/convert.hpp renamed to iceoryx_dust/include/iceoryx_dust/cxx/convert.hpp

@@ -15,8 +15,8 @@
 // limitations under the License.
 //
 // SPDX-License-Identifier: Apache-2.0
-#ifndef IOX_HOOFS_CXX_CONVERT_HPP
-#define IOX_HOOFS_CXX_CONVERT_HPP
+#ifndef IOX_DUST_CXX_CONVERT_HPP
+#define IOX_DUST_CXX_CONVERT_HPP
 
 #include "iceoryx_hoofs/posix_wrapper/posix_call.hpp"
 #include "iox/string.hpp"
@@ -45,7 +45,7 @@ namespace cxx
 ///     if ( cxx::convert::fromString("-123", a) ) {} // will fail since -123 is not unsigned
 /// @endcode
 /// @todo iox-#260 Refactor 'convert' so that one can use 'into' to directly to convert numbers to strings:
-/// 'ClassExpectingAnIoxString(iox::cxx::into<iox::string<100>>(42)'
+/// 'ClassExpectingAnIoxString(iox::into<iox::string<100>>(42)'
 class convert
 {
   public:
@@ -105,6 +105,6 @@ class convert
 } // namespace cxx
 } // namespace iox
 
-#include "iceoryx_hoofs/internal/cxx/convert.inl"
+#include "iceoryx_dust/internal/cxx/convert.inl"
 
-#endif // IOX_HOOFS_CXX_CONVERT_HPP
+#endif // IOX_DUST_CXX_CONVERT_HPP

iceoryx_dust/include/iceoryx_dust/cxx/forward_list.hpp

@@ -18,7 +18,7 @@
 #ifndef IOX_DUST_CXX_FORWARD_LIST_HPP
 #define IOX_DUST_CXX_FORWARD_LIST_HPP
 
-#include "iceoryx_hoofs/cxx/helplets.hpp"
+#include "iceoryx_hoofs/cxx/requires.hpp"
 #include "iox/uninitialized_array.hpp"
 
 #include <cstdint>

iceoryx_hoofs/include/iceoryx_hoofs/cxx/serialization.hpp renamed to iceoryx_dust/include/iceoryx_dust/cxx/serialization.hpp

@@ -14,10 +14,10 @@
 // limitations under the License.
 //
 // SPDX-License-Identifier: Apache-2.0
-#ifndef IOX_HOOFS_CXX_SERIALIZATION_HPP
-#define IOX_HOOFS_CXX_SERIALIZATION_HPP
+#ifndef IOX_DUST_CXX_SERIALIZATION_HPP
+#define IOX_DUST_CXX_SERIALIZATION_HPP
 
-#include "iceoryx_hoofs/cxx/convert.hpp"
+#include "iceoryx_dust/cxx/convert.hpp"
 
 #include <iostream>
 #include <sstream>
@@ -140,6 +140,6 @@ class Serialization
 } // namespace cxx
 } // namespace iox
 
-#include "iceoryx_hoofs/internal/cxx/serialization.inl"
+#include "iceoryx_dust/internal/cxx/serialization.inl"
 
-#endif // IOX_HOOFS_CXX_SERIALIZATION_HPP
+#endif // IOX_DUST_CXX_SERIALIZATION_HPP

iceoryx_dust/include/iceoryx_dust/cxx/std_string_support.hpp

@@ -16,15 +16,13 @@
 #ifndef IOX_DUST_STD_STRING_SUPPORT_HPP
 #define IOX_DUST_STD_STRING_SUPPORT_HPP
 
-#include "iceoryx_hoofs/cxx/helplets.hpp"
-#include "iceoryx_hoofs/cxx/string.hpp"
+#include "iox/into.hpp"
+#include "iox/string.hpp"
 
 #include <string>
 
 namespace iox
 {
-namespace cxx
-{
 template <uint64_t N>
 struct FromImpl<string<N>, std::string>
 {
@@ -36,7 +34,6 @@ struct FromImpl<std::string, string<N>>
 {
     static string<N> fromImpl(const std::string& value) noexcept;
 };
-} // namespace cxx
 } // namespace iox
 
 #include "iceoryx_dust/internal/cxx/std_string_support.inl"

iceoryx_dust/include/iceoryx_dust/internal/cli/arguments.hpp

@@ -17,8 +17,8 @@
 #define IOX_DUST_CLI_ARGUMENTS_HPP
 
 #include "iceoryx_dust/cli/types.hpp"
+#include "iceoryx_dust/cxx/convert.hpp"
 #include "iceoryx_dust/internal/cli/option.hpp"
-#include "iceoryx_hoofs/cxx/convert.hpp"
 #include "iceoryx_hoofs/cxx/vector.hpp"
 #include "iox/expected.hpp"
 

iceoryx_dust/include/iceoryx_dust/internal/cli/option_manager.inl

@@ -62,7 +62,7 @@ inline T OptionManager::defineOption(T& referenceToMember,
 {
     constexpr bool IS_NO_SWITCH = false;
     m_optionSet.addOption(OptionWithDetails{
-        {shortName, IS_NO_SWITCH, name, cxx::into<Argument_t>(cxx::convert::toString(defaultArgumentValue))},
+        {shortName, IS_NO_SWITCH, name, into<Argument_t>(cxx::convert::toString(defaultArgumentValue))},
         description,
         optionType,
         {cxx::TypeInfo<T>::NAME}});

iceoryx_hoofs/include/iceoryx_hoofs/internal/cxx/convert.inl renamed to iceoryx_dust/include/iceoryx_dust/internal/cxx/convert.inl

@@ -15,10 +15,10 @@
 // limitations under the License.
 //
 // SPDX-License-Identifier: Apache-2.0
-#ifndef IOX_HOOFS_CXX_CONVERT_INL
-#define IOX_HOOFS_CXX_CONVERT_INL
+#ifndef IOX_DUST_CXX_CONVERT_INL
+#define IOX_DUST_CXX_CONVERT_INL
 
-#include "iceoryx_hoofs/cxx/convert.hpp"
+#include "iceoryx_dust/cxx/convert.hpp"
 #include "iceoryx_hoofs/log/logging.hpp"
 
 namespace iox
@@ -431,4 +431,4 @@ inline bool convert::fromString<bool>(const char* v, bool& dest) noexcept
 } // namespace cxx
 } // namespace iox
 
-#endif // IOX_HOOFS_CXX_CONVERT_INL
+#endif // IOX_DUST_CXX_CONVERT_INL