Rich state completed

src/c1_state_machine/mod.rs

@@ -6,6 +6,7 @@ mod p1_switches;
 mod p2_laundry_machine;
 mod p3_atm;
 mod p4_accounted_currency;
+//todo fix 2 tests related to serial
 mod p5_digital_cash;
 mod p6_open_ended;
 

src/c1_state_machine/p1_switches.rs

@@ -15,7 +15,7 @@ impl StateMachine for LightSwitch {
 	type Transition = ();
 
 	fn next_state(starting_state: &bool, t: &()) -> bool {
-		todo!("Exercise 1")
+		!starting_state
 	}
 }
 
@@ -31,6 +31,7 @@ pub struct TwoSwitches {
 }
 
 /// Now there are two switches so we need a proper type for the transition.
+#[derive(PartialEq, Eq)]
 pub enum Toggle {
 	FirstSwitch,
 	SecondSwitch,
@@ -42,7 +43,28 @@ impl StateMachine for WeirdSwitchMachine {
 	type Transition = Toggle;
 
 	fn next_state(starting_state: &TwoSwitches, t: &Toggle) -> TwoSwitches {
-		todo!("Exercise 2")
+		let mut state = TwoSwitches {
+			first_switch: starting_state.first_switch,
+			second_switch: starting_state.second_switch,
+		};
+
+		if starting_state.first_switch == false && t == &Toggle::FirstSwitch {
+			state.first_switch = true;
+		}
+
+		if starting_state.first_switch == true && t == &Toggle::FirstSwitch {
+			state.first_switch = false;
+			state.second_switch = false;
+		}
+
+		if starting_state.second_switch == false && t == &Toggle::SecondSwitch {
+			state.second_switch = true;
+		}
+
+		if starting_state.second_switch == true && t == &Toggle::SecondSwitch {
+			state.second_switch = false;
+		}
+		return state;
 	}
 }
 

src/c1_state_machine/p2_laundry_machine.rs

@@ -24,6 +24,7 @@ pub enum ClothesState {
 }
 
 /// Something you can do with clothes
+#[derive(PartialEq, Eq)]
 pub enum ClothesAction {
 	/// Wearing clothes decreases their life by 1 and makes them dirty.
 	Wear,
@@ -40,7 +41,87 @@ impl StateMachine for ClothesMachine {
 	type Transition = ClothesAction;
 
 	fn next_state(starting_state: &ClothesState, t: &ClothesAction) -> ClothesState {
-		todo!("Exercise 3")
+		// let mut starting_state_is_clean_4 = starting_state == &ClothesState::Clean(4);
+		// let mut is_action_wear = t == &ClothesAction::Wear;
+
+		// if starting_state_is_clean_4 && is_action_wear{
+		// 	return ClothesState::Dirty(3);
+		// }
+
+		// let mut starting_state_is_dirty_4 = starting_state == &ClothesState::Dirty(4);
+
+		// if starting_state_is_dirty_4 && is_action_wear{
+		// 	return ClothesState::Dirty(3);
+		// }
+
+		// let mut starting_state_is_wet_4 =
+
+		match starting_state {
+			&ClothesState::Clean(d) => {
+				if &ClothesAction::Wear == t {
+					if d <= 1 {
+						return ClothesState::Tattered;
+					}
+					return ClothesState::Dirty(d - 1);
+				}
+				if &ClothesAction::Wash == t {
+					if d <= 1 {
+						return ClothesState::Tattered;
+					}
+					return ClothesState::Wet(d - 1);
+				}
+				if &ClothesAction::Dry == t {
+					if d <= 1 {
+						return ClothesState::Tattered;
+					}
+					return ClothesState::Clean(d - 1);
+				}
+			},
+			&ClothesState::Dirty(d) => {
+				if &ClothesAction::Wear == t {
+					if d <= 1 {
+						return ClothesState::Tattered;
+					}
+					return ClothesState::Dirty(d - 1);
+				}
+				if &ClothesAction::Wash == t {
+					if d <= 1 {
+						return ClothesState::Tattered;
+					}
+					return ClothesState::Wet(d - 1);
+				}
+				if &ClothesAction::Dry == t {
+					if d <= 1 {
+						return ClothesState::Tattered;
+					}
+					return ClothesState::Dirty(d - 1);
+				}
+			},
+			&ClothesState::Wet(d) => {
+				if &ClothesAction::Wear == t {
+					if d <= 1 {
+						return ClothesState::Tattered;
+					}
+					return ClothesState::Dirty(d - 1);
+				}
+				if &ClothesAction::Wash == t {
+					if d <= 1 {
+						return ClothesState::Tattered;
+					}
+					return ClothesState::Wet(d - 1);
+				}
+				if &ClothesAction::Dry == t {
+					if d <= 1 {
+						return ClothesState::Tattered;
+					}
+					return ClothesState::Clean(d - 1);
+				}
+			},
+			&ClothesState::Tattered => {
+				return ClothesState::Tattered;
+			},
+		};
+		todo!()
 	}
 }
 

src/c1_state_machine/p3_atm.rs

@@ -59,7 +59,101 @@ impl StateMachine for Atm {
 	type Transition = Action;
 
 	fn next_state(starting_state: &Self::State, t: &Self::Transition) -> Self::State {
-		todo!("Exercise 4")
+		match &t{
+			Action::SwipeCard(d)=>{
+				if starting_state.expected_pin_hash == Auth::Waiting{
+					let mut ret_state = Atm {
+						cash_inside: starting_state.cash_inside,
+						expected_pin_hash: Auth::Authenticating(1234),
+						keystroke_register: Vec::new(),
+					};
+					return ret_state;
+				} 
+				if starting_state.expected_pin_hash == Auth::Authenticating(1234){
+					let mut ret_state = Atm {
+						cash_inside: starting_state.cash_inside,
+						expected_pin_hash: starting_state.expected_pin_hash.clone(), 
+						keystroke_register: starting_state.keystroke_register.clone(),
+					};
+					return ret_state;
+				}
+				todo!()
+			}
+			Action::PressKey(d)=>{
+				if starting_state.expected_pin_hash == Auth::Waiting{
+					let mut ret_state = Atm {
+						cash_inside: starting_state.cash_inside,
+						expected_pin_hash: starting_state.expected_pin_hash.clone(), 
+						keystroke_register: starting_state.keystroke_register.clone(),
+					};
+					// ret_state.keystroke_register.push(d.clone());
+					return ret_state;
+				}
+				println!("Expected pin hash: {:?}", starting_state.expected_pin_hash);
+				if let Auth::Authenticating(_hash) = starting_state.expected_pin_hash {
+
+					let mut ret_state = Atm {
+						cash_inside: starting_state.cash_inside,
+						expected_pin_hash: starting_state.expected_pin_hash.clone(), 
+						keystroke_register: starting_state.keystroke_register.clone(),
+					};
+					if Key::Enter == d.clone(){
+						let actual_pinhash = crate::hash(&ret_state.keystroke_register);
+						let actual_pinhash_auth = Auth::Authenticating(actual_pinhash);
+						if actual_pinhash_auth != ret_state.expected_pin_hash{
+							ret_state.expected_pin_hash = Auth::Waiting;
+						}
+						else{
+							ret_state.expected_pin_hash = Auth::Authenticated;
+						}
+						ret_state.keystroke_register = vec![];
+						return ret_state;
+					}
+					ret_state.keystroke_register.push(d.clone());
+					return ret_state;
+				}
+
+				if starting_state.expected_pin_hash == Auth::Authenticated{
+
+					let mut ret_state = Atm {
+						cash_inside: starting_state.cash_inside,
+						expected_pin_hash: starting_state.expected_pin_hash.clone(), 
+						keystroke_register: starting_state.keystroke_register.clone(),
+					};
+					if Key::Enter == d.clone(){
+						let mut users_sum:String = "".to_string();
+						for i in ret_state.keystroke_register.iter(){
+							match i {
+								Key::One => {users_sum.push('1')},
+								Key::Two => {users_sum.push('2')},
+								Key::Three => {users_sum.push('3')},
+								Key::Four => {users_sum.push('4')},
+								_=>{}
+							};
+						}
+
+						let provided_sum = users_sum.parse::<u64>().unwrap();
+						println!("users sum {}", users_sum);
+						println!("provided sum {}", provided_sum);
+						let available_cash = ret_state.cash_inside;
+						if provided_sum > available_cash{
+							ret_state.expected_pin_hash = Auth::Waiting;
+							ret_state.keystroke_register = vec![];
+						}
+						else{
+							ret_state.cash_inside = ret_state.cash_inside - provided_sum;
+							ret_state.expected_pin_hash = Auth::Waiting;
+							ret_state.keystroke_register = vec![];
+						}
+						return ret_state;
+					}
+					ret_state.keystroke_register.push(d.clone());
+					return ret_state;
+
+				}
+				todo!()
+			}
+		}
 	}
 }
 

src/c1_state_machine/p4_accounted_currency.rs

@@ -8,7 +8,7 @@
 //! In this module we design a state machine that tracks the currency balances of several users.
 //! Each user is associated with an account balance and users are able to send money to other users.
 
-use super::{StateMachine, User};
+use super::{StateMachine, User, p5_digital_cash::Bank};
 use std::collections::HashMap;
 
 /// This state machine models a multi-user currency system. It tracks the balance of each
@@ -41,7 +41,51 @@ impl StateMachine for AccountedCurrency {
 	type Transition = AccountingTransaction;
 
 	fn next_state(starting_state: &Balances, t: &AccountingTransaction) -> Balances {
-		todo!("Exercise 1")
+		let mut ret_state = starting_state.clone();
+		match t{
+			&AccountingTransaction::Mint{minter, amount}=>{
+				let mut user_balance = ret_state.get(&minter);
+				if let Some(b) = user_balance{
+					ret_state.insert(minter, b+amount); 
+				}
+				else{
+					if amount > 0{
+						ret_state.insert(minter, amount);
+					}
+				}
+			},
+			&AccountingTransaction::Burn{burner, amount}=>{
+				let mut user_balance = ret_state.get(&burner);
+				if let Some(b) = user_balance{
+					if amount >= *b{
+						ret_state.remove(&burner);
+					}
+					else{
+						ret_state.insert(burner, b-amount);
+					}
+				}
+			}
+			&AccountingTransaction::Transfer{sender, receiver, amount}=>{
+				let mut sender_balance = ret_state.get(&sender);
+				let mut receiver_balance = ret_state.get(&receiver).unwrap_or(&0);
+				if let Some(b) = sender_balance{
+					if &amount <= b{
+						if sender == receiver{
+							return ret_state;
+						}
+						let mut new_sender_balance = b - &amount;
+						let mut new_receiver_balance = receiver_balance + &amount;
+						ret_state.insert(sender, new_sender_balance);
+						ret_state.insert(receiver, new_receiver_balance);
+						if new_sender_balance == 0{
+							ret_state.remove(&sender);
+						}
+					}
+				}
+			}
+			_=>{}
+		}
+		return ret_state;
 	}
 }