Rust状态机实现源码

enum Message {
  PlaceOrder,
  Verify(Verify),
  FinalConfirmation,
  Cancel,
}
enum Verify {
 Address,
 PaymentDetails,
}

struct Placed {
  is_address_present: bool,
  is_payment_ok: bool,
  is_canceled: bool,
}
impl Placed {
  fn new() -> Self {
    Self {
      is_address_present: false,
      is_payment_ok: false,
      is_canceled: false,
    }
  }
}
impl State<Types> for Placed {
  fn deliver(
    &mut self,
    message: Message,
  ) -> DeliveryStatus<Message, <Types as StateTypes>::Err> {
    match message {
      Message::Cancel => self.is_canceled = true,
      Message::Verify(Verify::Address) => self.is_address_present = true,
      Message::Verify(Verify::PaymentDetails) => self.is_payment_ok = true,
      _ => return DeliveryStatus::Unexpected(message),
    }
    DeliveryStatus::Delivered
  }
  fn advance(&self) -> Result<Transition<Types>, <Types as StateTypes>::Err> {
    if self.is_canceled {
      return Ok(Transition::Next(Box::new(Canceled)));
    }
    Ok(if self.is_payment_ok && self.is_address_present {
        Transition::Next(Box::new(Verified::new()))
      } else {
        Transition::Same
      }
    )
  }
}

// Initial state.
let on_display = OnDisplay::new();
// Fake a feed of un-ordered messages.
let mut feed = VecDeque::from(vec![
  Message::Verify(Verify::Address),
  Message::PlaceOrder,
  Message::FinalConfirmation,
  Message::Verify(Verify::PaymentDetails),
]);
let mut feeding_interval = time::interval(Duration::from_millis(100));
feeding_interval.tick().await;
let mut state_machine_runner = TimeBoundStateMachineRunner::new(
  “Order”.to_string(),
  Box::new(on_display),
  Duration::from_secs(5), // time budget
);
let (state_machine_tx, mut state_machine_rx) =    
  mpsc::unbounded_channel();                                     state_machine_runner.run(state_machine_tx);
                                                                   let res: TimeBoundStateMachineResult<Types> = loop {                                          
  select! {                                              
    Some(Either::Result{ result, ..} ) = 
      state_machine_rx.recv() => { break result; }                                               
    _ = feeding_interval.tick() => {                                                 
      // feed a message if present.                                                 
      if let Some(msg) = feed.pop_front() {                                                     
        let _ = state_machine_runner.deliver(msg);                                                      
      }
    }
  }
};
let order = res.unwrap_or_else(
  |_| panic!(“State machine did not complete in time”)
);
assert!(order.is::<Shipped>());