[#4] Fix typos in docs, comments and string literals

FAQ_ICEORYX_DEVS.md

@@ -25,7 +25,7 @@ Users can override the log level in the following ways:
 
 ## Tests marked with `#[should_panic]` attribute do not panic in release builds
 
-This usually happens when the panic is triggert via a `debug_assert` macro.
+This usually happens when the panic is triggered via a `debug_assert` macro.
 This macro is not active when the `-C debug-assertions` flag is not set, which
 is the case for release builds.
 To fix this problem, just add a `#[cfg(debug_assertions)]` to the test.

component-tests/cxx/src/test_containers.cpp

@@ -117,7 +117,7 @@ auto check_metrics_for_vector(ContainerTestRequest const& req) -> bool {
     }
     if ((stats.storage_metrics.storage_alignment > std::numeric_limits<int32_t>::max())
         || (static_cast<int32_t>(stats.storage_metrics.storage_alignment) != req.container_alignment)) {
-        std::cout << "Storage alignmnent mismatch\n";
+        std::cout << "Storage alignment mismatch\n";
         return false;
     }
     if ((stats.storage_metrics.sizeof_bytes > std::numeric_limits<int32_t>::max())

config/README.md

@@ -210,11 +210,11 @@ for the runtime configuration in TOML format as described above.
 
 The default settings are already tailored to the most common
 operating systems but it can happen that users may face a specific limitation
-(e.g. the `TEMP_DIRECTORY` is not writeable) on their specific platform.
+(e.g. the `TEMP_DIRECTORY` is not writable) on their specific platform.
 To provide the flexibility to easily handle such cases, it is possible to
 define a custom platform configuration to be used in the build.
 
-The first step is to create a file with custom configurtion
+The first step is to create a file with custom configuration
 at any location (e.g. `/my/funky/platform/platform_configuration.rs`).
 
 An example configuration may look like this, however be sure to check the

doc/development-setup/android.md

@@ -93,7 +93,7 @@ sudo systemctl restart waydroid-container.service
 
 The `suspend` property prevents the Android session to activate the lock-screen.
 Without turning suspend off, the `adb` commands will fail a few minutes after
-the last interaction with `waydroid`. Alternatively, the option could als be set
+the last interaction with `waydroid`. Alternatively, the option could also be set
 via `adb` with:
 
 ```bash

doc/how-to-write-conformance-tests.md

@@ -188,8 +188,8 @@ conformance test module:
 
 ```rs
 trait Foo {}
-struc Bar {}
-struc Baz {}
+struct Bar {}
+struct Baz {}
 
 impl Foo for Bar {}
 impl Foo for Baz {}

doc/user-documentation/bb-to-std-mapping.md

@@ -3,7 +3,7 @@
 ## Overview
 
 This document provides an overview of the iceoryx2 building blocks and their
-similiarities to Rust `std` types.
+similarities to Rust `std` types.
 
 ## Version
 

examples/cxx/health_monitoring/src/central_daemon.cpp

@@ -55,7 +55,7 @@ auto main() -> int {
                                .notifier_created_event(iox2::bb::into<EventId>(PubSubEvent::PublisherConnected))
                                .notifier_dropped_event(iox2::bb::into<EventId>(PubSubEvent::PublisherDisconnected))
                                // This event is emitted when either the central daemon or a decentralized process
-                               // detects a dead node and cleaned up all of its stale resources succesfully.
+                               // detects a dead node and cleaned up all of its stale resources successfully.
                                .notifier_dead_event(iox2::bb::into<EventId>(PubSubEvent::ProcessDied))
                                .open_or_create()
                                .value();

examples/nostd/bare-metal/rust/publish-subscribe/README.md

@@ -2,5 +2,5 @@
 
 This example illustrates the ability to use the publish-subscribe messaging
 pattern in a bare metal deployment. Samples are sent and received with the
-same publish-subscribe APIs used in more typical deployements to platforms
+same publish-subscribe APIs used in more typical deployments to platforms
 with an operating system.

examples/python/README.md

@@ -9,7 +9,7 @@ Python bindings. e.g.
 pip install iceoryx2==0.9.999
 ```
 
-Be sure to switch to the matching release tag to ensure compatability:
+Be sure to switch to the matching release tag to ensure compatibility:
 
 ```console
 git checkout v0.9.999
@@ -42,7 +42,7 @@ poetry --project iceoryx2-ffi/python install
 
 ## Build
 
-Compile the iceoryx2 Python language bindings into the virutal
+Compile the iceoryx2 Python language bindings into the virtual
 environment by calling:
 
 ```sh

examples/rust/health_monitoring/central_daemon.rs

@@ -57,7 +57,7 @@ fn main() -> Result<(), Box<dyn core::error::Error>> {
         .notifier_created_event(PubSubEvent::PublisherConnected.into())
         .notifier_dropped_event(PubSubEvent::PublisherDisconnected.into())
         // This event is emitted when either the central daemon or a decentralized process detects
-        // a dead node and cleaned up all of its stale resources succesfully.
+        // a dead node and cleaned up all of its stale resources successfully.
         .notifier_dead_event(PubSubEvent::ProcessDied.into())
         .open_or_create()?;
 

iceoryx2-bb/container/src/byte_atomic.rs

@@ -119,7 +119,7 @@ impl<T> MaybeTorn<T> {
     /// The caller must guarantee that the underlying memory does not contain a torn state,
     /// otherwise `T` may be "logically" invalid. In the context of [`FixedSizeByteAtomic::read()`],
     /// this means that the caller must have verified via synchronization primitives that no
-    /// concurrent writes occured during the read operation. If called on a torn value, using the
+    /// concurrent writes occurred during the read operation. If called on a torn value, using the
     /// resulting `T` may lead to undefined behavior.
     pub unsafe fn assume_consistent(self) -> T {
         unsafe { self.inner.assume_init() }

iceoryx2-bb/container/src/semantic_string.rs

@@ -299,7 +299,7 @@ pub trait SemanticString<const CAPACITY: usize>:
         temp.remove_range(idx, len);
         if Self::is_invalid_content(temp.as_bytes()) {
             fail!(from self, with SemanticStringError::InvalidContent,
-                "Unable to remove range from {} with lenght {} since it would result in the illegal content \"{}\".",
+                "Unable to remove range from {} with length {} since it would result in the illegal content \"{}\".",
                     idx, len, temp);
         }
 

iceoryx2-bb/cxx/include/iox2/legacy/detail/convert.hpp

@@ -60,7 +60,7 @@ class convert {
     static constexpr uint32_t FLOAT_SIGNALING_NAN_MASK { static_cast<uint32_t>(1) << static_cast<uint32_t>(22) };
     static constexpr uint64_t DOUBLE_SIGNALING_NAN_MASK { static_cast<uint64_t>(1) << static_cast<uint64_t>(51) };
 
-    /// @brief Converts every type which is either a pod (plain old data) type or is convertable
+    /// @brief Converts every type which is either a pod (plain old data) type or is convertible
     ///         to a string (this means that the operator std::string() is defined)
     /// @param Source type of the value which should be converted to a string
     /// @param[in] t value which should be converted to a string
@@ -69,7 +69,7 @@ class convert {
     static typename std::enable_if<!std::is_convertible<Source, std::string>::value, std::string>::type
     toString(const Source& t) noexcept;
 
-    /// @brief Converts every type which is either a pod (plain old data) type or is convertable
+    /// @brief Converts every type which is either a pod (plain old data) type or is convertible
     ///         to a string (this means that the operator std::string() is defined)
     /// @param Source type of the value which should be converted to a string
     /// @param[in] t value which should be converted to a string

iceoryx2-bb/elementary-traits/src/relocatable_container.rs

@@ -18,7 +18,7 @@ use crate::allocator::{Allocate, AllocationError};
 
 /// Describes a container which can shared between processes. Since the shared memory is often
 /// mapped at a different virtual memory position the underlying constructs must be relocatable in
-/// the sense that they should not rely on absolut memory positions.
+/// the sense that they should not rely on absolute memory positions.
 pub trait RelocatableContainer {
     /// Creates a new uninitialized RelocatableContainer. Before the container can be used the method
     /// [`RelocatableContainer::init()`] must be called.

iceoryx2-bb/elementary-traits/src/zeroable.rs

@@ -19,7 +19,7 @@
 /// 1. The user must ensure that an all-zero bit pattern is valid.
 ///
 pub unsafe trait Zeroable: core::marker::Sized {
-    /// Creates a new zerod value.
+    /// Creates a new zeroed value.
     fn new_zeroed() -> Self {
         unsafe { core::mem::zeroed() }
     }

iceoryx2-bb/elementary/src/cyclic_tagger.rs

@@ -42,7 +42,7 @@
 //! // add a new thing
 //! my_things.push(MyThing { some_property: 456, tag: global_tagger.create_tag() });
 //!
-//! // remove all non-taged things
+//! // remove all non-tagged things
 //! my_things.retain(|thing| thing.was_tagged_by(&global_tagger));
 //! ```
 

iceoryx2-bb/elementary/src/relocatable_pointer.rs

@@ -119,8 +119,8 @@ impl<T: Debug> RelocatablePointer<T> {
     }
 
     /// Initializes the [`RelocatablePointer`] by setting the distance to the memory destination
-    /// by providing an absolut pointer to it. The distance can be calculated from the
-    /// [`RelocatablePointer`] memory location and the absolut position of the destination.
+    /// by providing an absolute pointer to it. The distance can be calculated from the
+    /// [`RelocatablePointer`] memory location and the absolute position of the destination.
     /// **Important:** The pointer must point into the same shared memory object.
     ///
     /// # Safety

iceoryx2-bb/elementary/src/unique_id.rs

@@ -10,7 +10,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
-//! Contains two building blocks to generate unique ids. Useful for parallized unit test to
+//! Contains two building blocks to generate unique ids. Useful for parallelized unit test to
 //! generate names which point to OS resources or to enumerate constructs uniquely.
 //!
 //! # Examples

iceoryx2-bb/lock-free/src/mpmc/container.rs

@@ -191,7 +191,7 @@ impl<T: Copy + Debug> ContainerState<T> {
 /// A **threadsafe** and **lock-free** runtime fixed size container. The compile time fixed size
 /// container is called [`FixedSizeContainer`].
 ///
-/// **Restriction:** T is not allowed to implement [`Drop`], it must be trivially dropable!
+/// **Restriction:** T is not allowed to implement [`Drop`], it must be trivially droppable!
 #[repr(C)]
 #[derive(Debug)]
 pub struct Container<T: Copy + Debug> {
@@ -672,8 +672,8 @@ impl<T: Copy + Debug, const CAPACITY: usize> FixedSizeContainerData<T, CAPACITY>
 /// A **threadsafe** and **lock-free** compile time fixed size container. The runtime time fixed size
 /// container is called [`Container`].
 ///
-/// **Restriction:** T is not allowed to implement [`Drop`], it must be trivially dropable!
-// T is not allowed to implement Drop - must be trivially dropable
+/// **Restriction:** T is not allowed to implement [`Drop`], it must be trivially droppable!
+// T is not allowed to implement Drop - must be trivially droppable
 #[repr(C)]
 #[derive(Debug)]
 pub struct FixedSizeContainer<T: Copy + Debug, const CAPACITY: usize> {

iceoryx2-bb/lock-free/src/mpmc/robust_unique_index_set.rs

@@ -509,7 +509,7 @@ impl RobustUniqueIndexSet {
             .borrowed_indices as usize
     }
 
-    /// This funtion returns the number of borrowed indices, meaning how many
+    /// This function returns the number of borrowed indices, meaning how many
     /// `cell`s != `OwnerId::EMPTY` combined with the generation counter at that
     /// time.
     fn borrowed_indices_and_generation_counter(&self) -> SetState {

iceoryx2-bb/lock-free/src/spsc/queue.rs

@@ -11,7 +11,7 @@
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
 //! A **threadsafe** **lock-free** single produce single consumer queue.
-//! **IMPORTANT** Can only be used with trivially copyable types which are also trivially dropable.
+//! **IMPORTANT** Can only be used with trivially copyable types which are also trivially droppable.
 //!
 //! # Example
 //!

iceoryx2-bb/posix/src/clock.rs

@@ -48,7 +48,7 @@ enum_gen! { NanosleepError
 
 enum_gen! {
 /// Use this more generic error enum when you do not require the fine grained error handling.
-/// Every error enum is convertable into this one and on a higher level this is convertable into
+/// Every error enum is convertible into this one and on a higher level this is convertible into
 /// [`crate::Error`].
     ClockError
   generalization:

iceoryx2-bb/posix/src/directory.rs

@@ -142,7 +142,7 @@ enum_gen! {
     /// The DirectoryError enum is a generalization when one doesn't require the fine-grained error
     /// handling enums. One can forward DirectoryError as more generic return value when a method
     /// returns a Directory***Error.
-    /// On a higher level it is again convertable to [`crate::Error`].
+    /// On a higher level it is again convertible to [`crate::Error`].
     DirectoryError
   generalization:
     Create <= DirectoryCreateError,
@@ -152,7 +152,7 @@ enum_gen! {
 }
 
 /// Represents an entry of a [`Directory`]. It provides the name of the entry and [`Metadata`] to
-/// acquire additional informations about the entry.
+/// acquire additional information about the entry.
 ///
 /// # Example
 ///

iceoryx2-bb/posix/src/file.rs

@@ -32,7 +32,7 @@
 //! file.read_to_vector(&mut content).expect("Failed to read file");
 //! file.write(content.as_slice()).expect("Failed to write file");
 //!
-//! if File::does_exist(&file_name).expect("Failed to check for existance") {
+//! if File::does_exist(&file_name).expect("Failed to check for existence") {
 //!   println!("Woohoo file exists");
 //! }
 //!
@@ -252,7 +252,7 @@ enum_gen! {
     /// The FileError enum is a generalization when one doesn't require the fine-grained error
     /// handling enums. One can forward FileError as more generic return value when a method
     /// returns a File***Error.
-    /// On a higher level it is again convertable to [`crate::Error`].
+    /// On a higher level it is again convertible to [`crate::Error`].
     FileError
   generalization:
     Create <= FileCreationError,
@@ -543,15 +543,15 @@ impl File {
         {
             CreationMode::CreateExclusive => create_file(),
             CreationMode::PurgeAndCreate => {
-                if fail!(from config, when File::does_exist(&config.file_path), "{} since the file existance verification failed.", msg)
+                if fail!(from config, when File::does_exist(&config.file_path), "{} since the file existence verification failed.", msg)
                 {
                     fail!(from config, when File::remove(&config.file_path), "{} since the removal of the already existing file failed.", msg);
                 }
 
                 create_file()
             }
             CreationMode::OpenOrCreate => {
-                match fail!(from config, when File::does_exist(&config.file_path), "{} since the file existance verification failed.", msg)
+                match fail!(from config, when File::does_exist(&config.file_path), "{} since the file existence verification failed.", msg)
                 {
                     true => Ok(FileDescriptor::new(unsafe {
                         posix::open(config.file_path.as_c_str(), config.access_mode.as_oflag())
@@ -993,7 +993,7 @@ impl File {
             Errno::ELOOP => (LoopInSymbolicLinks, "{} \"{}\" since a loop exists in the symbolic links.", msg, path),
             Errno::ENAMETOOLONG => (MaxSupportedPathLengthExceeded, "{} \"{}\" since it is longer than the maximum path name length.", msg, path),
             Errno::EROFS => (PartOfReadOnlyFileSystem, "{} \"{}\" since it is part of a read-only filesystem.", msg, path),
-            v => (UnknownError(v as i32), "{} \"{}\" since an unkown error occurred ({}).", msg, path, v)
+            v => (UnknownError(v as i32), "{} \"{}\" since an unknown error occurred ({}).", msg, path, v)
         );
     }
 

iceoryx2-bb/posix/src/memory_lock.rs

@@ -41,7 +41,7 @@ enum_gen! {
     /// The MemoryLockError enum is a generalization when one doesn't require the fine-grained error
     /// handling enums. One can forward MemoryLockError as more generic return value when a method
     /// returns a MemoryLock***Error.
-    /// On a higher level it is again convertable to [`crate::Error`].
+    /// On a higher level it is again convertible to [`crate::Error`].
     MemoryLockError
   generalization:
     LockFailed <= MemoryLockCreationError; MemoryLockAllError

iceoryx2-bb/posix/src/metadata.rs

@@ -10,7 +10,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
-//! [`Metadata`] contains all informations like type, credentials, size, access times about every
+//! [`Metadata`] contains all information like type, credentials, size, access times about every
 //! structure which has a file handle representation. Every struct which implements the
 //! [`crate::file_descriptor::FileDescriptorManagement`] trait can emit a [`Metadata`].
 //! One struct is for instance [`crate::file::File`].
@@ -22,7 +22,7 @@ use crate::permission::{Permission, PermissionExt};
 use crate::user::Uid;
 use iceoryx2_pal_posix::*;
 
-/// Contains all informations like type, credentials, size, access times about every
+/// Contains all information like type, credentials, size, access times about every
 /// structure which has a file handle representation. Every struct which implements the
 /// [`crate::file_descriptor::FileDescriptorManagement`] trait can emit a [`Metadata`].
 /// One struct is for instance [`crate::file::File`].

iceoryx2-bb/posix/src/mutex.rs

@@ -148,7 +148,7 @@ enum_gen! {
     /// The MutexError enum is a generalization when one doesn't require the fine-grained error
     /// handling enums. One can forward MutexError as more generic return value when a method
     /// returns a Mutex***Error.
-    /// On a higher level it is again convertable to [`crate::Error`].
+    /// On a higher level it is again convertible to [`crate::Error`].
     MutexError
   entry:
     CreationFailed,

iceoryx2-bb/posix/src/process.rs

@@ -97,7 +97,7 @@ enum_gen! {
     /// The ProcessError enum is a generalization when one doesn't require the fine-grained error
     /// handling enums. One can forward ProcessError as more generic return value when a method
     /// returns a Process***Error.
-    /// On a higher level it is again convertable to [`crate::Error`].
+    /// On a higher level it is again convertible to [`crate::Error`].
     ProcessError
   generalization:
     FailedToSetSchedulerSettings <= ProcessSetSchedulerError,

iceoryx2-bb/posix/src/read_write_mutex.rs

@@ -105,7 +105,7 @@ enum_gen! {
     /// The ReadWriteMutexError enum is a generalization when one doesn't require the fine-grained error
     /// handling enums. One can forward ReadWriteMutexError as more generic return value when a method
     /// returns a ReadWriteMutex***Error.
-    /// On a higher level it is again convertable to [`crate::Error`].
+    /// On a higher level it is again convertible to [`crate::Error`].
     ReadWriteMutexError
   generalization:
     FailedToLock <= ReadWriteMutexWriteLockError; ReadWriteMutexReadLockError,

iceoryx2-bb/posix/src/semaphore.rs

@@ -106,7 +106,7 @@ enum_gen! {
     /// The SemaphoreError enum is a generalization when one doesn't require the fine-grained error
     /// handling enums. One can forward SemaphoreError as more generic return value when a method
     /// returns a Semaphore***Error.
-    /// On a higher level it is again convertable to [`crate::Error`].
+    /// On a higher level it is again convertible to [`crate::Error`].
     SemaphoreError
   generalization:
     FailedToCreate <= NamedSemaphoreCreationError; UnnamedSemaphoreCreationError,

iceoryx2-bb/posix/src/signal.rs

@@ -248,7 +248,7 @@ enum_gen! {
     /// The SignalError enum is a generalization when one doesn't require the fine-grained error
     /// handling enums. One can forward SignalError as more generic return value when a method
     /// returns a Signal***Error.
-    /// On a higher level it is again convertable to [`crate::Error`].
+    /// On a higher level it is again convertible to [`crate::Error`].
     SignalError
   generalization:
     FailedToRegister <= SignalRegisterError,

iceoryx2-bb/posix/src/thread.rs

@@ -260,7 +260,7 @@ enum_gen! {
     /// The ThreadError enum is a generalization when one doesn't require the fine-grained error
     /// handling enums. One can forward ThreadError as more generic return value when a method
     /// returns a Thread***Error.
-    /// On a higher level it is again convertable to [`crate::Error`].
+    /// On a higher level it is again convertible to [`crate::Error`].
     ThreadError
   generalization:
     FailedToSpawn <= ThreadSpawnError,

iceoryx2-bb/posix/src/unix_datagram_socket.rs

@@ -292,7 +292,7 @@ enum_gen! {
     /// The UnixDatagramError enum is a generalization when one doesn't require the fine-grained error
     /// handling enums. One can forward UnixDatagramError as more generic return value when a method
     /// returns a UnixDatagram***Error.
-    /// On a higher level it is again convertable to [`crate::Error`].
+    /// On a higher level it is again convertible to [`crate::Error`].
     UnixDatagramError
   generalization:
     CreationFailed <= UnixDatagramSenderCreationError; UnixDatagramReceiverCreationError,