From 541e68aa116a1a4e5eed0ea5aaa8ddd7010329a8 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 23 Sep 2025 15:08:30 +0200 Subject: [PATCH] doc fixes --- src/dest.rs | 4 ++-- src/lib.rs | 16 ++++++++-------- src/source.rs | 10 +++++----- 3 files changed, 15 insertions(+), 15 deletions(-) diff --git a/src/dest.rs b/src/dest.rs index 23bc1a8..51bc911 100644 --- a/src/dest.rs +++ b/src/dest.rs @@ -9,7 +9,7 @@ //! //! A destination entity might still generate packets which need to be sent back to the source //! entity of the file transfer. However, this handler allows freedom of communication like the -//! source entity by using a user-provided [PduSendProvider] to send all generated PDUs. +//! source entity by using a user-provided [PduSender] instance to send all generated PDUs. //! //! The transaction will be finished when following conditions are met: //! @@ -322,7 +322,7 @@ pub enum DestError { /// handler and driving the state machine, which might generate new packets to be sent to the /// remote entity. Please note that the destination handler can also only process Metadata, EOF and /// Prompt PDUs in addition to ACK PDUs where the acknowledged PDU is the Finished PDU. -/// All generated packets are sent using the user provided [PduSendProvider]. +/// All generated packets are sent using the user provided [PduSender]. /// /// The handler requires the [alloc] feature but will allocated all required memory on construction /// time. This means that the handler is still suitable for embedded systems where run-time diff --git a/src/lib.rs b/src/lib.rs index 830d30d..35b4894 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -72,7 +72,7 @@ //! //! # Notes on the user hooks and scheduling //! -//! Both examples feature implementations of the [UserFaultHookProvider] and the [user::CfdpUser] +//! Both examples feature implementations of the [UserFaultHook] and the [user::CfdpUser] //! trait which simply print some information to the console to monitor the progress of a file //! copy operation. These implementations could be adapted for other handler integrations. For //! example, they could signal a GUI application to display some information for the user. @@ -314,7 +314,7 @@ pub trait RemoteConfigStore { } /// This is a thin wrapper around a [hashbrown::HashMap] to store remote entity configurations. -/// It implements the full [RemoteEntityConfigProvider] trait. +/// It implements the full [RemoteEntityConfig] trait. #[cfg(feature = "alloc")] #[derive(Default, Debug)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] @@ -343,7 +343,7 @@ impl RemoteConfigStoreStd { } /// This is a thin wrapper around a [alloc::vec::Vec] to store remote entity configurations. -/// It implements the full [RemoteEntityConfigProvider] trait. +/// It implements the full [RemoteEntityConfig] trait. #[cfg(feature = "alloc")] #[derive(Default, Debug)] #[cfg_attr(feature = "defmt", derive(defmt::Format))] @@ -388,7 +388,7 @@ impl RemoteConfigList { } /// This is a thin wrapper around a [alloc::vec::Vec] to store remote entity configurations. -/// It implements the full [RemoteEntityConfigProvider] trait. +/// It implements the full [RemoteEntityConfig] trait. #[derive(Default, Debug)] #[cfg_attr(feature = "defmt", derive(defmt::Format))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] @@ -458,7 +458,7 @@ impl RemoteConfigStore for RemoteEntityConfig { /// This trait introduces some callbacks which will be called when a particular CFDP fault /// handler is called. /// -/// It is passed into the CFDP handlers as part of the [UserFaultHookProvider] and the local entity +/// It is passed into the CFDP handlers as part of the [UserFaultHook] and the local entity /// configuration and provides a way to specify custom user error handlers. This allows to /// implement some CFDP features like fault handler logging, which would not be possible /// generically otherwise. @@ -485,7 +485,7 @@ pub trait UserFaultHook { fn ignore_cb(&mut self, transaction_id: TransactionId, cond: ConditionCode, progress: u64); } -/// Dummy fault hook which implements [UserFaultHookProvider] but only provides empty +/// Dummy fault hook which implements [UserFaultHook] but only provides empty /// implementations. #[derive(Default, Debug, PartialEq, Eq, Copy, Clone)] pub struct DummyFaultHook {} @@ -524,7 +524,7 @@ impl UserFaultHook for DummyFaultHook { /// It does so by mapping each applicable [spacepackets::cfdp::ConditionCode] to a fault handler /// which is denoted by the four [spacepackets::cfdp::FaultHandlerCode]s. This code is used /// to select the error handling inside the CFDP handler itself in addition to dispatching to a -/// user-provided callback function provided by the [UserFaultHookProvider]. +/// user-provided callback function provided by the [UserFaultHook]. /// /// Some note on the provided default settings: /// @@ -733,7 +733,7 @@ pub mod std_mod { } } - /// Simple implementation of the [CountdownProvider] trait assuming a standard runtime. + /// Simple implementation of the [Countdown] trait assuming a standard runtime. #[derive(Debug)] pub struct StdCountdown { expiry_time: Duration, diff --git a/src/source.rs b/src/source.rs index 255583b..6602929 100644 --- a/src/source.rs +++ b/src/source.rs @@ -4,7 +4,7 @@ //! [ReadablePutRequest] into all packet data units (PDUs) which need to be sent to a remote //! CFDP entity to perform a File Copy operation to a remote entity. //! -//! The source entity allows freedom communication by using a user-provided [PduSendProvider] +//! The source entity allows freedom communication by using a user-provided [PduSender] instance //! to send all generated PDUs. It should be noted that for regular file transfers, each //! [SourceHandler::state_machine] call will map to one generated file data PDU. This allows //! flow control for the user of the state machine. @@ -219,7 +219,7 @@ pub enum FsmContext { /// entity. /// /// As such, it contains a state machine to perform all operations necessary to perform a -/// source-to-destination file transfer. This class uses the user provides [PduSendProvider] to +/// source-to-destination file transfer. This class uses the user provides [PduSender] to /// send the CFDP PDU packets generated by the state machine. /// /// The following core functions are the primary interface: @@ -294,7 +294,7 @@ impl< /// # Arguments /// /// * `cfg` - The local entity configuration for this source handler. - /// * `pdu_sender` - [PduSendProvider] provider used to send CFDP PDUs generated by the handler. + /// * `pdu_sender` - [PduSender] used to send CFDP PDUs generated by the handler. /// * `vfs` - [VirtualFilestore] implementation used by the handler, which decouples the CFDP /// implementation from the underlying filestore/filesystem. This allows to use this handler /// for embedded systems where a standard runtime might not be available. @@ -304,9 +304,9 @@ impl< /// checksum calculations. The user can specify the size of this buffer, so this should be /// set to the maximum expected PDU size or a conservative upper bound for this size, for /// example 2048 or 4096 bytes. - /// * `remote_cfg_table` - The [RemoteEntityConfigProvider] used to look up remote + /// * `remote_cfg_table` - The [RemoteEntityConfig] used to look up remote /// entities and target specific configuration for file copy operations. - /// * `timer_creator` - [TimerCreatorProvider] used by the CFDP handler to generate + /// * `timer_creator` - [TimerCreator] used by the CFDP handler to generate /// timers required by various tasks. This allows to use this handler for embedded systems /// where the standard time APIs might not be available. /// * `seq_count_provider` - The [SequenceCounter] used to generate the [TransactionId]