Merge v0.1.1 into master

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mode"
-version = "0.1.0"
+version = "0.1.1"
 authors = ["Andrew Thomas Christensen <[email protected]>"]
 edition = "2018"
 

README.md

@@ -36,7 +36,7 @@ impl Mode for Working {
     fn as_base_mut(&mut self) -> &mut Self::Base { self }
 
     // This function allows the current Mode to swap to another Mode, when ready.
-    fn get_transition(&mut self) -> Option<Box<Transition<Self>>> {
+    fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>> {
         if self.hours_worked == 4 || self.hours_worked >= 8 {
             // To swap to another Mode, a Transition function is returned, which will consume
             // the current Mode and return a new Mode to be swapped in as active.
@@ -61,7 +61,7 @@ impl Mode for Eating {
     type Base = Activity;
     fn as_base(&self) -> &Self::Base { self }
     fn as_base_mut(&mut self) -> &mut Self::Base { self }
-    fn get_transition(&mut self) -> Option<Box<Transition<Self>>> {
+    fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>> {
         if self.calories_consumed >= 500 {
             if self.hours_worked >= 8 {
                 // Time for bed!
@@ -90,7 +90,7 @@ impl Mode for Sleeping {
     type Base = Activity;
     fn as_base(&self) -> &Self::Base { self }
     fn as_base_mut(&mut self) -> &mut Self::Base { self }
-    fn get_transition(&mut self) -> Option<Box<Transition<Self>>> {
+    fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>> {
         if self.hours_rested >= 8 {
             // Time for breakfast!
             Some(Box::new(|_| { Eating { hours_worked: 0, calories_consumed: 0 } }))

examples/counter.rs

@@ -35,7 +35,7 @@ impl Mode for UpMode {
     type Base = CounterMode;
     fn as_base(&self) -> &Self::Base { self }
     fn as_base_mut(&mut self) -> &mut Self::Base { self }
-    fn get_transition(&mut self) -> Option<Box<Transition<Self>>> {
+    fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>> {
         if self.counter == self.target {
             // If we've reached the target value, start counting down to (roughly) the median value.
             Some(Box::new(
@@ -68,7 +68,7 @@ impl Mode for DownMode {
     type Base = CounterMode;
     fn as_base(&self) -> &Self::Base { self }
     fn as_base_mut(&mut self) -> &mut Self::Base { self }
-    fn get_transition(&mut self) -> Option<Box<Transition<Self>>> {
+    fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>> {
         const GOAL : i32 = 10;
         if self.counter == GOAL {
             // When we finally count down to the goal value, end the program by swapping in a "finished" state.
@@ -107,7 +107,7 @@ impl Mode for FinishedMode {
     type Base = CounterMode;
     fn as_base(&self) -> &Self::Base { self }
     fn as_base_mut(&mut self) -> &mut Self::Base { self }
-    fn get_transition(&mut self) -> Option<Box<Transition<Self>>> {
+    fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>> {
         // We're finished calculating, so we never want to transition.
         None
     }

src/automaton.rs

@@ -48,7 +48,7 @@ use std::fmt;
 /// #     type Base = MyMode;
 /// #     fn as_base(&self) -> &Self::Base { self }
 /// #     fn as_base_mut(&mut self) -> &mut Self::Base { self }
-/// #     fn get_transition(&mut self) -> Option<Box<Transition<Self>>> { None }
+/// #     fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>> { None }
 /// # }
 /// # 
 /// // Use with_initial_mode() to create the Automaton with an initial state.
@@ -65,7 +65,7 @@ use std::fmt;
 pub struct Automaton<Base>
     where Base : ?Sized
 {
-    current_mode : Box<AnyModeWrapper<Base = Base>>,
+    current_mode : Box<dyn AnyModeWrapper<Base = Base>>,
 }
 
 impl<Base> Automaton<Base>
@@ -130,7 +130,7 @@ impl<Base> Automaton<Base>
     ///     type Base = Self;
     ///     fn as_base(&self) -> &Self { self }
     ///     fn as_base_mut(&mut self) -> &mut Self { self }
-    ///     fn get_transition(&mut self) -> Option<Box<Transition<Self>>> {
+    ///     fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>> {
     ///         // TODO: Logic for transitioning between states goes here.
     ///         Some(Box::new(
     ///             |previous : Self| {
@@ -195,7 +195,7 @@ impl<Base> Default for Automaton<Base>
 ///     type Base = MyBase;
 ///     fn as_base(&self) -> &Self::Base { self }
 ///     fn as_base_mut(&mut self) -> &mut Self::Base { self }
-///     fn get_transition(&mut self) -> Option<Box<Transition<Self>>> { None } // TODO
+///     fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>> { None } // TODO
 /// }
 /// 
 /// let automaton = Automaton::with_initial_mode(MyMode { foo: 3, bar: "Hello, World!" });

src/lib.rs

@@ -39,7 +39,7 @@
 //!     fn as_base_mut(&mut self) -> &mut Self::Base { self }
 //! 
 //!     // This function allows the current Mode to swap to another Mode, when ready.
-//!     fn get_transition(&mut self) -> Option<Box<Transition<Self>>> {
+//!     fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>> {
 //!         if self.hours_worked == 4 || self.hours_worked >= 8 {
 //!             // To swap to another Mode, a Transition function is returned, which will consume
 //!             // the current Mode and return a new Mode to be swapped in as active.
@@ -64,7 +64,7 @@
 //!     type Base = Activity;
 //!     fn as_base(&self) -> &Self::Base { self }
 //!     fn as_base_mut(&mut self) -> &mut Self::Base { self }
-//!     fn get_transition(&mut self) -> Option<Box<Transition<Self>>> {
+//!     fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>> {
 //!         if self.calories_consumed >= 500 {
 //!             if self.hours_worked >= 8 {
 //!                 // Time for bed!
@@ -93,7 +93,7 @@
 //!     type Base = Activity;
 //!     fn as_base(&self) -> &Self::Base { self }
 //!     fn as_base_mut(&mut self) -> &mut Self::Base { self }
-//!     fn get_transition(&mut self) -> Option<Box<Transition<Self>>> {
+//!     fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>> {
 //!         if self.hours_rested >= 8 {
 //!             // Time for breakfast!
 //!             Some(Box::new(|_| { Eating { hours_worked: 0, calories_consumed: 0 } }))

src/mode.rs

@@ -38,7 +38,7 @@ use crate::Transition;
 ///     type Base = MyMode;
 ///     fn as_base(&self) -> &Self::Base { self }
 ///     fn as_base_mut(&mut self) -> &mut Self::Base { self }
-///     fn get_transition(&mut self) -> Option<Box<Transition<Self>>> {
+///     fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>> {
 ///         // Transition to ModeB. ModeA can swap to ModeB because both share the same Base.
 ///         Some(Box::new(|previous : Self| { ModeB }))
 ///     }
@@ -51,7 +51,7 @@ use crate::Transition;
 ///     type Base = MyMode;
 ///     fn as_base(&self) -> &Self::Base { self }
 ///     fn as_base_mut(&mut self) -> &mut Self::Base { self }
-///     fn get_transition(&mut self) -> Option<Box<Transition<Self>>> { None } // None means don't transition.
+///     fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>> { None } // None means don't transition.
 /// }
 /// ```
 /// 
@@ -80,8 +80,8 @@ use crate::Transition;
 pub trait Mode : 'static {
     /// Represents the user-facing interface for the `Mode` that will be exposed via the `Automaton`. In order to be
     /// used with an `Automaton`, the `Base` type of the `Mode` **must** match the `Base` type of the `Automaton`. This
-    /// is so that the `Automaton` can provide `get_mode()` and `get_mode_mut()` functions that return a reference to
-    /// the `Mode` as the `Base` type.
+    /// is so that the `Automaton` can provide `borrow_mode()` and `borrow_mode_mut()` functions that return a reference
+    /// to the `Mode` as the `Base` type.
     /// 
     type Base : ?Sized;
 
@@ -100,5 +100,5 @@ pub trait Mode : 'static {
     /// 
     /// See [`Transition`](trait.Transition.html) for more details.
     /// 
-    fn get_transition(&mut self) -> Option<Box<Transition<Self>>>;
+    fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>>;
 }

src/mode_wrapper.rs

@@ -26,7 +26,7 @@ pub trait AnyModeWrapper {
     /// this yields a `Transition`, the `Transition` will be called on the inner `Mode` and a new `ModeWrapper` around
     /// the `Mode` to be swapped in will be returned.
     /// 
-    fn perform_transitions(&mut self) -> Option<Box<AnyModeWrapper<Base = Self::Base>>>;
+    fn perform_transitions(&mut self) -> Option<Box<dyn AnyModeWrapper<Base = Self::Base>>>;
 }
 
 /// Wraps a specific instance of `Mode`, allowing the parent `Automaton` to handle `Transition`s between that instance
@@ -66,7 +66,7 @@ impl<T> AnyModeWrapper for ModeWrapper<T>
         self.mode.as_mut().unwrap().as_base_mut()
     }
 
-    fn perform_transitions(&mut self) -> Option<Box<AnyModeWrapper<Base = Self::Base>>> {
+    fn perform_transitions(&mut self) -> Option<Box<dyn AnyModeWrapper<Base = Self::Base>>> {
         // Retrieve the desired transition, if any, from the inner Mode.
         match self.mode.as_mut().unwrap().get_transition() {
             None => None,

src/transition.rs

@@ -40,7 +40,7 @@ use crate::{AnyModeWrapper, Mode, ModeWrapper};
 /// #   fn as_base(&self) -> &Self::Base { self }
 /// #   fn as_base_mut(&mut self) -> &mut Self::Base { self }
 ///     // ...
-///     fn get_transition(&mut self) -> Option<Box<Transition<Self>>> {
+///     fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>> {
 /// #       let some_condition = true;
 /// #       let some_other_condition = true;
 ///         // ...
@@ -65,7 +65,7 @@ use crate::{AnyModeWrapper, Mode, ModeWrapper};
 /// #     type Base = MyMode;
 /// #     fn as_base(&self) -> &Self::Base { self }
 /// #     fn as_base_mut(&mut self) -> &mut Self::Base { self }
-/// #     fn get_transition(&mut self) -> Option<Box<Transition<Self>>> { None }
+/// #     fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>> { None }
 /// # }
 /// #
 /// # struct YetAnotherMode;
@@ -75,7 +75,7 @@ use crate::{AnyModeWrapper, Mode, ModeWrapper};
 /// #     type Base = MyMode;
 /// #     fn as_base(&self) -> &Self::Base { self }
 /// #     fn as_base_mut(&mut self) -> &mut Self::Base { self }
-/// #     fn get_transition(&mut self) -> Option<Box<Transition<Self>>> { None }
+/// #     fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>> { None }
 /// # }
 /// ```
 /// 
@@ -103,7 +103,7 @@ use crate::{AnyModeWrapper, Mode, ModeWrapper};
 /// # }
 /// #
 /// struct SomeMode {
-///     queued_transition : Option<Box<Transition<Self>>>
+///     queued_transition : Option<Box<dyn Transition<Self>>>
 /// }
 /// 
 /// impl MyMode for SomeMode {
@@ -124,7 +124,7 @@ use crate::{AnyModeWrapper, Mode, ModeWrapper};
 /// #   fn as_base(&self) -> &Self::Base { self }
 /// #   fn as_base_mut(&mut self) -> &mut Self::Base { self }
 ///     // ...
-///     fn get_transition(&mut self) -> Option<Box<Transition<Self>>> {
+///     fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>> {
 /// #       let ready_to_transition = true;
 ///         // ...
 ///         if ready_to_transition && self.queued_transition.is_some() {
@@ -142,7 +142,7 @@ use crate::{AnyModeWrapper, Mode, ModeWrapper};
 /// #     type Base = MyMode;
 /// #     fn as_base(&self) -> &Self::Base { self }
 /// #     fn as_base_mut(&mut self) -> &mut Self::Base { self }
-/// #     fn get_transition(&mut self) -> Option<Box<Transition<Self>>> { None }
+/// #     fn get_transition(&mut self) -> Option<Box<dyn Transition<Self>>> { None }
 /// # }
 /// ```
 /// 
@@ -157,7 +157,7 @@ pub trait Transition<A>
     /// implementation details of the `Automaton`. Unfortunately, that isn't possible, in this case, because the `Mode`
     /// trait cannot be made into an object, and therefore cannot be boxed.
     /// 
-    fn invoke(self : Box<Self>, mode : A) -> Box<AnyModeWrapper<Base = A::Base>>;
+    fn invoke(self : Box<Self>, mode : A) -> Box<dyn AnyModeWrapper<Base = A::Base>>;
 }
 
 impl<T, A, B> Transition<A> for T
@@ -166,7 +166,7 @@ impl<T, A, B> Transition<A> for T
         A : Mode,
         B : Mode<Base = A::Base>,
 {
-    fn invoke(self : Box<Self>, mode : A) -> Box<AnyModeWrapper<Base = A::Base>> {
+    fn invoke(self : Box<Self>, mode : A) -> Box<dyn AnyModeWrapper<Base = A::Base>> {
         // Call the transition function and wrap the result with a ModeWrapper.
         Box::new(ModeWrapper::<B>::new((self)(mode)))
     }