1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102

use collection::{Collection, MutableCollection, Sliceable};
use card::{StandardCard};
use deck::deck_creator;

///A Deck that can contain duplicate cards. For games such as canasta or black jack that use multiple decks
#[derive(Debug)]
pub struct DuplicatesAllowedDeck<T> {
    _cards: Vec<T>
}

impl<T> DuplicatesAllowedDeck<T>
{
	pub fn new() -> DuplicatesAllowedDeck<T>
	{
		DuplicatesAllowedDeck{_cards:Vec::new()}
	}

	pub fn new_standard_deck() -> DuplicatesAllowedDeck<StandardCard>
	{
		DuplicatesAllowedDeck{_cards:  deck_creator::create_standard_deck()}
	}
}

impl<T> Collection for DuplicatesAllowedDeck<T>
{
	type Item=T;
	fn size(&self) -> usize
	{
		self._cards.size()
	}
}

impl<T> MutableCollection for DuplicatesAllowedDeck<T>
{
	fn push(&mut self, item: Self::Item) -> ()
	{
		self._cards.push(item)
	}

	fn pop(&mut self) -> Option<Self::Item>
	{
		self._cards.pop()
	}

	fn insert_at(&mut self, index: usize, item: Self::Item) -> ()
	{
		self._cards.insert_at(index, item)
	}

	fn remove_at(&mut self, index:usize) -> Option<Self::Item>
	{
		self._cards.remove_at(index)
	}
}

impl<T> Sliceable for DuplicatesAllowedDeck<T>
{
	type Item = T;
	fn as_mut_slice(&mut self) -> &mut [T]
	{
		self._cards.as_mut_slice()
	}
}


#[cfg(test)]
mod deck_tests
{
	use super::{DuplicatesAllowedDeck};
	use deck::{Deck};

	use card::{StandardCard, Suit};

	#[test]
	fn ctor_test()
	{
		assert_eq!(DuplicatesAllowedDeck::<StandardCard>::new_standard_deck().size(), 52);
	}

	#[test]
	fn add_test()
	{
		let mut deck = DuplicatesAllowedDeck::<StandardCard>::new_standard_deck();
		deck.add_card_to_bottom(StandardCard::new(1, Suit::Hearts));
		assert_eq!(deck.size(), 53);
	}

	#[test]
	fn remove_card_from_bottom_test()
	{
		let mut deck = DuplicatesAllowedDeck::<StandardCard>::new_standard_deck();
		let _ = deck.remove_card_from_bottom();
		assert_eq!(deck.size(), 51);
	}

	#[test]
	fn empty_pop_test()
	{
		let mut deck = DuplicatesAllowedDeck::<u8>::new();
		assert!(deck.remove_card_from_bottom().is_none());
	}
}