Fix misspelling of 'occurred' in public interface

[rust-lightning] / lightning / src / ln / peer_handler.rs

diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs
index b977f791389f2eadade27b0d739539f441341290..03470588a0abff86a3e7488160a0fe81dd12994e 100644 (file)
--- a/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@ -42,7 +42,7 @@ use bitcoin::hashes::{HashEngine, Hash};
 
 /// A dummy struct which implements `RoutingMessageHandler` without storing any routing information
 /// or doing any processing. You can provide one of these as the route_handler in a MessageHandler.
-struct IgnoringMessageHandler{}
+pub struct IgnoringMessageHandler{}
 impl MessageSendEventsProvider for IgnoringMessageHandler {
        fn get_and_clear_pending_msg_events(&self) -> Vec<MessageSendEvent> { Vec::new() }
 }
@@ -67,7 +67,7 @@ impl Deref for IgnoringMessageHandler {
 
 /// A dummy struct which implements `ChannelMessageHandler` without having any channels.
 /// You can provide one of these as the route_handler in a MessageHandler.
-struct ErroringMessageHandler {
+pub struct ErroringMessageHandler {
        message_queue: Mutex<Vec<MessageSendEvent>>
 }
 impl ErroringMessageHandler {
@@ -293,7 +293,7 @@ fn _check_usize_is_32_or_64() {
 /// lifetimes). Other times you can afford a reference, which is more efficient, in which case
 /// SimpleRefPeerManager is the more appropriate type. Defining these type aliases prevents
 /// issues such as overly long function definitions.
-pub type SimpleArcPeerManager<SD, M, T, F, C, L> = Arc<PeerManager<SD, SimpleArcChannelManager<M, T, F, L>, Arc<NetGraphMsgHandler<Arc<C>, Arc<L>>>, Arc<L>>>;
+pub type SimpleArcPeerManager<SD, M, T, F, C, L> = PeerManager<SD, Arc<SimpleArcChannelManager<M, T, F, L>>, Arc<NetGraphMsgHandler<Arc<C>, Arc<L>>>, Arc<L>>;
 
 /// SimpleRefPeerManager is a type alias for a PeerManager reference, and is the reference
 /// counterpart to the SimpleArcPeerManager type alias. Use this type by default when you don't
@@ -1345,7 +1345,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
        /// It will send pings to each peer and disconnect those which did not respond to the last round of pings.
 
        /// Will most likely call send_data on all of the registered descriptors, thus, be very careful with reentrancy issues!
-       pub fn timer_tick_occured(&self) {
+       pub fn timer_tick_occurred(&self) {
                let mut peers_lock = self.peers.lock().unwrap();
                {
                        let peers = &mut *peers_lock;
@@ -1518,11 +1518,11 @@ mod tests {
                assert_eq!(peers[0].peers.lock().unwrap().peers.len(), 1);
 
                // peers[0] awaiting_pong is set to true, but the Peer is still connected
-               peers[0].timer_tick_occured();
+               peers[0].timer_tick_occurred();
                assert_eq!(peers[0].peers.lock().unwrap().peers.len(), 1);
 
-               // Since timer_tick_occured() is called again when awaiting_pong is true, all Peers are disconnected
-               peers[0].timer_tick_occured();
+               // Since timer_tick_occurred() is called again when awaiting_pong is true, all Peers are disconnected
+               peers[0].timer_tick_occurred();
                assert_eq!(peers[0].peers.lock().unwrap().peers.len(), 0);
        }