Refactor: rename WriteResult to ClientWriteResult

`WriteResult` is public but is sealed behind a private mod,
thus this is not a breaking change.

Author: drmingdrmer

openraft/src/raft/impl_raft_blocking_write.rs

@@ -7,7 +7,7 @@ use maplit::btreemap;
 use crate::core::raft_msg::RaftMsg;
 use crate::error::ClientWriteError;
 use crate::error::RaftError;
-use crate::raft::message::WriteResult;
+use crate::raft::message::ClientWriteResult;
 use crate::raft::responder::OneshotResponder;
 use crate::raft::ClientWriteResponse;
 use crate::summary::MessageSummary;
@@ -169,7 +169,7 @@ where C: RaftTypeConfig<Responder = OneshotResponder<C>>
     }
 }
 
-fn oneshot_channel<C>() -> (OneshotResponder<C>, OneshotReceiverOf<C, WriteResult<C>>)
+fn oneshot_channel<C>() -> (OneshotResponder<C>, OneshotReceiverOf<C, ClientWriteResult<C>>)
 where C: RaftTypeConfig {
     let (tx, rx) = C::AsyncRuntime::oneshot();
 

openraft/src/raft/message/client_write.rs

@@ -11,7 +11,7 @@ use crate::MessageSummary;
 use crate::RaftTypeConfig;
 
 /// The result of a write request to Raft.
-pub type WriteResult<C> = Result<ClientWriteResponse<C>, ClientWriteError<NodeIdOf<C>, NodeOf<C>>>;
+pub type ClientWriteResult<C> = Result<ClientWriteResponse<C>, ClientWriteError<NodeIdOf<C>, NodeOf<C>>>;
 
 /// The response to a client-request.
 #[cfg_attr(

openraft/src/raft/message/mod.rs

@@ -12,7 +12,7 @@ mod client_write;
 pub use append_entries::AppendEntriesRequest;
 pub use append_entries::AppendEntriesResponse;
 pub use client_write::ClientWriteResponse;
-pub use client_write::WriteResult;
+pub use client_write::ClientWriteResult;
 pub use install_snapshot::InstallSnapshotRequest;
 pub use install_snapshot::InstallSnapshotResponse;
 pub use install_snapshot::SnapshotResponse;

openraft/src/raft/mod.rs

@@ -26,12 +26,12 @@ use core_state::CoreState;
 pub use message::AppendEntriesRequest;
 pub use message::AppendEntriesResponse;
 pub use message::ClientWriteResponse;
+pub use message::ClientWriteResult;
 pub use message::InstallSnapshotRequest;
 pub use message::InstallSnapshotResponse;
 pub use message::SnapshotResponse;
 pub use message::VoteRequest;
 pub use message::VoteResponse;
-pub use message::WriteResult;
 use tokio::sync::mpsc;
 use tokio::sync::watch;
 use tokio::sync::Mutex;
@@ -644,12 +644,12 @@ where C: RaftTypeConfig
         app_data: C::D,
     ) -> Result<ClientWriteResponse<C>, RaftError<C::NodeId, ClientWriteError<C::NodeId, C::Node>>>
     where
-        ResponderReceiverOf<C>: Future<Output = Result<WriteResult<C>, E>>,
+        ResponderReceiverOf<C>: Future<Output = Result<ClientWriteResult<C>, E>>,
         E: Error + OptionalSend,
     {
         let rx = self.client_write_ff(app_data).await?;
 
-        let res: WriteResult<C> = self.inner.recv_msg(rx).await?;
+        let res: ClientWriteResult<C> = self.inner.recv_msg(rx).await?;
 
         let client_write_response = res.map_err(RaftError::APIError)?;
         Ok(client_write_response)

openraft/src/raft/responder/impls.rs

@@ -1,5 +1,5 @@
 use crate::async_runtime::AsyncOneshotSendExt;
-use crate::raft::message::WriteResult;
+use crate::raft::message::ClientWriteResult;
 use crate::raft::responder::Responder;
 use crate::type_config::alias::AsyncRuntimeOf;
 use crate::type_config::alias::OneshotReceiverOf;
@@ -15,30 +15,30 @@ use crate::RaftTypeConfig;
 pub struct OneshotResponder<C>
 where C: RaftTypeConfig
 {
-    tx: OneshotSenderOf<C, WriteResult<C>>,
+    tx: OneshotSenderOf<C, ClientWriteResult<C>>,
 }
 
 impl<C> OneshotResponder<C>
 where C: RaftTypeConfig
 {
     /// Create a new instance from a [`AsyncRuntime::OneshotSender`].
-    pub fn new(tx: OneshotSenderOf<C, WriteResult<C>>) -> Self {
+    pub fn new(tx: OneshotSenderOf<C, ClientWriteResult<C>>) -> Self {
         Self { tx }
     }
 }
 
 impl<C> Responder<C> for OneshotResponder<C>
 where C: RaftTypeConfig
 {
-    type Receiver = OneshotReceiverOf<C, WriteResult<C>>;
+    type Receiver = OneshotReceiverOf<C, ClientWriteResult<C>>;
 
     fn from_app_data(app_data: C::D) -> (C::D, Self, Self::Receiver)
     where Self: Sized {
         let (tx, rx) = AsyncRuntimeOf::<C>::oneshot();
         (app_data, Self { tx }, rx)
     }
 
-    fn send(self, res: WriteResult<C>) {
+    fn send(self, res: ClientWriteResult<C>) {
         let res = self.tx.send(res);
 
         if res.is_ok() {

openraft/src/raft/responder/mod.rs

@@ -3,7 +3,7 @@
 pub(crate) mod impls;
 pub use impls::OneshotResponder;
 
-use crate::raft::message::WriteResult;
+use crate::raft::message::ClientWriteResult;
 use crate::OptionalSend;
 use crate::RaftTypeConfig;
 
@@ -12,7 +12,7 @@ use crate::RaftTypeConfig;
 ///
 /// It is created for each request [`AppData`], and is sent to `RaftCore`.
 /// Once the request is completed,
-/// the `RaftCore` send the result [`WriteResult`] via it.
+/// the `RaftCore` send the result [`ClientWriteResult`] via it.
 /// The implementation of the trait then forward the response to application.
 /// There could optionally be a receiver to wait for the response.
 ///
@@ -35,5 +35,5 @@ where C: RaftTypeConfig
     /// Send result when the request has been completed.
     ///
     /// This method is called by the `RaftCore` once the request has been applied to state machine.
-    fn send(self, result: WriteResult<C>);
+    fn send(self, result: ClientWriteResult<C>);
 }

openraft/src/type_config.rs

@@ -79,7 +79,7 @@ pub trait RaftTypeConfig:
     /// some application defined channel.
     ///
     /// [`Raft::client_write`]: `crate::raft::Raft::client_write`
-    /// [`WriteResult`]: `crate::raft::message::WriteResult`
+    /// [`WriteResult`]: `crate::raft::message::ClientWriteResult`
     type Responder: Responder<Self>;
 }