target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void allCards() { Assert.assertEquals(this.jdkDeck.getCards(), this.acDeck.getCards()); }
|
public List<Card> getCards() { return this.cards; }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } ApacheCommonsDeckOfCardsAsList(); }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
@Test public void cardsAreImmutable() { var acCards = this.acDeck.getCards(); Verify.assertThrows( UnsupportedOperationException.class, () -> acCards.remove(0)); Verify.assertThrows( UnsupportedOperationException.class, acCards::clear); Verify.assertThrows( UnsupportedOperationException.class, () -> acCards.add(null)); }
|
public List<Card> getCards() { return this.cards; }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } ApacheCommonsDeckOfCardsAsList(); }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
@Test public void diamonds() { Assert.assertEquals(this.jdkDeck.diamonds(), this.acDeck.diamonds()); }
|
public List<Card> diamonds() { return null; }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> diamonds() { return null; } }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> diamonds() { return null; } ApacheCommonsDeckOfCardsAsList(); }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> diamonds() { return null; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> diamonds() { return null; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
@Test public void hearts() { Assert.assertEquals(this.jdkDeck.hearts(), this.acDeck.hearts()); }
|
public List<Card> hearts() { return null; }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> hearts() { return null; } }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> hearts() { return null; } ApacheCommonsDeckOfCardsAsList(); }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> hearts() { return null; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> hearts() { return null; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
@Test public void diamonds() { Assert.assertEquals(this.jdkDeck.diamonds(), this.ecDeck.diamonds()); }
|
public ImmutableList<Card> diamonds() { return null; }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Card> diamonds() { return null; } }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Card> diamonds() { return null; } EclipseCollectionsDeckOfCardsAsList(); }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Card> diamonds() { return null; } EclipseCollectionsDeckOfCardsAsList(); MutableStack<Card> shuffle(Random random); MutableSet<Card> deal(MutableStack<Card> stack, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(
MutableStack<Card> shuffled,
int hands,
int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Bag<Suit> countsBySuit(); Bag<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Card> diamonds() { return null; } EclipseCollectionsDeckOfCardsAsList(); MutableStack<Card> shuffle(Random random); MutableSet<Card> deal(MutableStack<Card> stack, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(
MutableStack<Card> shuffled,
int hands,
int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Bag<Suit> countsBySuit(); Bag<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void spades() { Assert.assertEquals(this.jdkDeck.spades(), this.acDeck.spades()); }
|
public List<Card> spades() { return null; }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> spades() { return null; } }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> spades() { return null; } ApacheCommonsDeckOfCardsAsList(); }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> spades() { return null; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> spades() { return null; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
@Test public void clubs() { Assert.assertEquals(this.jdkDeck.clubs(), this.acDeck.clubs()); }
|
public List<Card> clubs() { return null; }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> clubs() { return null; } }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> clubs() { return null; } ApacheCommonsDeckOfCardsAsList(); }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> clubs() { return null; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
ApacheCommonsDeckOfCardsAsList { public List<Card> clubs() { return null; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
@Test public void deal() { var jdkShuffle = this.jdkDeck.shuffle(new Random(1)); var acShuffle = this.acDeck.shuffle(new Random(1)); var jdkHand = this.jdkDeck.deal(jdkShuffle, 5); var acHand = this.acDeck.deal(acShuffle, 5); Assert.assertEquals(jdkHand, acHand); }
|
public Set<Card> deal(Deque<Card> deque, int count) { var hand = new HashSet<Card>(); IntStream.range(0, count).forEach(i -> hand.add(deque.pop())); return hand; }
|
ApacheCommonsDeckOfCardsAsList { public Set<Card> deal(Deque<Card> deque, int count) { var hand = new HashSet<Card>(); IntStream.range(0, count).forEach(i -> hand.add(deque.pop())); return hand; } }
|
ApacheCommonsDeckOfCardsAsList { public Set<Card> deal(Deque<Card> deque, int count) { var hand = new HashSet<Card>(); IntStream.range(0, count).forEach(i -> hand.add(deque.pop())); return hand; } ApacheCommonsDeckOfCardsAsList(); }
|
ApacheCommonsDeckOfCardsAsList { public Set<Card> deal(Deque<Card> deque, int count) { var hand = new HashSet<Card>(); IntStream.range(0, count).forEach(i -> hand.add(deque.pop())); return hand; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
ApacheCommonsDeckOfCardsAsList { public Set<Card> deal(Deque<Card> deque, int count) { var hand = new HashSet<Card>(); IntStream.range(0, count).forEach(i -> hand.add(deque.pop())); return hand; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
@Test public void shuffleAndDealHands() { var jdkHands = this.jdkDeck.shuffleAndDeal(new Random(1), 5, 5); var acHands = this.acDeck.shuffleAndDeal(new Random(1), 5, 5); Assert.assertEquals(jdkHands, acHands); }
|
public List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); }
|
ApacheCommonsDeckOfCardsAsList { public List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } }
|
ApacheCommonsDeckOfCardsAsList { public List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } ApacheCommonsDeckOfCardsAsList(); }
|
ApacheCommonsDeckOfCardsAsList { public List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
ApacheCommonsDeckOfCardsAsList { public List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
@Test public void dealHands() { var jdkShuffled = this.jdkDeck.shuffle(new Random(1)); var acShuffled = this.acDeck.shuffle(new Random(1)); var jdkHands = this.jdkDeck.dealHands(jdkShuffled, 5, 5); var acHands = this.acDeck.dealHands(acShuffled, 5, 5); Assert.assertEquals(jdkHands, acHands); }
|
public List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { return null; }
|
ApacheCommonsDeckOfCardsAsList { public List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { return null; } }
|
ApacheCommonsDeckOfCardsAsList { public List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { return null; } ApacheCommonsDeckOfCardsAsList(); }
|
ApacheCommonsDeckOfCardsAsList { public List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { return null; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
ApacheCommonsDeckOfCardsAsList { public List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { return null; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
@Test public void cardsBySuit() { var jdkCardsBySuit = this.jdkDeck.getCardsBySuit(); var acCardsBySuit = this.acDeck.getCardsBySuit(); Assert.assertEquals(jdkCardsBySuit.get(Suit.CLUBS), new ArrayList<>(acCardsBySuit.get(Suit.CLUBS))); }
|
public MultiValuedMap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; }
|
ApacheCommonsDeckOfCardsAsList { public MultiValuedMap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } }
|
ApacheCommonsDeckOfCardsAsList { public MultiValuedMap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } ApacheCommonsDeckOfCardsAsList(); }
|
ApacheCommonsDeckOfCardsAsList { public MultiValuedMap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
ApacheCommonsDeckOfCardsAsList { public MultiValuedMap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
@Test public void cardsBySuitIsImmutable() { var acCardsBySuit = this.acDeck.getCardsBySuit(); Verify.assertThrows( UnsupportedOperationException.class, () -> acCardsBySuit.remove(Suit.CLUBS)); Verify.assertThrows( UnsupportedOperationException.class, acCardsBySuit::clear); Verify.assertThrows( UnsupportedOperationException.class, () -> acCardsBySuit.get(Suit.CLUBS).remove(0)); Verify.assertThrows( UnsupportedOperationException.class, () -> acCardsBySuit.get(Suit.CLUBS).add(null)); Verify.assertThrows( UnsupportedOperationException.class, acCardsBySuit.get(Suit.CLUBS)::clear); }
|
public MultiValuedMap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; }
|
ApacheCommonsDeckOfCardsAsList { public MultiValuedMap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } }
|
ApacheCommonsDeckOfCardsAsList { public MultiValuedMap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } ApacheCommonsDeckOfCardsAsList(); }
|
ApacheCommonsDeckOfCardsAsList { public MultiValuedMap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
ApacheCommonsDeckOfCardsAsList { public MultiValuedMap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
@Test public void countsBySuit() { Assert.assertEquals( this.jdkDeck.countsBySuit().get(Suit.CLUBS).intValue(), this.acDeck.countsBySuit().getCount(Suit.CLUBS)); }
|
public Bag<Suit> countsBySuit() { return null; }
|
ApacheCommonsDeckOfCardsAsList { public Bag<Suit> countsBySuit() { return null; } }
|
ApacheCommonsDeckOfCardsAsList { public Bag<Suit> countsBySuit() { return null; } ApacheCommonsDeckOfCardsAsList(); }
|
ApacheCommonsDeckOfCardsAsList { public Bag<Suit> countsBySuit() { return null; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
ApacheCommonsDeckOfCardsAsList { public Bag<Suit> countsBySuit() { return null; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
@Test public void countsByRank() { Assert.assertEquals( this.jdkDeck.countsByRank().get(Rank.TEN).intValue(), this.acDeck.countsByRank().getCount(Rank.EIGHT)); }
|
public MultiSet<Rank> countsByRank() { return null; }
|
ApacheCommonsDeckOfCardsAsList { public MultiSet<Rank> countsByRank() { return null; } }
|
ApacheCommonsDeckOfCardsAsList { public MultiSet<Rank> countsByRank() { return null; } ApacheCommonsDeckOfCardsAsList(); }
|
ApacheCommonsDeckOfCardsAsList { public MultiSet<Rank> countsByRank() { return null; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
ApacheCommonsDeckOfCardsAsList { public MultiSet<Rank> countsByRank() { return null; } ApacheCommonsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Bag<Suit> countsBySuit(); MultiSet<Rank> countsByRank(); List<Card> getCards(); MultiValuedMap<Suit, Card> getCardsBySuit(); }
|
@Test public void allCards() { Assert.assertEquals(this.jdkDeck.getCards(), this.ggDeck.getCards()); }
|
public ImmutableList<Card> getCards() { return this.cards; }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> getCards() { return this.cards; } }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> getCards() { return this.cards; } GoogleGuavaDeckOfCardsAsList(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> getCards() { return this.cards; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> getCards() { return this.cards; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void hearts() { Assert.assertEquals(this.jdkDeck.hearts(), this.ecDeck.hearts()); }
|
public ImmutableList<Card> hearts() { return null; }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Card> hearts() { return null; } }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Card> hearts() { return null; } EclipseCollectionsDeckOfCardsAsList(); }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Card> hearts() { return null; } EclipseCollectionsDeckOfCardsAsList(); MutableStack<Card> shuffle(Random random); MutableSet<Card> deal(MutableStack<Card> stack, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(
MutableStack<Card> shuffled,
int hands,
int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Bag<Suit> countsBySuit(); Bag<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Card> hearts() { return null; } EclipseCollectionsDeckOfCardsAsList(); MutableStack<Card> shuffle(Random random); MutableSet<Card> deal(MutableStack<Card> stack, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(
MutableStack<Card> shuffled,
int hands,
int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Bag<Suit> countsBySuit(); Bag<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void cardsAreImmutable() { var ggCards = this.ggDeck.getCards(); Verify.assertThrows( UnsupportedOperationException.class, () -> ggCards.remove(0)); Verify.assertThrows( UnsupportedOperationException.class, ggCards::clear); Verify.assertThrows( UnsupportedOperationException.class, () -> ggCards.add(null)); }
|
public ImmutableList<Card> getCards() { return this.cards; }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> getCards() { return this.cards; } }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> getCards() { return this.cards; } GoogleGuavaDeckOfCardsAsList(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> getCards() { return this.cards; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> getCards() { return this.cards; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void diamonds() { Assert.assertEquals(this.jdkDeck.diamonds(), this.ggDeck.diamonds()); }
|
public ImmutableList<Card> diamonds() { return null; }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> diamonds() { return null; } }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> diamonds() { return null; } GoogleGuavaDeckOfCardsAsList(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> diamonds() { return null; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> diamonds() { return null; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void hearts() { Assert.assertEquals(this.jdkDeck.hearts(), this.ggDeck.hearts()); }
|
public ImmutableList<Card> hearts() { return null; }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> hearts() { return null; } }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> hearts() { return null; } GoogleGuavaDeckOfCardsAsList(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> hearts() { return null; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> hearts() { return null; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void spades() { Assert.assertEquals(this.jdkDeck.spades(), this.ggDeck.spades()); }
|
public ImmutableList<Card> spades() { return null; }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> spades() { return null; } }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> spades() { return null; } GoogleGuavaDeckOfCardsAsList(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> spades() { return null; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> spades() { return null; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void clubs() { Assert.assertEquals(this.jdkDeck.clubs(), this.ggDeck.clubs()); }
|
public ImmutableList<Card> clubs() { return null; }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> clubs() { return null; } }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> clubs() { return null; } GoogleGuavaDeckOfCardsAsList(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> clubs() { return null; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Card> clubs() { return null; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void deal() { var jdkShuffle = this.jdkDeck.shuffle(new Random(1)); var ggShuffle = this.ggDeck.shuffle(new Random(1)); var jdkHand = this.jdkDeck.deal(jdkShuffle, 5); var ggHand = this.ggDeck.deal(ggShuffle, 5); Assert.assertEquals(jdkHand, ggHand); }
|
public Set<Card> deal(Deque<Card> deque, int count) { var hand = new HashSet<Card>(); IntStream.range(0, count).forEach(i -> hand.add(deque.pop())); return hand; }
|
GoogleGuavaDeckOfCardsAsList { public Set<Card> deal(Deque<Card> deque, int count) { var hand = new HashSet<Card>(); IntStream.range(0, count).forEach(i -> hand.add(deque.pop())); return hand; } }
|
GoogleGuavaDeckOfCardsAsList { public Set<Card> deal(Deque<Card> deque, int count) { var hand = new HashSet<Card>(); IntStream.range(0, count).forEach(i -> hand.add(deque.pop())); return hand; } GoogleGuavaDeckOfCardsAsList(); }
|
GoogleGuavaDeckOfCardsAsList { public Set<Card> deal(Deque<Card> deque, int count) { var hand = new HashSet<Card>(); IntStream.range(0, count).forEach(i -> hand.add(deque.pop())); return hand; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
GoogleGuavaDeckOfCardsAsList { public Set<Card> deal(Deque<Card> deque, int count) { var hand = new HashSet<Card>(); IntStream.range(0, count).forEach(i -> hand.add(deque.pop())); return hand; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void shuffleAndDealHands() { var jdkHands = this.jdkDeck.shuffleAndDeal(new Random(1), 5, 5); var ggHands = this.ggDeck.shuffleAndDeal(new Random(1), 5, 5); Assert.assertEquals(jdkHands, ggHands); }
|
public ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } GoogleGuavaDeckOfCardsAsList(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void dealHands() { var jdkShuffled = this.jdkDeck.shuffle(new Random(1)); var ggShuffled = this.ggDeck.shuffle(new Random(1)); var jdkHands = this.jdkDeck.dealHands(jdkShuffled, 5, 5); var ggHands = this.ggDeck.dealHands(ggShuffled, 5, 5); Assert.assertEquals(jdkHands, ggHands); }
|
public ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { return null; }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { return null; } }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { return null; } GoogleGuavaDeckOfCardsAsList(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { return null; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { return null; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void cardsBySuit() { var jdkCardsBySuit = this.jdkDeck.getCardsBySuit(); var ggCardsBySuit = this.ggDeck.getCardsBySuit(); Assert.assertEquals(jdkCardsBySuit.get(Suit.CLUBS), ggCardsBySuit.get(Suit.CLUBS)); }
|
public ImmutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } GoogleGuavaDeckOfCardsAsList(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void cardsBySuitIsImmutable() { var ggCardsBySuit = this.ggDeck.getCardsBySuit(); Verify.assertThrows( UnsupportedOperationException.class, () -> ggCardsBySuit.removeAll(Suit.CLUBS)); Verify.assertThrows( UnsupportedOperationException.class, ggCardsBySuit::clear); Verify.assertThrows( UnsupportedOperationException.class, () -> ggCardsBySuit.get(Suit.CLUBS).remove(0)); Verify.assertThrows( UnsupportedOperationException.class, () -> ggCardsBySuit.get(Suit.CLUBS).add(null)); Verify.assertThrows( UnsupportedOperationException.class, ggCardsBySuit.get(Suit.CLUBS)::clear); }
|
public ImmutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } GoogleGuavaDeckOfCardsAsList(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
GoogleGuavaDeckOfCardsAsList { public ImmutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void spades() { Assert.assertEquals(this.jdkDeck.spades(), this.ecDeck.spades()); }
|
public ImmutableList<Card> spades() { return null; }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Card> spades() { return null; } }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Card> spades() { return null; } EclipseCollectionsDeckOfCardsAsList(); }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Card> spades() { return null; } EclipseCollectionsDeckOfCardsAsList(); MutableStack<Card> shuffle(Random random); MutableSet<Card> deal(MutableStack<Card> stack, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(
MutableStack<Card> shuffled,
int hands,
int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Bag<Suit> countsBySuit(); Bag<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Card> spades() { return null; } EclipseCollectionsDeckOfCardsAsList(); MutableStack<Card> shuffle(Random random); MutableSet<Card> deal(MutableStack<Card> stack, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(
MutableStack<Card> shuffled,
int hands,
int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Bag<Suit> countsBySuit(); Bag<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void countsBySuit() { Assert.assertEquals( this.jdkDeck.countsBySuit().get(Suit.CLUBS).intValue(), this.ggDeck.countsBySuit().count(Suit.CLUBS)); }
|
public Multiset<Suit> countsBySuit() { return null; }
|
GoogleGuavaDeckOfCardsAsList { public Multiset<Suit> countsBySuit() { return null; } }
|
GoogleGuavaDeckOfCardsAsList { public Multiset<Suit> countsBySuit() { return null; } GoogleGuavaDeckOfCardsAsList(); }
|
GoogleGuavaDeckOfCardsAsList { public Multiset<Suit> countsBySuit() { return null; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
GoogleGuavaDeckOfCardsAsList { public Multiset<Suit> countsBySuit() { return null; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void countsByRank() { Assert.assertEquals( this.jdkDeck.countsByRank().get(Rank.TEN).intValue(), this.ggDeck.countsByRank().count(Rank.NINE)); }
|
public Multiset<Rank> countsByRank() { return null; }
|
GoogleGuavaDeckOfCardsAsList { public Multiset<Rank> countsByRank() { return null; } }
|
GoogleGuavaDeckOfCardsAsList { public Multiset<Rank> countsByRank() { return null; } GoogleGuavaDeckOfCardsAsList(); }
|
GoogleGuavaDeckOfCardsAsList { public Multiset<Rank> countsByRank() { return null; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
GoogleGuavaDeckOfCardsAsList { public Multiset<Rank> countsByRank() { return null; } GoogleGuavaDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Multiset<Suit> countsBySuit(); Multiset<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void allCards() { Assert.assertEquals(52, this.jdkDeck.getCards().size()); Assert.assertEquals(new Card(Rank.ACE, Suit.SPADES), this.jdkDeck.getCards().get(0)); Assert.assertEquals(new Card(Rank.KING, Suit.CLUBS), this.jdkDeck.getCards().get(51)); }
|
public List<Card> getCards() { return this.cards; }
|
JDKImperativeDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } }
|
JDKImperativeDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } JDKImperativeDeckOfCardsAsList(); }
|
JDKImperativeDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
JDKImperativeDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
@Test public void cardsAreImmutable() { var jdkCards = this.jdkDeck.getCards(); Verify.assertThrows( UnsupportedOperationException.class, () -> jdkCards.remove(0)); Verify.assertThrows( UnsupportedOperationException.class, jdkCards::clear); Verify.assertThrows( UnsupportedOperationException.class, () -> jdkCards.add(null)); }
|
public List<Card> getCards() { return this.cards; }
|
JDKImperativeDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } }
|
JDKImperativeDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } JDKImperativeDeckOfCardsAsList(); }
|
JDKImperativeDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
JDKImperativeDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
@Test public void diamonds() { Assert.assertEquals(13, this.jdkDeck.diamonds().size()); Assert.assertTrue(Iterate.allSatisfy(this.jdkDeck.diamonds(), Card::isDiamonds)); }
|
public List<Card> diamonds() { return this.cardsBySuit.get(Suit.DIAMONDS); }
|
JDKImperativeDeckOfCardsAsList { public List<Card> diamonds() { return this.cardsBySuit.get(Suit.DIAMONDS); } }
|
JDKImperativeDeckOfCardsAsList { public List<Card> diamonds() { return this.cardsBySuit.get(Suit.DIAMONDS); } JDKImperativeDeckOfCardsAsList(); }
|
JDKImperativeDeckOfCardsAsList { public List<Card> diamonds() { return this.cardsBySuit.get(Suit.DIAMONDS); } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
JDKImperativeDeckOfCardsAsList { public List<Card> diamonds() { return this.cardsBySuit.get(Suit.DIAMONDS); } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
@Test public void hearts() { Assert.assertEquals(13, this.jdkDeck.hearts().size()); Assert.assertTrue(Iterate.allSatisfy(this.jdkDeck.hearts(), Card::isHearts)); }
|
public List<Card> hearts() { return this.cardsBySuit.get(Suit.HEARTS); }
|
JDKImperativeDeckOfCardsAsList { public List<Card> hearts() { return this.cardsBySuit.get(Suit.HEARTS); } }
|
JDKImperativeDeckOfCardsAsList { public List<Card> hearts() { return this.cardsBySuit.get(Suit.HEARTS); } JDKImperativeDeckOfCardsAsList(); }
|
JDKImperativeDeckOfCardsAsList { public List<Card> hearts() { return this.cardsBySuit.get(Suit.HEARTS); } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
JDKImperativeDeckOfCardsAsList { public List<Card> hearts() { return this.cardsBySuit.get(Suit.HEARTS); } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
@Test public void spades() { Assert.assertEquals(13, this.jdkDeck.spades().size()); Assert.assertTrue(Iterate.allSatisfy(this.jdkDeck.spades(), Card::isSpades)); }
|
public List<Card> spades() { return this.cardsBySuit.get(Suit.SPADES); }
|
JDKImperativeDeckOfCardsAsList { public List<Card> spades() { return this.cardsBySuit.get(Suit.SPADES); } }
|
JDKImperativeDeckOfCardsAsList { public List<Card> spades() { return this.cardsBySuit.get(Suit.SPADES); } JDKImperativeDeckOfCardsAsList(); }
|
JDKImperativeDeckOfCardsAsList { public List<Card> spades() { return this.cardsBySuit.get(Suit.SPADES); } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
JDKImperativeDeckOfCardsAsList { public List<Card> spades() { return this.cardsBySuit.get(Suit.SPADES); } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
@Test public void clubs() { Assert.assertEquals(13, this.jdkDeck.clubs().size()); Assert.assertTrue(Iterate.allSatisfy(this.jdkDeck.clubs(), Card::isClubs)); }
|
public List<Card> clubs() { return this.cardsBySuit.get(Suit.CLUBS); }
|
JDKImperativeDeckOfCardsAsList { public List<Card> clubs() { return this.cardsBySuit.get(Suit.CLUBS); } }
|
JDKImperativeDeckOfCardsAsList { public List<Card> clubs() { return this.cardsBySuit.get(Suit.CLUBS); } JDKImperativeDeckOfCardsAsList(); }
|
JDKImperativeDeckOfCardsAsList { public List<Card> clubs() { return this.cardsBySuit.get(Suit.CLUBS); } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
JDKImperativeDeckOfCardsAsList { public List<Card> clubs() { return this.cardsBySuit.get(Suit.CLUBS); } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
@Test public void deal() { var jdkShuffle = this.jdkDeck.shuffle(new Random(1)); var jdkHand = this.jdkDeck.deal(jdkShuffle, 5); Assert.assertEquals(5, jdkHand.size()); Assert.assertEquals(47, jdkShuffle.size()); }
|
public Set<Card> deal(Deque<Card> deque, int count) { var hand = new HashSet<Card>(); for (int i = 0; i < count; i++) { hand.add(deque.pop()); } return hand; }
|
JDKImperativeDeckOfCardsAsList { public Set<Card> deal(Deque<Card> deque, int count) { var hand = new HashSet<Card>(); for (int i = 0; i < count; i++) { hand.add(deque.pop()); } return hand; } }
|
JDKImperativeDeckOfCardsAsList { public Set<Card> deal(Deque<Card> deque, int count) { var hand = new HashSet<Card>(); for (int i = 0; i < count; i++) { hand.add(deque.pop()); } return hand; } JDKImperativeDeckOfCardsAsList(); }
|
JDKImperativeDeckOfCardsAsList { public Set<Card> deal(Deque<Card> deque, int count) { var hand = new HashSet<Card>(); for (int i = 0; i < count; i++) { hand.add(deque.pop()); } return hand; } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
JDKImperativeDeckOfCardsAsList { public Set<Card> deal(Deque<Card> deque, int count) { var hand = new HashSet<Card>(); for (int i = 0; i < count; i++) { hand.add(deque.pop()); } return hand; } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
@Test public void shuffleAndDealHands() { var jdkHands = this.jdkDeck.shuffleAndDeal(new Random(1), 5, 5); Assert.assertEquals(5, jdkHands.size()); Assert.assertTrue(Iterate.allSatisfy(jdkHands, each -> each.size() == 5)); }
|
public List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); }
|
JDKImperativeDeckOfCardsAsList { public List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } }
|
JDKImperativeDeckOfCardsAsList { public List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } JDKImperativeDeckOfCardsAsList(); }
|
JDKImperativeDeckOfCardsAsList { public List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
JDKImperativeDeckOfCardsAsList { public List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
@Test public void clubs() { Assert.assertEquals(this.jdkDeck.clubs(), this.ecDeck.clubs()); }
|
public ImmutableList<Card> clubs() { return null; }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Card> clubs() { return null; } }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Card> clubs() { return null; } EclipseCollectionsDeckOfCardsAsList(); }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Card> clubs() { return null; } EclipseCollectionsDeckOfCardsAsList(); MutableStack<Card> shuffle(Random random); MutableSet<Card> deal(MutableStack<Card> stack, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(
MutableStack<Card> shuffled,
int hands,
int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Bag<Suit> countsBySuit(); Bag<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Card> clubs() { return null; } EclipseCollectionsDeckOfCardsAsList(); MutableStack<Card> shuffle(Random random); MutableSet<Card> deal(MutableStack<Card> stack, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(
MutableStack<Card> shuffled,
int hands,
int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Bag<Suit> countsBySuit(); Bag<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void dealHands() { var jdkShuffled = this.jdkDeck.shuffle(new Random(1)); var jdkHands = this.jdkDeck.dealHands(jdkShuffled, 5, 5); Assert.assertEquals(5, jdkHands.size()); Assert.assertTrue(Iterate.allSatisfy(jdkHands, each -> each.size() == 5)); Assert.assertEquals(27, jdkShuffled.size()); }
|
public List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { var result = new ArrayList<Set<Card>>(); for (int i = 0; i < hands; i++) { result.add(this.deal(shuffled, cardsPerHand)); } return List.copyOf(result); }
|
JDKImperativeDeckOfCardsAsList { public List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { var result = new ArrayList<Set<Card>>(); for (int i = 0; i < hands; i++) { result.add(this.deal(shuffled, cardsPerHand)); } return List.copyOf(result); } }
|
JDKImperativeDeckOfCardsAsList { public List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { var result = new ArrayList<Set<Card>>(); for (int i = 0; i < hands; i++) { result.add(this.deal(shuffled, cardsPerHand)); } return List.copyOf(result); } JDKImperativeDeckOfCardsAsList(); }
|
JDKImperativeDeckOfCardsAsList { public List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { var result = new ArrayList<Set<Card>>(); for (int i = 0; i < hands; i++) { result.add(this.deal(shuffled, cardsPerHand)); } return List.copyOf(result); } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
JDKImperativeDeckOfCardsAsList { public List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { var result = new ArrayList<Set<Card>>(); for (int i = 0; i < hands; i++) { result.add(this.deal(shuffled, cardsPerHand)); } return List.copyOf(result); } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
@Test public void cardsBySuit() { var jdkCardsBySuit = this.jdkDeck.getCardsBySuit(); Assert.assertEquals(4, jdkCardsBySuit.size()); Assert.assertEquals(13, jdkCardsBySuit.get(Suit.CLUBS).size()); Assert.assertEquals(13, jdkCardsBySuit.get(Suit.DIAMONDS).size()); Assert.assertEquals(13, jdkCardsBySuit.get(Suit.SPADES).size()); Assert.assertEquals(13, jdkCardsBySuit.get(Suit.HEARTS).size()); }
|
public Map<Suit, List<Card>> getCardsBySuit() { return this.cardsBySuit; }
|
JDKImperativeDeckOfCardsAsList { public Map<Suit, List<Card>> getCardsBySuit() { return this.cardsBySuit; } }
|
JDKImperativeDeckOfCardsAsList { public Map<Suit, List<Card>> getCardsBySuit() { return this.cardsBySuit; } JDKImperativeDeckOfCardsAsList(); }
|
JDKImperativeDeckOfCardsAsList { public Map<Suit, List<Card>> getCardsBySuit() { return this.cardsBySuit; } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
JDKImperativeDeckOfCardsAsList { public Map<Suit, List<Card>> getCardsBySuit() { return this.cardsBySuit; } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
@Test public void cardsBySuitIsImmutable() { var jdkCardsBySuit = this.jdkDeck.getCardsBySuit(); Verify.assertThrows( UnsupportedOperationException.class, () -> jdkCardsBySuit.remove(Suit.CLUBS)); Verify.assertThrows( UnsupportedOperationException.class, jdkCardsBySuit::clear); Verify.assertThrows( UnsupportedOperationException.class, () -> jdkCardsBySuit.get(Suit.CLUBS).remove(0)); Verify.assertThrows( UnsupportedOperationException.class, () -> jdkCardsBySuit.get(Suit.CLUBS).add(null)); Verify.assertThrows( UnsupportedOperationException.class, jdkCardsBySuit.get(Suit.CLUBS)::clear); }
|
public Map<Suit, List<Card>> getCardsBySuit() { return this.cardsBySuit; }
|
JDKImperativeDeckOfCardsAsList { public Map<Suit, List<Card>> getCardsBySuit() { return this.cardsBySuit; } }
|
JDKImperativeDeckOfCardsAsList { public Map<Suit, List<Card>> getCardsBySuit() { return this.cardsBySuit; } JDKImperativeDeckOfCardsAsList(); }
|
JDKImperativeDeckOfCardsAsList { public Map<Suit, List<Card>> getCardsBySuit() { return this.cardsBySuit; } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
JDKImperativeDeckOfCardsAsList { public Map<Suit, List<Card>> getCardsBySuit() { return this.cardsBySuit; } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
@Test public void countsBySuit() { Assert.assertEquals(Long.valueOf(13), this.jdkDeck.countsBySuit().get(Suit.CLUBS)); }
|
public Map<Suit, Long> countsBySuit() { var result = new HashMap<Suit, Long>(); for (var card : this.cards) { var suit = card.suit(); var value = result.computeIfAbsent(suit, s -> Long.valueOf(0)); result.put(suit, value + 1); } return result; }
|
JDKImperativeDeckOfCardsAsList { public Map<Suit, Long> countsBySuit() { var result = new HashMap<Suit, Long>(); for (var card : this.cards) { var suit = card.suit(); var value = result.computeIfAbsent(suit, s -> Long.valueOf(0)); result.put(suit, value + 1); } return result; } }
|
JDKImperativeDeckOfCardsAsList { public Map<Suit, Long> countsBySuit() { var result = new HashMap<Suit, Long>(); for (var card : this.cards) { var suit = card.suit(); var value = result.computeIfAbsent(suit, s -> Long.valueOf(0)); result.put(suit, value + 1); } return result; } JDKImperativeDeckOfCardsAsList(); }
|
JDKImperativeDeckOfCardsAsList { public Map<Suit, Long> countsBySuit() { var result = new HashMap<Suit, Long>(); for (var card : this.cards) { var suit = card.suit(); var value = result.computeIfAbsent(suit, s -> Long.valueOf(0)); result.put(suit, value + 1); } return result; } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
JDKImperativeDeckOfCardsAsList { public Map<Suit, Long> countsBySuit() { var result = new HashMap<Suit, Long>(); for (var card : this.cards) { var suit = card.suit(); var value = result.computeIfAbsent(suit, s -> Long.valueOf(0)); result.put(suit, value + 1); } return result; } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
@Test public void countsByRank() { Assert.assertEquals(Long.valueOf(4), this.jdkDeck.countsByRank().get(Rank.TEN)); }
|
public Map<Rank, Long> countsByRank() { var result = new HashMap<Rank, Long>(); for (var card : this.cards) { var rank = card.rank(); var value = result.computeIfAbsent(rank, r -> Long.valueOf(0)); result.put(rank, value + 1); } return result; }
|
JDKImperativeDeckOfCardsAsList { public Map<Rank, Long> countsByRank() { var result = new HashMap<Rank, Long>(); for (var card : this.cards) { var rank = card.rank(); var value = result.computeIfAbsent(rank, r -> Long.valueOf(0)); result.put(rank, value + 1); } return result; } }
|
JDKImperativeDeckOfCardsAsList { public Map<Rank, Long> countsByRank() { var result = new HashMap<Rank, Long>(); for (var card : this.cards) { var rank = card.rank(); var value = result.computeIfAbsent(rank, r -> Long.valueOf(0)); result.put(rank, value + 1); } return result; } JDKImperativeDeckOfCardsAsList(); }
|
JDKImperativeDeckOfCardsAsList { public Map<Rank, Long> countsByRank() { var result = new HashMap<Rank, Long>(); for (var card : this.cards) { var rank = card.rank(); var value = result.computeIfAbsent(rank, r -> Long.valueOf(0)); result.put(rank, value + 1); } return result; } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
JDKImperativeDeckOfCardsAsList { public Map<Rank, Long> countsByRank() { var result = new HashMap<Rank, Long>(); for (var card : this.cards) { var rank = card.rank(); var value = result.computeIfAbsent(rank, r -> Long.valueOf(0)); result.put(rank, value + 1); } return result; } JDKImperativeDeckOfCardsAsList(); Deque<Card> shuffle(Random random); Set<Card> deal(Deque<Card> deque, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, List<Card>> getCardsBySuit(); }
|
@Test public void allCards() { Assert.assertEquals(this.jdkDeck.getCards(), this.vavrDeck.getCards().toJavaList()); }
|
public List<Card> getCards() { return this.cards; }
|
VavrDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } }
|
VavrDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } VavrDeckOfCardsAsList(); }
|
VavrDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
VavrDeckOfCardsAsList { public List<Card> getCards() { return this.cards; } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
@Test public void diamonds() { Assert.assertEquals(this.jdkDeck.diamonds(), this.vavrDeck.diamonds().toJavaList()); }
|
public List<Card> diamonds() { return null; }
|
VavrDeckOfCardsAsList { public List<Card> diamonds() { return null; } }
|
VavrDeckOfCardsAsList { public List<Card> diamonds() { return null; } VavrDeckOfCardsAsList(); }
|
VavrDeckOfCardsAsList { public List<Card> diamonds() { return null; } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
VavrDeckOfCardsAsList { public List<Card> diamonds() { return null; } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
@Test public void hearts() { Assert.assertEquals(this.jdkDeck.hearts(), this.vavrDeck.hearts().toJavaList()); }
|
public List<Card> hearts() { return null; }
|
VavrDeckOfCardsAsList { public List<Card> hearts() { return null; } }
|
VavrDeckOfCardsAsList { public List<Card> hearts() { return null; } VavrDeckOfCardsAsList(); }
|
VavrDeckOfCardsAsList { public List<Card> hearts() { return null; } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
VavrDeckOfCardsAsList { public List<Card> hearts() { return null; } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
@Test public void spades() { Assert.assertEquals(this.jdkDeck.spades(), this.vavrDeck.spades().toJavaList()); }
|
public List<Card> spades() { return null; }
|
VavrDeckOfCardsAsList { public List<Card> spades() { return null; } }
|
VavrDeckOfCardsAsList { public List<Card> spades() { return null; } VavrDeckOfCardsAsList(); }
|
VavrDeckOfCardsAsList { public List<Card> spades() { return null; } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
VavrDeckOfCardsAsList { public List<Card> spades() { return null; } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
@Test public void clubs() { Assert.assertEquals(this.jdkDeck.clubs(), this.vavrDeck.clubs().toJavaList()); }
|
public List<Card> clubs() { return null; }
|
VavrDeckOfCardsAsList { public List<Card> clubs() { return null; } }
|
VavrDeckOfCardsAsList { public List<Card> clubs() { return null; } VavrDeckOfCardsAsList(); }
|
VavrDeckOfCardsAsList { public List<Card> clubs() { return null; } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
VavrDeckOfCardsAsList { public List<Card> clubs() { return null; } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
@Test public void deal() { var ecShuffle = this.ecDeck.shuffle(new Random(1)); var jdkShuffle = this.jdkDeck.shuffle(new Random(1)); var ecHand = this.ecDeck.deal(ecShuffle, 5); var jdkHand = this.jdkDeck.deal(jdkShuffle, 5); Assert.assertEquals(jdkHand, ecHand); }
|
public MutableSet<Card> deal(MutableStack<Card> stack, int count) { return stack.pop(count).toSet(); }
|
EclipseCollectionsDeckOfCardsAsList { public MutableSet<Card> deal(MutableStack<Card> stack, int count) { return stack.pop(count).toSet(); } }
|
EclipseCollectionsDeckOfCardsAsList { public MutableSet<Card> deal(MutableStack<Card> stack, int count) { return stack.pop(count).toSet(); } EclipseCollectionsDeckOfCardsAsList(); }
|
EclipseCollectionsDeckOfCardsAsList { public MutableSet<Card> deal(MutableStack<Card> stack, int count) { return stack.pop(count).toSet(); } EclipseCollectionsDeckOfCardsAsList(); MutableStack<Card> shuffle(Random random); MutableSet<Card> deal(MutableStack<Card> stack, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(
MutableStack<Card> shuffled,
int hands,
int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Bag<Suit> countsBySuit(); Bag<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
EclipseCollectionsDeckOfCardsAsList { public MutableSet<Card> deal(MutableStack<Card> stack, int count) { return stack.pop(count).toSet(); } EclipseCollectionsDeckOfCardsAsList(); MutableStack<Card> shuffle(Random random); MutableSet<Card> deal(MutableStack<Card> stack, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(
MutableStack<Card> shuffled,
int hands,
int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Bag<Suit> countsBySuit(); Bag<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void deal() { var jdkShuffle = this.jdkDeck.shuffle(new Random(1)); var vavrShuffle = this.vavrDeck.shuffle(new Random(1)); var jdkHand = this.jdkDeck.deal(jdkShuffle, 5); var vavrHand = this.vavrDeck.deal(vavrShuffle, 5)._1().toJavaSet(); Assert.assertEquals(jdkHand, vavrHand); }
|
public Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count) { var hand = HashSet.<Card>empty(); for (int i = 0; i < count; i++) { var cardTuple2 = stack.pop2(); stack = cardTuple2._2(); hand = hand.add(cardTuple2._1()); } return Tuple.of(hand, stack); }
|
VavrDeckOfCardsAsList { public Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count) { var hand = HashSet.<Card>empty(); for (int i = 0; i < count; i++) { var cardTuple2 = stack.pop2(); stack = cardTuple2._2(); hand = hand.add(cardTuple2._1()); } return Tuple.of(hand, stack); } }
|
VavrDeckOfCardsAsList { public Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count) { var hand = HashSet.<Card>empty(); for (int i = 0; i < count; i++) { var cardTuple2 = stack.pop2(); stack = cardTuple2._2(); hand = hand.add(cardTuple2._1()); } return Tuple.of(hand, stack); } VavrDeckOfCardsAsList(); }
|
VavrDeckOfCardsAsList { public Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count) { var hand = HashSet.<Card>empty(); for (int i = 0; i < count; i++) { var cardTuple2 = stack.pop2(); stack = cardTuple2._2(); hand = hand.add(cardTuple2._1()); } return Tuple.of(hand, stack); } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
VavrDeckOfCardsAsList { public Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count) { var hand = HashSet.<Card>empty(); for (int i = 0; i < count; i++) { var cardTuple2 = stack.pop2(); stack = cardTuple2._2(); hand = hand.add(cardTuple2._1()); } return Tuple.of(hand, stack); } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
@Test public void shuffleAndDealHands() { var jdkHands = this.jdkDeck.shuffleAndDeal(new Random(1), 5, 5); var vavrHands = this.vavrDeck.shuffleAndDeal(new Random(1), 5, 5); Assert.assertEquals(jdkHands.get(0), vavrHands.get(0).toJavaSet()); Assert.assertEquals(jdkHands.get(1), vavrHands.get(1).toJavaSet()); Assert.assertEquals(jdkHands.get(2), vavrHands.get(2).toJavaSet()); Assert.assertEquals(jdkHands.get(3), vavrHands.get(3).toJavaSet()); Assert.assertEquals(jdkHands.get(4), vavrHands.get(4).toJavaSet()); }
|
public List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); }
|
VavrDeckOfCardsAsList { public List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } }
|
VavrDeckOfCardsAsList { public List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } VavrDeckOfCardsAsList(); }
|
VavrDeckOfCardsAsList { public List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
VavrDeckOfCardsAsList { public List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
@Test public void dealHands() { var jdkShuffled = this.jdkDeck.shuffle(new Random(1)); var vavrShuffled = this.vavrDeck.shuffle(new Random(1)); var jdkHands = this.jdkDeck.dealHands(jdkShuffled, 5, 5); var vavrHands = this.vavrDeck.dealHands(vavrShuffled, 5, 5); Assert.assertEquals(jdkHands.get(0), vavrHands.get(0).toJavaSet()); Assert.assertEquals(jdkHands.get(1), vavrHands.get(1).toJavaSet()); Assert.assertEquals(jdkHands.get(2), vavrHands.get(2).toJavaSet()); Assert.assertEquals(jdkHands.get(3), vavrHands.get(3).toJavaSet()); Assert.assertEquals(jdkHands.get(4), vavrHands.get(4).toJavaSet()); }
|
public List<Set<Card>> dealHands( List<Card> shuffled, int hands, int cardsPerHand) { return null; }
|
VavrDeckOfCardsAsList { public List<Set<Card>> dealHands( List<Card> shuffled, int hands, int cardsPerHand) { return null; } }
|
VavrDeckOfCardsAsList { public List<Set<Card>> dealHands( List<Card> shuffled, int hands, int cardsPerHand) { return null; } VavrDeckOfCardsAsList(); }
|
VavrDeckOfCardsAsList { public List<Set<Card>> dealHands( List<Card> shuffled, int hands, int cardsPerHand) { return null; } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
VavrDeckOfCardsAsList { public List<Set<Card>> dealHands( List<Card> shuffled, int hands, int cardsPerHand) { return null; } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
@Test public void cardsBySuit() { var jdkCardsBySuit = this.jdkDeck.getCardsBySuit(); var vavrCardsBySuit = this.vavrDeck.getCardsBySuit(); Assert.assertEquals(jdkCardsBySuit.get(Suit.CLUBS), vavrCardsBySuit.get(Suit.CLUBS).get().toJavaList()); }
|
public Map<Suit, ? extends List<Card>> getCardsBySuit() { return this.cardsBySuit; }
|
VavrDeckOfCardsAsList { public Map<Suit, ? extends List<Card>> getCardsBySuit() { return this.cardsBySuit; } }
|
VavrDeckOfCardsAsList { public Map<Suit, ? extends List<Card>> getCardsBySuit() { return this.cardsBySuit; } VavrDeckOfCardsAsList(); }
|
VavrDeckOfCardsAsList { public Map<Suit, ? extends List<Card>> getCardsBySuit() { return this.cardsBySuit; } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
VavrDeckOfCardsAsList { public Map<Suit, ? extends List<Card>> getCardsBySuit() { return this.cardsBySuit; } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
@Test public void countsBySuit() { Assert.assertEquals( this.jdkDeck.countsBySuit().get(Suit.CLUBS), this.vavrDeck.countsBySuit().get(Suit.CLUBS).get()); }
|
public Map<Suit, Long> countsBySuit() { return null; }
|
VavrDeckOfCardsAsList { public Map<Suit, Long> countsBySuit() { return null; } }
|
VavrDeckOfCardsAsList { public Map<Suit, Long> countsBySuit() { return null; } VavrDeckOfCardsAsList(); }
|
VavrDeckOfCardsAsList { public Map<Suit, Long> countsBySuit() { return null; } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
VavrDeckOfCardsAsList { public Map<Suit, Long> countsBySuit() { return null; } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
@Test public void countsByRank() { Assert.assertEquals( this.jdkDeck.countsByRank().get(Rank.TEN), this.vavrDeck.countsByRank().get(Rank.TEN).get()); }
|
public Map<Rank, Long> countsByRank() { return null; }
|
VavrDeckOfCardsAsList { public Map<Rank, Long> countsByRank() { return null; } }
|
VavrDeckOfCardsAsList { public Map<Rank, Long> countsByRank() { return null; } VavrDeckOfCardsAsList(); }
|
VavrDeckOfCardsAsList { public Map<Rank, Long> countsByRank() { return null; } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
VavrDeckOfCardsAsList { public Map<Rank, Long> countsByRank() { return null; } VavrDeckOfCardsAsList(); List<Card> shuffle(Random random); Tuple2<Set<Card>, ? extends List<Card>> deal(List<Card> stack, int count); List<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); List<Set<Card>> dealHands(
List<Card> shuffled,
int hands,
int cardsPerHand); List<Card> diamonds(); List<Card> hearts(); List<Card> spades(); List<Card> clubs(); Map<Suit, Long> countsBySuit(); Map<Rank, Long> countsByRank(); List<Card> getCards(); Map<Suit, ? extends List<Card>> getCardsBySuit(); }
|
@Test public void get_put() { this.testObj.put("A", 1); Assert.assertEquals(MutableSet.of(1), this.testObj.get("A")); Assert.assertEquals(1, this.testObj.size()); this.testObj.put("A", 2); Assert.assertEquals(MutableSet.of(1, 2), this.testObj.get("A")); Assert.assertEquals(2, this.testObj.size()); this.testObj.put("A", 1); Assert.assertEquals(MutableSet.of(1, 2), this.testObj.get("A")); Assert.assertEquals(2, this.testObj.size()); this.testObj.put("B", 10); Assert.assertEquals(MutableSet.of(10), this.testObj.get("B")); Assert.assertEquals(3, this.testObj.size()); this.testObj.put("B", 11); Assert.assertEquals(MutableSet.of(10, 11), this.testObj.get("B")); Assert.assertEquals(4, this.testObj.size()); this.testObj.put("A", 2); Assert.assertEquals(MutableSet.of(1, 2), this.testObj.get("A")); Assert.assertEquals(4, this.testObj.size()); }
|
@Override public int size() { return this.size; }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } static HashSetMultimap<K, V> newMultimap(); @Override int size(); }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } static HashSetMultimap<K, V> newMultimap(); @Override int size(); }
|
@Test public void get_putIterable() { this.testObj.put("A", MutableSet.of(1)); Assert.assertEquals(MutableSet.of(1), this.testObj.get("A")); Assert.assertEquals(1, this.testObj.size()); this.testObj.put("A", MutableSet.of(2, 1)); Assert.assertEquals(MutableSet.of(1, 2), this.testObj.get("A")); Assert.assertEquals(2, this.testObj.size()); this.testObj.put("B", MutableSet.of(10, 11)); Assert.assertEquals(MutableSet.of(10, 11), this.testObj.get("B")); Assert.assertEquals(4, this.testObj.size()); this.testObj.put("A", MutableSet.of(2, 3, 4)); Assert.assertEquals(MutableSet.of(1, 2, 3, 4), this.testObj.get("A")); Assert.assertEquals(6, this.testObj.size()); }
|
@Override public int size() { return this.size; }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } static HashSetMultimap<K, V> newMultimap(); @Override int size(); }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } static HashSetMultimap<K, V> newMultimap(); @Override int size(); }
|
@Test public void putAll() { this.testObj.putAll(MutableMap.of("A", MutableList.of(1, 2, 3))); Assert.assertEquals(MutableSet.of(1, 2, 3), this.testObj.get("A")); Assert.assertEquals(3, this.testObj.size()); this.testObj.putAll(MutableMap.of("B", MutableList.of(10, 10))); Assert.assertEquals(MutableSet.of(10, 10), this.testObj.get("B")); Assert.assertEquals(4, this.testObj.size()); }
|
@Override public int size() { return this.size; }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } static HashSetMultimap<K, V> newMultimap(); @Override int size(); }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } static HashSetMultimap<K, V> newMultimap(); @Override int size(); }
|
@Test public void remove() { Assert.assertEquals(MutableSet.empty(), this.testObj.remove("A")); this.testObj.putAll(MutableMap.of("A", MutableList.of(1, 2, 3))); this.testObj.putAll(MutableMap.of("B", MutableList.of(10, 10))); Assert.assertEquals(4, this.testObj.size()); this.testObj.remove("A"); Assert.assertEquals(1, this.testObj.size()); this.testObj.remove("B"); Assert.assertEquals(0, this.testObj.size()); }
|
@Override public int size() { return this.size; }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } static HashSetMultimap<K, V> newMultimap(); @Override int size(); }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } static HashSetMultimap<K, V> newMultimap(); @Override int size(); }
|
@Test public void shuffleAndDealHands() { var ecHands = this.ecDeck.shuffleAndDeal(new Random(1), 5, 5); var jdkHands = this.jdkDeck.shuffleAndDeal(new Random(1), 5, 5); Assert.assertEquals(jdkHands, ecHands); }
|
public ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } EclipseCollectionsDeckOfCardsAsList(); }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } EclipseCollectionsDeckOfCardsAsList(); MutableStack<Card> shuffle(Random random); MutableSet<Card> deal(MutableStack<Card> stack, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(
MutableStack<Card> shuffled,
int hands,
int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Bag<Suit> countsBySuit(); Bag<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } EclipseCollectionsDeckOfCardsAsList(); MutableStack<Card> shuffle(Random random); MutableSet<Card> deal(MutableStack<Card> stack, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(
MutableStack<Card> shuffled,
int hands,
int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Bag<Suit> countsBySuit(); Bag<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void remove_keyValue() { Assert.assertEquals(MutableSet.empty(), this.testObj.remove("A")); this.testObj.putAll(MutableMap.of("A", MutableList.of(1, 2, 3, 1))); this.testObj.putAll(MutableMap.of("B", MutableList.of(10, 10))); Assert.assertEquals(4, this.testObj.size()); this.testObj.remove("A", 1); Assert.assertEquals(MutableSet.of(2, 3), this.testObj.get("A")); Assert.assertEquals(3, this.testObj.size()); this.testObj.remove("B", 10); MutableSet<Integer> getForB = this.testObj.get("B"); Assert.assertEquals(MutableSet.empty(), getForB); Assert.assertEquals(2, this.testObj.size()); Assert.assertNotSame(getForB, this.testObj.get("B")); }
|
@Override public int size() { return this.size; }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } static HashSetMultimap<K, V> newMultimap(); @Override int size(); }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } static HashSetMultimap<K, V> newMultimap(); @Override int size(); }
|
@Test public void clear() { Assert.assertEquals(0, this.testObj.size()); this.testObj.clear(); this.testObj.putAll(MutableMap.of("A", MutableList.of(1, 2, 3, 1))); this.testObj.putAll(MutableMap.of("B", MutableList.of(10, 10))); Assert.assertEquals(4, this.testObj.size()); this.testObj.clear(); Assert.assertEquals(0, this.testObj.size()); }
|
@Override public int size() { return this.size; }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } static HashSetMultimap<K, V> newMultimap(); @Override int size(); }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { @Override public int size() { return this.size; } static HashSetMultimap<K, V> newMultimap(); @Override int size(); }
|
@Test public void hashCodeEquals() { this.testObj.putAll(MutableMap.of("A", MutableList.of(1, 2, 3, 1))); this.testObj.putAll(MutableMap.of("B", MutableList.of(10, 10))); HashSetMultimap<String, Integer> other = HashSetMultimap.newMultimap(); other.putAll(MutableMap.of("A", MutableList.of(1, 2, 3, 1))); Assert.assertTrue(this.testObj.equals(this.testObj)); Assert.assertFalse(this.testObj.equals(other)); Assert.assertFalse(other.equals(this.testObj)); other.putAll(MutableMap.of("B", MutableList.of(10, 10))); Verify.assertEqualsAndHashCode(this.testObj, this.testObj); Verify.assertEqualsAndHashCode(this.testObj, other); Verify.assertEqualsAndHashCode(other, this.testObj); }
|
public static <K, V> HashSetMultimap<K, V> newMultimap() { return new HashSetMultimap<>(); }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { public static <K, V> HashSetMultimap<K, V> newMultimap() { return new HashSetMultimap<>(); } }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { public static <K, V> HashSetMultimap<K, V> newMultimap() { return new HashSetMultimap<>(); } }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { public static <K, V> HashSetMultimap<K, V> newMultimap() { return new HashSetMultimap<>(); } static HashSetMultimap<K, V> newMultimap(); @Override int size(); }
|
HashSetMultimap extends AbstractMutableMultimap<K, V, MutableSet<V>> implements MutableSetMultimap<K, V> { public static <K, V> HashSetMultimap<K, V> newMultimap() { return new HashSetMultimap<>(); } static HashSetMultimap<K, V> newMultimap(); @Override int size(); }
|
@Test public void allCards() { Assert.assertEquals(this.jdkDeck.getCards(), this.customDeck.getCards()); }
|
public MutableList<Card> getCards() { return this.cards; }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> getCards() { return this.cards; } }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> getCards() { return this.cards; } CustomCollectionsDeckOfCardsAsList(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> getCards() { return this.cards; } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> getCards() { return this.cards; } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void cardsAreImmutable() { var jdk2Cards = this.customDeck.getCards(); Verify.assertThrows( UnsupportedOperationException.class, () -> jdk2Cards.remove(0)); Verify.assertThrows( UnsupportedOperationException.class, jdk2Cards::clear); Verify.assertThrows( UnsupportedOperationException.class, () -> jdk2Cards.add(null)); }
|
public MutableList<Card> getCards() { return this.cards; }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> getCards() { return this.cards; } }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> getCards() { return this.cards; } CustomCollectionsDeckOfCardsAsList(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> getCards() { return this.cards; } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> getCards() { return this.cards; } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void diamonds() { Assert.assertEquals(this.jdkDeck.diamonds(), this.customDeck.diamonds()); }
|
public MutableList<Card> diamonds() { return this.cardsBySuit.get(Suit.DIAMONDS); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> diamonds() { return this.cardsBySuit.get(Suit.DIAMONDS); } }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> diamonds() { return this.cardsBySuit.get(Suit.DIAMONDS); } CustomCollectionsDeckOfCardsAsList(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> diamonds() { return this.cardsBySuit.get(Suit.DIAMONDS); } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> diamonds() { return this.cardsBySuit.get(Suit.DIAMONDS); } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void hearts() { Assert.assertEquals(this.jdkDeck.hearts(), this.customDeck.hearts()); }
|
public MutableList<Card> hearts() { return this.cardsBySuit.get(Suit.HEARTS); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> hearts() { return this.cardsBySuit.get(Suit.HEARTS); } }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> hearts() { return this.cardsBySuit.get(Suit.HEARTS); } CustomCollectionsDeckOfCardsAsList(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> hearts() { return this.cardsBySuit.get(Suit.HEARTS); } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> hearts() { return this.cardsBySuit.get(Suit.HEARTS); } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void spades() { Assert.assertEquals(this.jdkDeck.spades(), this.customDeck.spades()); }
|
public MutableList<Card> spades() { return this.cardsBySuit.get(Suit.SPADES); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> spades() { return this.cardsBySuit.get(Suit.SPADES); } }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> spades() { return this.cardsBySuit.get(Suit.SPADES); } CustomCollectionsDeckOfCardsAsList(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> spades() { return this.cardsBySuit.get(Suit.SPADES); } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> spades() { return this.cardsBySuit.get(Suit.SPADES); } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void clubs() { Assert.assertEquals(this.jdkDeck.clubs(), this.customDeck.clubs()); }
|
public MutableList<Card> clubs() { return this.cardsBySuit.get(Suit.CLUBS); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> clubs() { return this.cardsBySuit.get(Suit.CLUBS); } }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> clubs() { return this.cardsBySuit.get(Suit.CLUBS); } CustomCollectionsDeckOfCardsAsList(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> clubs() { return this.cardsBySuit.get(Suit.CLUBS); } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<Card> clubs() { return this.cardsBySuit.get(Suit.CLUBS); } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void deal() { var jdk1Shuffle = this.jdkDeck.shuffle(new Random(1)); var jdk2Shuffle = this.customDeck.shuffle(new Random(1)); var jdk1Hand = this.jdkDeck.deal(jdk1Shuffle, 5); var jdk2Hand = this.customDeck.deal(jdk2Shuffle, 5); Assert.assertEquals(jdk1Hand, jdk2Hand); }
|
public MutableSet<Card> deal(Deque<Card> deque, int count) { var hand = MutableSet.<Card>empty(); IntStream.range(0, count).forEach(i -> hand.add(deque.pop())); return hand; }
|
CustomCollectionsDeckOfCardsAsList { public MutableSet<Card> deal(Deque<Card> deque, int count) { var hand = MutableSet.<Card>empty(); IntStream.range(0, count).forEach(i -> hand.add(deque.pop())); return hand; } }
|
CustomCollectionsDeckOfCardsAsList { public MutableSet<Card> deal(Deque<Card> deque, int count) { var hand = MutableSet.<Card>empty(); IntStream.range(0, count).forEach(i -> hand.add(deque.pop())); return hand; } CustomCollectionsDeckOfCardsAsList(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableSet<Card> deal(Deque<Card> deque, int count) { var hand = MutableSet.<Card>empty(); IntStream.range(0, count).forEach(i -> hand.add(deque.pop())); return hand; } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableSet<Card> deal(Deque<Card> deque, int count) { var hand = MutableSet.<Card>empty(); IntStream.range(0, count).forEach(i -> hand.add(deque.pop())); return hand; } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void dealHands() { var ecShuffled = this.ecDeck.shuffle(new Random(1)); var jdkShuffled = this.jdkDeck.shuffle(new Random(1)); var ecHands = this.ecDeck.dealHands(ecShuffled, 5, 5); var jdkHands = this.jdkDeck.dealHands(jdkShuffled, 5, 5); Assert.assertEquals(jdkHands, ecHands); }
|
public ImmutableList<Set<Card>> dealHands( MutableStack<Card> shuffled, int hands, int cardsPerHand) { return null; }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Set<Card>> dealHands( MutableStack<Card> shuffled, int hands, int cardsPerHand) { return null; } }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Set<Card>> dealHands( MutableStack<Card> shuffled, int hands, int cardsPerHand) { return null; } EclipseCollectionsDeckOfCardsAsList(); }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Set<Card>> dealHands( MutableStack<Card> shuffled, int hands, int cardsPerHand) { return null; } EclipseCollectionsDeckOfCardsAsList(); MutableStack<Card> shuffle(Random random); MutableSet<Card> deal(MutableStack<Card> stack, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(
MutableStack<Card> shuffled,
int hands,
int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Bag<Suit> countsBySuit(); Bag<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableList<Set<Card>> dealHands( MutableStack<Card> shuffled, int hands, int cardsPerHand) { return null; } EclipseCollectionsDeckOfCardsAsList(); MutableStack<Card> shuffle(Random random); MutableSet<Card> deal(MutableStack<Card> stack, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(
MutableStack<Card> shuffled,
int hands,
int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Bag<Suit> countsBySuit(); Bag<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void shuffleAndDealHands() { var jdk1Hands = this.jdkDeck.shuffleAndDeal(new Random(1), 5, 5); var jdk2Hands = this.customDeck.shuffleAndDeal(new Random(1), 5, 5); Assert.assertEquals(jdk1Hands, jdk2Hands); }
|
public MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } CustomCollectionsDeckOfCardsAsList(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand) { var shuffled = this.shuffle(random); return this.dealHands(shuffled, hands, cardsPerHand); } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void dealHands() { var jdk1Shuffled = this.jdkDeck.shuffle(new Random(1)); var jdk2Shuffled = this.customDeck.shuffle(new Random(1)); var jdk1Hands = this.jdkDeck.dealHands(jdk1Shuffled, 5, 5); var jdk2Hands = this.customDeck.dealHands(jdk2Shuffled, 5, 5); Assert.assertEquals(jdk1Hands, jdk2Hands); }
|
public MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { return MutableList.fromStream(IntStream.range(0, hands) .mapToObj(each -> this.deal(shuffled, cardsPerHand))) .asUnmodifiable(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { return MutableList.fromStream(IntStream.range(0, hands) .mapToObj(each -> this.deal(shuffled, cardsPerHand))) .asUnmodifiable(); } }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { return MutableList.fromStream(IntStream.range(0, hands) .mapToObj(each -> this.deal(shuffled, cardsPerHand))) .asUnmodifiable(); } CustomCollectionsDeckOfCardsAsList(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { return MutableList.fromStream(IntStream.range(0, hands) .mapToObj(each -> this.deal(shuffled, cardsPerHand))) .asUnmodifiable(); } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand) { return MutableList.fromStream(IntStream.range(0, hands) .mapToObj(each -> this.deal(shuffled, cardsPerHand))) .asUnmodifiable(); } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void cardsBySuit() { var jdk1CardsBySuit = this.jdkDeck.getCardsBySuit(); var jdk2CardsBySuit = this.customDeck.getCardsBySuit(); Assert.assertEquals(jdk1CardsBySuit.get(Suit.CLUBS), jdk2CardsBySuit.get(Suit.CLUBS)); }
|
public MutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; }
|
CustomCollectionsDeckOfCardsAsList { public MutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } }
|
CustomCollectionsDeckOfCardsAsList { public MutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } CustomCollectionsDeckOfCardsAsList(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void cardsBySuitIsImmutable() { var jdk2CardsBySuit = this.customDeck.getCardsBySuit(); Verify.assertThrows( UnsupportedOperationException.class, () -> jdk2CardsBySuit.remove(Suit.CLUBS)); Verify.assertThrows( UnsupportedOperationException.class, jdk2CardsBySuit::clear); Verify.assertThrows( UnsupportedOperationException.class, () -> jdk2CardsBySuit.get(Suit.CLUBS).remove(0)); Verify.assertThrows( UnsupportedOperationException.class, () -> jdk2CardsBySuit.get(Suit.CLUBS).add(null)); Verify.assertThrows( UnsupportedOperationException.class, jdk2CardsBySuit.get(Suit.CLUBS)::clear); }
|
public MutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; }
|
CustomCollectionsDeckOfCardsAsList { public MutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } }
|
CustomCollectionsDeckOfCardsAsList { public MutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } CustomCollectionsDeckOfCardsAsList(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void countsBySuit() { for (Suit suit : Suit.values()) { Assert.assertEquals( this.jdkDeck.countsBySuit().get(suit).intValue(), this.customDeck.countsBySuit().getOccurrences(suit)); } }
|
public MutableBag<Suit> countsBySuit() { return this.cards.countBy(Card::suit); }
|
CustomCollectionsDeckOfCardsAsList { public MutableBag<Suit> countsBySuit() { return this.cards.countBy(Card::suit); } }
|
CustomCollectionsDeckOfCardsAsList { public MutableBag<Suit> countsBySuit() { return this.cards.countBy(Card::suit); } CustomCollectionsDeckOfCardsAsList(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableBag<Suit> countsBySuit() { return this.cards.countBy(Card::suit); } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableBag<Suit> countsBySuit() { return this.cards.countBy(Card::suit); } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void countsByRank() { for (Rank rank : Rank.values()) { Assert.assertEquals( this.jdkDeck.countsByRank().get(rank).intValue(), this.customDeck.countsByRank().getOccurrences(rank)); } }
|
public MutableBag<Rank> countsByRank() { return this.cards.countBy(Card::rank); }
|
CustomCollectionsDeckOfCardsAsList { public MutableBag<Rank> countsByRank() { return this.cards.countBy(Card::rank); } }
|
CustomCollectionsDeckOfCardsAsList { public MutableBag<Rank> countsByRank() { return this.cards.countBy(Card::rank); } CustomCollectionsDeckOfCardsAsList(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableBag<Rank> countsByRank() { return this.cards.countBy(Card::rank); } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
CustomCollectionsDeckOfCardsAsList { public MutableBag<Rank> countsByRank() { return this.cards.countBy(Card::rank); } CustomCollectionsDeckOfCardsAsList(); Deque<Card> shuffle(Random random); MutableSet<Card> deal(Deque<Card> deque, int count); MutableList<MutableSet<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); MutableList<MutableSet<Card>> dealHands(Deque<Card> shuffled, int hands, int cardsPerHand); MutableList<Card> diamonds(); MutableList<Card> hearts(); MutableList<Card> spades(); MutableList<Card> clubs(); MutableBag<Suit> countsBySuit(); MutableBag<Rank> countsByRank(); MutableList<Card> getCards(); MutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void withAll() { HashBag<String> bag = this.testObj.withAll("1", "2", "3", "2", "3", "3"); Assert.assertEquals(1, bag.getOccurrences("1")); Assert.assertEquals(2, bag.getOccurrences("2")); Assert.assertEquals(3, bag.getOccurrences("3")); }
|
HashBag<T> withAll(T... elements) { for (T element : elements) { this.backingMap.merge(element, 1, (existingValue, newValue) -> existingValue + 1); this.size++; } return this; }
|
HashBag implements MutableBag<T> { HashBag<T> withAll(T... elements) { for (T element : elements) { this.backingMap.merge(element, 1, (existingValue, newValue) -> existingValue + 1); this.size++; } return this; } }
|
HashBag implements MutableBag<T> { HashBag<T> withAll(T... elements) { for (T element : elements) { this.backingMap.merge(element, 1, (existingValue, newValue) -> existingValue + 1); this.size++; } return this; } }
|
HashBag implements MutableBag<T> { HashBag<T> withAll(T... elements) { for (T element : elements) { this.backingMap.merge(element, 1, (existingValue, newValue) -> existingValue + 1); this.size++; } return this; } @Override int sizeDistinct(); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); void forEachWithIndex(BiConsumer<? super T, Integer> biConsumer); @Override T1[] toArray(T1[] array); @Override boolean add(T element); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends T> c); @Override boolean removeAll(Collection<?> c); @Override boolean retainAll(Collection<?> c); @Override void clear(); @Override Iterator<T> iterator(); @Override int getOccurrences(T element); @Override boolean addOccurrence(T element); @Override boolean addOccurrences(T element, int occurrences); @Override boolean removeOccurrence(T element); @Override boolean removeOccurrences(T element, int occurrences); @Override void forEachWithOccurrences(BiConsumer<? super T, Integer> biConsumer); @Override void forEach(Consumer<? super T> consumer); @Override int hashCode(); @Override boolean equals(Object other); }
|
HashBag implements MutableBag<T> { HashBag<T> withAll(T... elements) { for (T element : elements) { this.backingMap.merge(element, 1, (existingValue, newValue) -> existingValue + 1); this.size++; } return this; } @Override int sizeDistinct(); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); void forEachWithIndex(BiConsumer<? super T, Integer> biConsumer); @Override T1[] toArray(T1[] array); @Override boolean add(T element); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends T> c); @Override boolean removeAll(Collection<?> c); @Override boolean retainAll(Collection<?> c); @Override void clear(); @Override Iterator<T> iterator(); @Override int getOccurrences(T element); @Override boolean addOccurrence(T element); @Override boolean addOccurrences(T element, int occurrences); @Override boolean removeOccurrence(T element); @Override boolean removeOccurrences(T element, int occurrences); @Override void forEachWithOccurrences(BiConsumer<? super T, Integer> biConsumer); @Override void forEach(Consumer<? super T> consumer); @Override int hashCode(); @Override boolean equals(Object other); }
|
@Test public void isEmpty() { Assert.assertTrue(this.testObj.isEmpty()); this.testObj.withAll("1", "2", "3", "2", "3", "3"); Assert.assertFalse(this.testObj.isEmpty()); }
|
@Override public boolean isEmpty() { return this.size == 0; }
|
HashBag implements MutableBag<T> { @Override public boolean isEmpty() { return this.size == 0; } }
|
HashBag implements MutableBag<T> { @Override public boolean isEmpty() { return this.size == 0; } }
|
HashBag implements MutableBag<T> { @Override public boolean isEmpty() { return this.size == 0; } @Override int sizeDistinct(); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); void forEachWithIndex(BiConsumer<? super T, Integer> biConsumer); @Override T1[] toArray(T1[] array); @Override boolean add(T element); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends T> c); @Override boolean removeAll(Collection<?> c); @Override boolean retainAll(Collection<?> c); @Override void clear(); @Override Iterator<T> iterator(); @Override int getOccurrences(T element); @Override boolean addOccurrence(T element); @Override boolean addOccurrences(T element, int occurrences); @Override boolean removeOccurrence(T element); @Override boolean removeOccurrences(T element, int occurrences); @Override void forEachWithOccurrences(BiConsumer<? super T, Integer> biConsumer); @Override void forEach(Consumer<? super T> consumer); @Override int hashCode(); @Override boolean equals(Object other); }
|
HashBag implements MutableBag<T> { @Override public boolean isEmpty() { return this.size == 0; } @Override int sizeDistinct(); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); void forEachWithIndex(BiConsumer<? super T, Integer> biConsumer); @Override T1[] toArray(T1[] array); @Override boolean add(T element); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends T> c); @Override boolean removeAll(Collection<?> c); @Override boolean retainAll(Collection<?> c); @Override void clear(); @Override Iterator<T> iterator(); @Override int getOccurrences(T element); @Override boolean addOccurrence(T element); @Override boolean addOccurrences(T element, int occurrences); @Override boolean removeOccurrence(T element); @Override boolean removeOccurrences(T element, int occurrences); @Override void forEachWithOccurrences(BiConsumer<? super T, Integer> biConsumer); @Override void forEach(Consumer<? super T> consumer); @Override int hashCode(); @Override boolean equals(Object other); }
|
@Test public void contains() { Assert.assertFalse(this.testObj.contains("1")); this.testObj.withAll("1", "2", "3", "2", "3", "3"); Assert.assertTrue(this.testObj.contains("1")); Assert.assertFalse(this.testObj.contains("4")); }
|
@Override public boolean contains(Object o) { return this.backingMap.containsKey(o); }
|
HashBag implements MutableBag<T> { @Override public boolean contains(Object o) { return this.backingMap.containsKey(o); } }
|
HashBag implements MutableBag<T> { @Override public boolean contains(Object o) { return this.backingMap.containsKey(o); } }
|
HashBag implements MutableBag<T> { @Override public boolean contains(Object o) { return this.backingMap.containsKey(o); } @Override int sizeDistinct(); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); void forEachWithIndex(BiConsumer<? super T, Integer> biConsumer); @Override T1[] toArray(T1[] array); @Override boolean add(T element); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends T> c); @Override boolean removeAll(Collection<?> c); @Override boolean retainAll(Collection<?> c); @Override void clear(); @Override Iterator<T> iterator(); @Override int getOccurrences(T element); @Override boolean addOccurrence(T element); @Override boolean addOccurrences(T element, int occurrences); @Override boolean removeOccurrence(T element); @Override boolean removeOccurrences(T element, int occurrences); @Override void forEachWithOccurrences(BiConsumer<? super T, Integer> biConsumer); @Override void forEach(Consumer<? super T> consumer); @Override int hashCode(); @Override boolean equals(Object other); }
|
HashBag implements MutableBag<T> { @Override public boolean contains(Object o) { return this.backingMap.containsKey(o); } @Override int sizeDistinct(); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); void forEachWithIndex(BiConsumer<? super T, Integer> biConsumer); @Override T1[] toArray(T1[] array); @Override boolean add(T element); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends T> c); @Override boolean removeAll(Collection<?> c); @Override boolean retainAll(Collection<?> c); @Override void clear(); @Override Iterator<T> iterator(); @Override int getOccurrences(T element); @Override boolean addOccurrence(T element); @Override boolean addOccurrences(T element, int occurrences); @Override boolean removeOccurrence(T element); @Override boolean removeOccurrences(T element, int occurrences); @Override void forEachWithOccurrences(BiConsumer<? super T, Integer> biConsumer); @Override void forEach(Consumer<? super T> consumer); @Override int hashCode(); @Override boolean equals(Object other); }
|
@Test public void toArray() { Assert.assertArrayEquals(new String[]{}, this.testObj.toArray()); this.testObj.withAll("1", "2", "3", "2", "3", "3"); Assert.assertArrayEquals(new String[]{"1", "2", "2", "3", "3", "3"}, this.testObj.toArray()); }
|
@Override public Object[] toArray() { Object[] result = new Object[this.size()]; this.forEachWithIndex((each, index) -> result[index] = each); return result; }
|
HashBag implements MutableBag<T> { @Override public Object[] toArray() { Object[] result = new Object[this.size()]; this.forEachWithIndex((each, index) -> result[index] = each); return result; } }
|
HashBag implements MutableBag<T> { @Override public Object[] toArray() { Object[] result = new Object[this.size()]; this.forEachWithIndex((each, index) -> result[index] = each); return result; } }
|
HashBag implements MutableBag<T> { @Override public Object[] toArray() { Object[] result = new Object[this.size()]; this.forEachWithIndex((each, index) -> result[index] = each); return result; } @Override int sizeDistinct(); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); void forEachWithIndex(BiConsumer<? super T, Integer> biConsumer); @Override T1[] toArray(T1[] array); @Override boolean add(T element); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends T> c); @Override boolean removeAll(Collection<?> c); @Override boolean retainAll(Collection<?> c); @Override void clear(); @Override Iterator<T> iterator(); @Override int getOccurrences(T element); @Override boolean addOccurrence(T element); @Override boolean addOccurrences(T element, int occurrences); @Override boolean removeOccurrence(T element); @Override boolean removeOccurrences(T element, int occurrences); @Override void forEachWithOccurrences(BiConsumer<? super T, Integer> biConsumer); @Override void forEach(Consumer<? super T> consumer); @Override int hashCode(); @Override boolean equals(Object other); }
|
HashBag implements MutableBag<T> { @Override public Object[] toArray() { Object[] result = new Object[this.size()]; this.forEachWithIndex((each, index) -> result[index] = each); return result; } @Override int sizeDistinct(); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); void forEachWithIndex(BiConsumer<? super T, Integer> biConsumer); @Override T1[] toArray(T1[] array); @Override boolean add(T element); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends T> c); @Override boolean removeAll(Collection<?> c); @Override boolean retainAll(Collection<?> c); @Override void clear(); @Override Iterator<T> iterator(); @Override int getOccurrences(T element); @Override boolean addOccurrence(T element); @Override boolean addOccurrences(T element, int occurrences); @Override boolean removeOccurrence(T element); @Override boolean removeOccurrences(T element, int occurrences); @Override void forEachWithOccurrences(BiConsumer<? super T, Integer> biConsumer); @Override void forEach(Consumer<? super T> consumer); @Override int hashCode(); @Override boolean equals(Object other); }
|
@Test public void cardsBySuit() { var ecCardsBySuit = this.ecDeck.getCardsBySuit(); var jdkCardsBySuit = this.jdkDeck.getCardsBySuit(); Assert.assertEquals(jdkCardsBySuit.get(Suit.CLUBS), ecCardsBySuit.get(Suit.CLUBS)); }
|
public ImmutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } EclipseCollectionsDeckOfCardsAsList(); }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } EclipseCollectionsDeckOfCardsAsList(); MutableStack<Card> shuffle(Random random); MutableSet<Card> deal(MutableStack<Card> stack, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(
MutableStack<Card> shuffled,
int hands,
int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Bag<Suit> countsBySuit(); Bag<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
EclipseCollectionsDeckOfCardsAsList { public ImmutableListMultimap<Suit, Card> getCardsBySuit() { return this.cardsBySuit; } EclipseCollectionsDeckOfCardsAsList(); MutableStack<Card> shuffle(Random random); MutableSet<Card> deal(MutableStack<Card> stack, int count); ImmutableList<Set<Card>> shuffleAndDeal(Random random, int hands, int cardsPerHand); ImmutableList<Set<Card>> dealHands(
MutableStack<Card> shuffled,
int hands,
int cardsPerHand); ImmutableList<Card> diamonds(); ImmutableList<Card> hearts(); ImmutableList<Card> spades(); ImmutableList<Card> clubs(); Bag<Suit> countsBySuit(); Bag<Rank> countsByRank(); ImmutableList<Card> getCards(); ImmutableListMultimap<Suit, Card> getCardsBySuit(); }
|
@Test public void testDeleteAccount() { }
|
@DELETE @Path("{userName}") @Consumes(MediaType.APPLICATION_JSON + ";charset=UTF-8") @Produces(MediaType.APPLICATION_JSON + ";charset=UTF-8") public Response<AccountEntry> deleteAccount(Request<AccountEntry> request, @PathParam("userName") String userName) { Data<AccountEntry> data, returnData; boolean deleted = false; try { userName = validateUsername(userName); RequestValidator.validateRequest(request); data = request.getMessage().getData(); Collection<AccountEntry> accounts = data.getEntries(); if (accounts.size() != 1) { return Response.badRequest("Number of entries must be 1.", null); } deleted = userManager.disable(userName); } catch (AccessDeniedException ex) { return Response.badRequest(ex.getMessage(), ex); } catch (IllegalArgumentException e) { return Response.badRequest(e.getMessage(), e); } catch (Exception e) { return Response.serverError(e.getMessage(), e); } if (deleted) { return Response.ok(); } else { return Response.serverError("could not delete account.", null); } }
|
AuthenticationController { @DELETE @Path("{userName}") @Consumes(MediaType.APPLICATION_JSON + ";charset=UTF-8") @Produces(MediaType.APPLICATION_JSON + ";charset=UTF-8") public Response<AccountEntry> deleteAccount(Request<AccountEntry> request, @PathParam("userName") String userName) { Data<AccountEntry> data, returnData; boolean deleted = false; try { userName = validateUsername(userName); RequestValidator.validateRequest(request); data = request.getMessage().getData(); Collection<AccountEntry> accounts = data.getEntries(); if (accounts.size() != 1) { return Response.badRequest("Number of entries must be 1.", null); } deleted = userManager.disable(userName); } catch (AccessDeniedException ex) { return Response.badRequest(ex.getMessage(), ex); } catch (IllegalArgumentException e) { return Response.badRequest(e.getMessage(), e); } catch (Exception e) { return Response.serverError(e.getMessage(), e); } if (deleted) { return Response.ok(); } else { return Response.serverError("could not delete account.", null); } } }
|
AuthenticationController { @DELETE @Path("{userName}") @Consumes(MediaType.APPLICATION_JSON + ";charset=UTF-8") @Produces(MediaType.APPLICATION_JSON + ";charset=UTF-8") public Response<AccountEntry> deleteAccount(Request<AccountEntry> request, @PathParam("userName") String userName) { Data<AccountEntry> data, returnData; boolean deleted = false; try { userName = validateUsername(userName); RequestValidator.validateRequest(request); data = request.getMessage().getData(); Collection<AccountEntry> accounts = data.getEntries(); if (accounts.size() != 1) { return Response.badRequest("Number of entries must be 1.", null); } deleted = userManager.disable(userName); } catch (AccessDeniedException ex) { return Response.badRequest(ex.getMessage(), ex); } catch (IllegalArgumentException e) { return Response.badRequest(e.getMessage(), e); } catch (Exception e) { return Response.serverError(e.getMessage(), e); } if (deleted) { return Response.ok(); } else { return Response.serverError("could not delete account.", null); } } }
|
AuthenticationController { @DELETE @Path("{userName}") @Consumes(MediaType.APPLICATION_JSON + ";charset=UTF-8") @Produces(MediaType.APPLICATION_JSON + ";charset=UTF-8") public Response<AccountEntry> deleteAccount(Request<AccountEntry> request, @PathParam("userName") String userName) { Data<AccountEntry> data, returnData; boolean deleted = false; try { userName = validateUsername(userName); RequestValidator.validateRequest(request); data = request.getMessage().getData(); Collection<AccountEntry> accounts = data.getEntries(); if (accounts.size() != 1) { return Response.badRequest("Number of entries must be 1.", null); } deleted = userManager.disable(userName); } catch (AccessDeniedException ex) { return Response.badRequest(ex.getMessage(), ex); } catch (IllegalArgumentException e) { return Response.badRequest(e.getMessage(), e); } catch (Exception e) { return Response.serverError(e.getMessage(), e); } if (deleted) { return Response.ok(); } else { return Response.serverError("could not delete account.", null); } } void setUserManager(UserManager userManager); void setAccessControlManager(AccessControlManager accessControlManager); @GET @Path("{userName}") @Produces(MediaType.APPLICATION_JSON + ";charset=UTF-8") Response<AccountEntry> getUser(
@PathParam("userName") String userName); @POST @Path("{userName}")// can be @me - then updating the current user @Consumes(MediaType.APPLICATION_JSON + ";charset=UTF-8") @Produces(MediaType.APPLICATION_JSON + ";charset=UTF-8") Response<AccountEntry> updateUser(
@PathParam("said") String said,
@PathParam("userName") String userName,
Request<AccountEntry> request); @DELETE @Path("{userName}") @Consumes(MediaType.APPLICATION_JSON + ";charset=UTF-8") @Produces(MediaType.APPLICATION_JSON + ";charset=UTF-8") Response<AccountEntry> deleteAccount(Request<AccountEntry> request,
@PathParam("userName") String userName); @GET @Path("/username") String getCurrentUserName(); @GET @Path("/role") String getCurrentRole(); @GET @Produces(MediaType.APPLICATION_JSON) @Path("/credentials/{contact-said}") Response<AccountEntry> getCredentials(
@PathParam("said") String saidLocal,
@PathParam("contact-said") String saidRequester); @POST @Produces(MediaType.APPLICATION_JSON) @Path("/credentials/{contact-said}") Response<?> confirmCredentials(
@PathParam("said") String saidLocal,
@PathParam("contact-said") String saidRequester); }
|
AuthenticationController { @DELETE @Path("{userName}") @Consumes(MediaType.APPLICATION_JSON + ";charset=UTF-8") @Produces(MediaType.APPLICATION_JSON + ";charset=UTF-8") public Response<AccountEntry> deleteAccount(Request<AccountEntry> request, @PathParam("userName") String userName) { Data<AccountEntry> data, returnData; boolean deleted = false; try { userName = validateUsername(userName); RequestValidator.validateRequest(request); data = request.getMessage().getData(); Collection<AccountEntry> accounts = data.getEntries(); if (accounts.size() != 1) { return Response.badRequest("Number of entries must be 1.", null); } deleted = userManager.disable(userName); } catch (AccessDeniedException ex) { return Response.badRequest(ex.getMessage(), ex); } catch (IllegalArgumentException e) { return Response.badRequest(e.getMessage(), e); } catch (Exception e) { return Response.serverError(e.getMessage(), e); } if (deleted) { return Response.ok(); } else { return Response.serverError("could not delete account.", null); } } void setUserManager(UserManager userManager); void setAccessControlManager(AccessControlManager accessControlManager); @GET @Path("{userName}") @Produces(MediaType.APPLICATION_JSON + ";charset=UTF-8") Response<AccountEntry> getUser(
@PathParam("userName") String userName); @POST @Path("{userName}")// can be @me - then updating the current user @Consumes(MediaType.APPLICATION_JSON + ";charset=UTF-8") @Produces(MediaType.APPLICATION_JSON + ";charset=UTF-8") Response<AccountEntry> updateUser(
@PathParam("said") String said,
@PathParam("userName") String userName,
Request<AccountEntry> request); @DELETE @Path("{userName}") @Consumes(MediaType.APPLICATION_JSON + ";charset=UTF-8") @Produces(MediaType.APPLICATION_JSON + ";charset=UTF-8") Response<AccountEntry> deleteAccount(Request<AccountEntry> request,
@PathParam("userName") String userName); @GET @Path("/username") String getCurrentUserName(); @GET @Path("/role") String getCurrentRole(); @GET @Produces(MediaType.APPLICATION_JSON) @Path("/credentials/{contact-said}") Response<AccountEntry> getCredentials(
@PathParam("said") String saidLocal,
@PathParam("contact-said") String saidRequester); @POST @Produces(MediaType.APPLICATION_JSON) @Path("/credentials/{contact-said}") Response<?> confirmCredentials(
@PathParam("said") String saidLocal,
@PathParam("contact-said") String saidRequester); }
|
@Test public void testGetAdapterName() throws Exception { DimeServiceAdapter adapter = new DimeServiceAdapter("test"); assertEquals("di.me", adapter.getAdapterName()); }
|
@Override public String getAdapterName() { return DimeServiceAdapter.NAME; }
|
DimeServiceAdapter extends ServiceAdapterBase implements InternalServiceAdapter { @Override public String getAdapterName() { return DimeServiceAdapter.NAME; } }
|
DimeServiceAdapter extends ServiceAdapterBase implements InternalServiceAdapter { @Override public String getAdapterName() { return DimeServiceAdapter.NAME; } DimeServiceAdapter(String identifier); }
|
DimeServiceAdapter extends ServiceAdapterBase implements InternalServiceAdapter { @Override public String getAdapterName() { return DimeServiceAdapter.NAME; } DimeServiceAdapter(String identifier); void setProxyFactory(ProxyFactory proxyFactory); void setAccountRegistrar(AccountRegistrar accountRegistrar); void setPublicResolverService(HttpRestProxy publicResolverService); void setCredentialStore(CredentialStore credentialStore); void setPolicyManager(PolicyManager policyManager); @Override String getAdapterName(); Collection<T> get(String receiverSAID, String senderSAID,
String attribute, Class<T> returnType, Tenant tenant); BinaryFile getBinary(String receiverSAID, String senderSAID,
String resourceId, Tenant tenant); @Override void _set(String attribute, Object value); @Override Collection<T> search(String attribute,
Resource values, Class<T> returnType); @Override Collection<T> search(Resource values,
Class<T> returnType); PersonContact getProfile(String targetSaidName, Token token); Token getUserToken(String username, Tenant tenant); boolean confirmToken(Token token, Tenant tenant); @Override Boolean isConnected(); ServiceResponse[] getRaw(String attribute); @Override Collection<T> get(String attribute, Class<T> returnType); @Override void response(String attribute, Resource value); @Override void delete(String attribute); }
|
DimeServiceAdapter extends ServiceAdapterBase implements InternalServiceAdapter { @Override public String getAdapterName() { return DimeServiceAdapter.NAME; } DimeServiceAdapter(String identifier); void setProxyFactory(ProxyFactory proxyFactory); void setAccountRegistrar(AccountRegistrar accountRegistrar); void setPublicResolverService(HttpRestProxy publicResolverService); void setCredentialStore(CredentialStore credentialStore); void setPolicyManager(PolicyManager policyManager); @Override String getAdapterName(); Collection<T> get(String receiverSAID, String senderSAID,
String attribute, Class<T> returnType, Tenant tenant); BinaryFile getBinary(String receiverSAID, String senderSAID,
String resourceId, Tenant tenant); @Override void _set(String attribute, Object value); @Override Collection<T> search(String attribute,
Resource values, Class<T> returnType); @Override Collection<T> search(Resource values,
Class<T> returnType); PersonContact getProfile(String targetSaidName, Token token); Token getUserToken(String username, Tenant tenant); boolean confirmToken(Token token, Tenant tenant); @Override Boolean isConnected(); ServiceResponse[] getRaw(String attribute); @Override Collection<T> get(String attribute, Class<T> returnType); @Override void response(String attribute, Resource value); @Override void delete(String attribute); static final String NAME; }
|
@Test public void testGetProfile() throws Exception { String said = "12345"; URL baseUrl = new URL("http: String path = "/api/dime/rest/:target/shared/profile".replace(":target", said); String json = "[{`@context`:{`nco`:`http: URI profileUri = new URIImpl("urn:uuid:3dcb73e4-399f-41af-b4f2-a8bb48c315a1"); URI phoneUri = new URIImpl("urn:uuid:e9e07fd8-f53f-453b-b2dc-307e04c4fb61"); URI nameUri = new URIImpl("urn:uuid:18e938b1-935d-4cb4-b763-3ca1d654305f"); AccountRegistrar mockRegistrar = Mockito.mock(AccountRegistrar.class); Mockito.when(mockRegistrar.resolve(said)).thenReturn(baseUrl); HttpRestProxy mockProxy = Mockito.mock(HttpRestProxy.class); Mockito.when(mockProxy.get(Mockito.eq(path), Mockito.anyMap())).thenReturn(json); ProxyFactory mockFactory = Mockito.mock(ProxyFactory.class); Mockito.when(mockFactory.createProxy(Mockito.eq(baseUrl), Mockito.anyString(), Mockito.anyString())).thenReturn(mockProxy); DimeServiceAdapter adapter = new DimeServiceAdapter("1"); adapter.setProxyFactory(mockFactory); adapter.setAccountRegistrar(mockRegistrar); PersonContact profile = adapter.getProfile(said, new Token("token", "secret")); Model metadata = profile.getModel(); assertEquals(profileUri, profile.asURI()); assertTrue(metadata.contains(profileUri, NCO.hasPersonName, nameUri)); assertTrue(metadata.contains(profileUri, NCO.hasPhoneNumber, phoneUri)); assertTrue(metadata.contains(nameUri, RDF.type, NCO.PersonName)); assertEquals("Ismael Rivera", ModelUtils.findObject(metadata, nameUri, NCO.fullname).asLiteral().getValue()); assertEquals("Ismael", ModelUtils.findObject(metadata, nameUri, NCO.nameGiven).asLiteral().getValue()); assertEquals("Rivera", ModelUtils.findObject(metadata, nameUri, NCO.nameFamily).asLiteral().getValue()); assertTrue(metadata.contains(phoneUri, RDF.type, NCO.PhoneNumber)); assertEquals("555-55-55", ModelUtils.findObject(metadata, phoneUri, NCO.phoneNumber).asLiteral().getValue()); }
|
public PersonContact getProfile(String targetSaidName, Token token) throws AttributeNotSupportedException, ServiceNotAvailableException { HttpRestProxy proxy = null; PersonContact profile = null; final String path = SHARED_PROFILE_PATH.replace(":target", targetSaidName); try { URL baseURL = accountRegistrar.resolve(targetSaidName); proxy = proxyFactory.createProxy(baseURL, token.getToken(), token.getSecret()); Map<String, String> headers = headers( "Accept", MediaType.APPLICATION_JSONLD); String response = proxy.get(path, headers); logger.info("GET "+path+" [username="+token.getToken()+", password="+token.getSecret()+"] responded with: "+response); profile = JSONLDUtils.deserialize(response, PersonContact.class); if (logger.isDebugEnabled()) { logger.debug("Profile metadata for "+path+" response is:\n"+profile.getModel().serialize(Syntax.Turtle)); } } catch (AccountCannotResolveException e) { throw new ServiceNotAvailableException("said not registered at dns: " + targetSaidName, e); } catch (JsonParseException e) { throw new ServiceNotAvailableException( "Could not process response from "+path+", invalid JSON returned: "+e.getMessage(), "SERV-100"); } catch (JsonMappingException e) { throw new ServiceNotAvailableException( "Could not process response, invalid JSON returned: "+e.getMessage(), "SERV-100"); } catch (Exception e) { throw new ServiceNotAvailableException("Unknown error occurred: "+e.getMessage(), e); } finally { if (proxy != null) { proxy.close(); } } return profile; }
|
DimeServiceAdapter extends ServiceAdapterBase implements InternalServiceAdapter { public PersonContact getProfile(String targetSaidName, Token token) throws AttributeNotSupportedException, ServiceNotAvailableException { HttpRestProxy proxy = null; PersonContact profile = null; final String path = SHARED_PROFILE_PATH.replace(":target", targetSaidName); try { URL baseURL = accountRegistrar.resolve(targetSaidName); proxy = proxyFactory.createProxy(baseURL, token.getToken(), token.getSecret()); Map<String, String> headers = headers( "Accept", MediaType.APPLICATION_JSONLD); String response = proxy.get(path, headers); logger.info("GET "+path+" [username="+token.getToken()+", password="+token.getSecret()+"] responded with: "+response); profile = JSONLDUtils.deserialize(response, PersonContact.class); if (logger.isDebugEnabled()) { logger.debug("Profile metadata for "+path+" response is:\n"+profile.getModel().serialize(Syntax.Turtle)); } } catch (AccountCannotResolveException e) { throw new ServiceNotAvailableException("said not registered at dns: " + targetSaidName, e); } catch (JsonParseException e) { throw new ServiceNotAvailableException( "Could not process response from "+path+", invalid JSON returned: "+e.getMessage(), "SERV-100"); } catch (JsonMappingException e) { throw new ServiceNotAvailableException( "Could not process response, invalid JSON returned: "+e.getMessage(), "SERV-100"); } catch (Exception e) { throw new ServiceNotAvailableException("Unknown error occurred: "+e.getMessage(), e); } finally { if (proxy != null) { proxy.close(); } } return profile; } }
|
DimeServiceAdapter extends ServiceAdapterBase implements InternalServiceAdapter { public PersonContact getProfile(String targetSaidName, Token token) throws AttributeNotSupportedException, ServiceNotAvailableException { HttpRestProxy proxy = null; PersonContact profile = null; final String path = SHARED_PROFILE_PATH.replace(":target", targetSaidName); try { URL baseURL = accountRegistrar.resolve(targetSaidName); proxy = proxyFactory.createProxy(baseURL, token.getToken(), token.getSecret()); Map<String, String> headers = headers( "Accept", MediaType.APPLICATION_JSONLD); String response = proxy.get(path, headers); logger.info("GET "+path+" [username="+token.getToken()+", password="+token.getSecret()+"] responded with: "+response); profile = JSONLDUtils.deserialize(response, PersonContact.class); if (logger.isDebugEnabled()) { logger.debug("Profile metadata for "+path+" response is:\n"+profile.getModel().serialize(Syntax.Turtle)); } } catch (AccountCannotResolveException e) { throw new ServiceNotAvailableException("said not registered at dns: " + targetSaidName, e); } catch (JsonParseException e) { throw new ServiceNotAvailableException( "Could not process response from "+path+", invalid JSON returned: "+e.getMessage(), "SERV-100"); } catch (JsonMappingException e) { throw new ServiceNotAvailableException( "Could not process response, invalid JSON returned: "+e.getMessage(), "SERV-100"); } catch (Exception e) { throw new ServiceNotAvailableException("Unknown error occurred: "+e.getMessage(), e); } finally { if (proxy != null) { proxy.close(); } } return profile; } DimeServiceAdapter(String identifier); }
|
DimeServiceAdapter extends ServiceAdapterBase implements InternalServiceAdapter { public PersonContact getProfile(String targetSaidName, Token token) throws AttributeNotSupportedException, ServiceNotAvailableException { HttpRestProxy proxy = null; PersonContact profile = null; final String path = SHARED_PROFILE_PATH.replace(":target", targetSaidName); try { URL baseURL = accountRegistrar.resolve(targetSaidName); proxy = proxyFactory.createProxy(baseURL, token.getToken(), token.getSecret()); Map<String, String> headers = headers( "Accept", MediaType.APPLICATION_JSONLD); String response = proxy.get(path, headers); logger.info("GET "+path+" [username="+token.getToken()+", password="+token.getSecret()+"] responded with: "+response); profile = JSONLDUtils.deserialize(response, PersonContact.class); if (logger.isDebugEnabled()) { logger.debug("Profile metadata for "+path+" response is:\n"+profile.getModel().serialize(Syntax.Turtle)); } } catch (AccountCannotResolveException e) { throw new ServiceNotAvailableException("said not registered at dns: " + targetSaidName, e); } catch (JsonParseException e) { throw new ServiceNotAvailableException( "Could not process response from "+path+", invalid JSON returned: "+e.getMessage(), "SERV-100"); } catch (JsonMappingException e) { throw new ServiceNotAvailableException( "Could not process response, invalid JSON returned: "+e.getMessage(), "SERV-100"); } catch (Exception e) { throw new ServiceNotAvailableException("Unknown error occurred: "+e.getMessage(), e); } finally { if (proxy != null) { proxy.close(); } } return profile; } DimeServiceAdapter(String identifier); void setProxyFactory(ProxyFactory proxyFactory); void setAccountRegistrar(AccountRegistrar accountRegistrar); void setPublicResolverService(HttpRestProxy publicResolverService); void setCredentialStore(CredentialStore credentialStore); void setPolicyManager(PolicyManager policyManager); @Override String getAdapterName(); Collection<T> get(String receiverSAID, String senderSAID,
String attribute, Class<T> returnType, Tenant tenant); BinaryFile getBinary(String receiverSAID, String senderSAID,
String resourceId, Tenant tenant); @Override void _set(String attribute, Object value); @Override Collection<T> search(String attribute,
Resource values, Class<T> returnType); @Override Collection<T> search(Resource values,
Class<T> returnType); PersonContact getProfile(String targetSaidName, Token token); Token getUserToken(String username, Tenant tenant); boolean confirmToken(Token token, Tenant tenant); @Override Boolean isConnected(); ServiceResponse[] getRaw(String attribute); @Override Collection<T> get(String attribute, Class<T> returnType); @Override void response(String attribute, Resource value); @Override void delete(String attribute); }
|
DimeServiceAdapter extends ServiceAdapterBase implements InternalServiceAdapter { public PersonContact getProfile(String targetSaidName, Token token) throws AttributeNotSupportedException, ServiceNotAvailableException { HttpRestProxy proxy = null; PersonContact profile = null; final String path = SHARED_PROFILE_PATH.replace(":target", targetSaidName); try { URL baseURL = accountRegistrar.resolve(targetSaidName); proxy = proxyFactory.createProxy(baseURL, token.getToken(), token.getSecret()); Map<String, String> headers = headers( "Accept", MediaType.APPLICATION_JSONLD); String response = proxy.get(path, headers); logger.info("GET "+path+" [username="+token.getToken()+", password="+token.getSecret()+"] responded with: "+response); profile = JSONLDUtils.deserialize(response, PersonContact.class); if (logger.isDebugEnabled()) { logger.debug("Profile metadata for "+path+" response is:\n"+profile.getModel().serialize(Syntax.Turtle)); } } catch (AccountCannotResolveException e) { throw new ServiceNotAvailableException("said not registered at dns: " + targetSaidName, e); } catch (JsonParseException e) { throw new ServiceNotAvailableException( "Could not process response from "+path+", invalid JSON returned: "+e.getMessage(), "SERV-100"); } catch (JsonMappingException e) { throw new ServiceNotAvailableException( "Could not process response, invalid JSON returned: "+e.getMessage(), "SERV-100"); } catch (Exception e) { throw new ServiceNotAvailableException("Unknown error occurred: "+e.getMessage(), e); } finally { if (proxy != null) { proxy.close(); } } return profile; } DimeServiceAdapter(String identifier); void setProxyFactory(ProxyFactory proxyFactory); void setAccountRegistrar(AccountRegistrar accountRegistrar); void setPublicResolverService(HttpRestProxy publicResolverService); void setCredentialStore(CredentialStore credentialStore); void setPolicyManager(PolicyManager policyManager); @Override String getAdapterName(); Collection<T> get(String receiverSAID, String senderSAID,
String attribute, Class<T> returnType, Tenant tenant); BinaryFile getBinary(String receiverSAID, String senderSAID,
String resourceId, Tenant tenant); @Override void _set(String attribute, Object value); @Override Collection<T> search(String attribute,
Resource values, Class<T> returnType); @Override Collection<T> search(Resource values,
Class<T> returnType); PersonContact getProfile(String targetSaidName, Token token); Token getUserToken(String username, Tenant tenant); boolean confirmToken(Token token, Tenant tenant); @Override Boolean isConnected(); ServiceResponse[] getRaw(String attribute); @Override Collection<T> get(String attribute, Class<T> returnType); @Override void response(String attribute, Resource value); @Override void delete(String attribute); static final String NAME; }
|
@Test public void testGetAttribute() { AttributeMap attributeMap = new AttributeMap(); assertTrue("Wrong mapping found for getAttribute(/event/@all).", attributeMap.getAttribute("/event/@all").equals(AttributeMap.EVENT_ALL)); assertTrue("Wrong mapping found for getAttribute(/event/@me/123).", attributeMap.getAttribute("/event/@me/123").equals(AttributeMap.EVENT_DETAILS)); }
|
public String getAttribute (String input) { Iterator<String> iterator = this.attributes.iterator(); while (iterator.hasNext()) { String candidate = iterator.next(); String attr = candidate.replaceAll("\\{\\w+\\}", "([^/]+)"); if (input.matches(attr)) { return candidate; } } return null; }
|
AttributeMap { public String getAttribute (String input) { Iterator<String> iterator = this.attributes.iterator(); while (iterator.hasNext()) { String candidate = iterator.next(); String attr = candidate.replaceAll("\\{\\w+\\}", "([^/]+)"); if (input.matches(attr)) { return candidate; } } return null; } }
|
AttributeMap { public String getAttribute (String input) { Iterator<String> iterator = this.attributes.iterator(); while (iterator.hasNext()) { String candidate = iterator.next(); String attr = candidate.replaceAll("\\{\\w+\\}", "([^/]+)"); if (input.matches(attr)) { return candidate; } } return null; } AttributeMap(); }
|
AttributeMap { public String getAttribute (String input) { Iterator<String> iterator = this.attributes.iterator(); while (iterator.hasNext()) { String candidate = iterator.next(); String attr = candidate.replaceAll("\\{\\w+\\}", "([^/]+)"); if (input.matches(attr)) { return candidate; } } return null; } AttributeMap(); String getAttribute(String input); Map<String, String> extractIds(String attribute, String input); }
|
AttributeMap { public String getAttribute (String input) { Iterator<String> iterator = this.attributes.iterator(); while (iterator.hasNext()) { String candidate = iterator.next(); String attr = candidate.replaceAll("\\{\\w+\\}", "([^/]+)"); if (input.matches(attr)) { return candidate; } } return null; } AttributeMap(); String getAttribute(String input); Map<String, String> extractIds(String attribute, String input); static final String EVENT_ID; static final String USER_ID; static final String EVENT_ALL; static final String EVENT_ALLMINE; static final String EVENT_DETAILS; static final String EVENT_ATTENDEES; static final String EVENT_ATTENDEEDETAILS; static final String PROFILE_ME; static final String PROFILE_MYDETAILS; static final String PROFILE_DETAILS; static final String PROFILEATTRIBUTE_MYDETAILS; static final String PROFILEATTRIBUTE_DETAILS; static final String FRIEND_ALL; static final String FRIEND_DETAILS; static final String GROUP_ALL; static final String LIVEPOST_ALL; static final String LIVEPOST_ALLMINE; static final String LIVEPOST_ALLUSER; static final String NOTIFICATION; static final String PLACE_ALL; static final String ACTIVITY_ALL; static final String ACTIVITY_DETAILS; }
|
@Test public void testExtractIds() { AttributeMap attributeMap = new AttributeMap(); Map<String, String> details = attributeMap.extractIds(AttributeMap.EVENT_ALL, "/event/@all"); assertTrue("Wrong eventId detected for /event/@all", details.get(AttributeMap.EVENT_ID) == null); assertTrue("Wrong userId detected for /event/@all", details.get(AttributeMap.USER_ID) == null); details = attributeMap.extractIds(AttributeMap.EVENT_DETAILS, "/event/@me/123"); assertTrue("Wrong eventId detected for /event/@me/123", details.get(AttributeMap.EVENT_ID).equals("123")); assertTrue("Wrong userId detected for /event/@me/123", details.get(AttributeMap.USER_ID) == null); details = attributeMap.extractIds(AttributeMap.EVENT_ATTENDEEDETAILS, "/event/@me/123/456"); assertTrue("Wrong eventId detected for /event/@me/123/456", details.get(AttributeMap.EVENT_ID).equals("123")); assertTrue("Wrong userId detected for /event/@me/123/456", details.get(AttributeMap.USER_ID).equals("456")); }
|
public Map<String, String> extractIds (String attribute, String input) { HashMap<String, String> idMap = new HashMap<String, String>(); Iterator<String> iterator = this.idnames.iterator(); while (iterator.hasNext()) { String candidate = iterator.next(); String attr = attribute.replaceAll("\\{"+candidate+"\\}", "([^/]+)").replaceAll("\\{\\w+\\}", "[^/]+"); Pattern pattern = Pattern.compile(attr); Matcher matcher = pattern.matcher(input); if (matcher.find() && matcher.groupCount() >= 1) { idMap.put(candidate, matcher.group(1)); } } return idMap; }
|
AttributeMap { public Map<String, String> extractIds (String attribute, String input) { HashMap<String, String> idMap = new HashMap<String, String>(); Iterator<String> iterator = this.idnames.iterator(); while (iterator.hasNext()) { String candidate = iterator.next(); String attr = attribute.replaceAll("\\{"+candidate+"\\}", "([^/]+)").replaceAll("\\{\\w+\\}", "[^/]+"); Pattern pattern = Pattern.compile(attr); Matcher matcher = pattern.matcher(input); if (matcher.find() && matcher.groupCount() >= 1) { idMap.put(candidate, matcher.group(1)); } } return idMap; } }
|
AttributeMap { public Map<String, String> extractIds (String attribute, String input) { HashMap<String, String> idMap = new HashMap<String, String>(); Iterator<String> iterator = this.idnames.iterator(); while (iterator.hasNext()) { String candidate = iterator.next(); String attr = attribute.replaceAll("\\{"+candidate+"\\}", "([^/]+)").replaceAll("\\{\\w+\\}", "[^/]+"); Pattern pattern = Pattern.compile(attr); Matcher matcher = pattern.matcher(input); if (matcher.find() && matcher.groupCount() >= 1) { idMap.put(candidate, matcher.group(1)); } } return idMap; } AttributeMap(); }
|
AttributeMap { public Map<String, String> extractIds (String attribute, String input) { HashMap<String, String> idMap = new HashMap<String, String>(); Iterator<String> iterator = this.idnames.iterator(); while (iterator.hasNext()) { String candidate = iterator.next(); String attr = attribute.replaceAll("\\{"+candidate+"\\}", "([^/]+)").replaceAll("\\{\\w+\\}", "[^/]+"); Pattern pattern = Pattern.compile(attr); Matcher matcher = pattern.matcher(input); if (matcher.find() && matcher.groupCount() >= 1) { idMap.put(candidate, matcher.group(1)); } } return idMap; } AttributeMap(); String getAttribute(String input); Map<String, String> extractIds(String attribute, String input); }
|
AttributeMap { public Map<String, String> extractIds (String attribute, String input) { HashMap<String, String> idMap = new HashMap<String, String>(); Iterator<String> iterator = this.idnames.iterator(); while (iterator.hasNext()) { String candidate = iterator.next(); String attr = attribute.replaceAll("\\{"+candidate+"\\}", "([^/]+)").replaceAll("\\{\\w+\\}", "[^/]+"); Pattern pattern = Pattern.compile(attr); Matcher matcher = pattern.matcher(input); if (matcher.find() && matcher.groupCount() >= 1) { idMap.put(candidate, matcher.group(1)); } } return idMap; } AttributeMap(); String getAttribute(String input); Map<String, String> extractIds(String attribute, String input); static final String EVENT_ID; static final String USER_ID; static final String EVENT_ALL; static final String EVENT_ALLMINE; static final String EVENT_DETAILS; static final String EVENT_ATTENDEES; static final String EVENT_ATTENDEEDETAILS; static final String PROFILE_ME; static final String PROFILE_MYDETAILS; static final String PROFILE_DETAILS; static final String PROFILEATTRIBUTE_MYDETAILS; static final String PROFILEATTRIBUTE_DETAILS; static final String FRIEND_ALL; static final String FRIEND_DETAILS; static final String GROUP_ALL; static final String LIVEPOST_ALL; static final String LIVEPOST_ALLMINE; static final String LIVEPOST_ALLUSER; static final String NOTIFICATION; static final String PLACE_ALL; static final String ACTIVITY_ALL; static final String ACTIVITY_DETAILS; }
|
@Test public void testCreateLogForContext() throws ResourceExistsException { URI liveContext = new URIImpl("urn:live-context"); Environment environment = modelFactory.getDCONFactory().createEnvironment(); URI temperatureUri = new URIImpl("urn:temperature:123"); environment.setCurrentTemperature(temperatureUri); resourceStore.createGraph(liveContext); resourceStore.create(liveContext, environment); URI logUri = historyLogService.createLogForContext(liveContext); URI metadataUri = tripleStore.getOrCreateMetadataGraph(logUri); assertTrue(tripleStore.containsStatements(metadataUri, logUri, RDF.type, DUHO.ContextLog)); assertTrue(tripleStore.containsStatements(metadataUri, logUri, DUHO.timestamp, Variable.ANY)); assertFalse(tripleStore.containsStatements(logUri, liveContext, Variable.ANY, Variable.ANY)); assertTrue(tripleStore.containsStatements(logUri, environment.asResource(), RDF.type, DCON.Environment)); assertTrue(tripleStore.containsStatements(logUri, environment.asResource(), DCON.currentTemperature, temperatureUri)); assertFalse(tripleStore.containsStatements(logUri, Variable.ANY, NAO.hasDataGraph, Variable.ANY)); assertFalse(tripleStore.containsStatements(logUri, Variable.ANY, NAO.isDataGraphFor, Variable.ANY)); }
|
public URI createLogForContext(URI contextGraph) { TripleStore tripleStore = resourceStore.getTripleStore(); URI logGraph = resourceStore.createGraph(DUHO.ContextLog); URI metadataGraph = tripleStore.getOrCreateMetadataGraph(logGraph); Model metadata = RDF2Go.getModelFactory().createModel().open(); metadata.addAll(tripleStore.getModel(contextGraph).iterator()); metadata.removeStatements(Variable.ANY, NAO.hasDataGraph, Variable.ANY); metadata.removeStatements(Variable.ANY, NAO.isDataGraphFor, Variable.ANY); tripleStore.addAll(logGraph, metadata.iterator()); tripleStore.addStatement(metadataGraph, logGraph, DUHO.timestamp, DateUtil.currentDateTimeAsLiteral()); broadcastManager.sendBroadcast(new Event(resourceStore.getName(), Event.ACTION_GRAPH_ADD, logGraph)); return logGraph; }
|
HistoryLogService { public URI createLogForContext(URI contextGraph) { TripleStore tripleStore = resourceStore.getTripleStore(); URI logGraph = resourceStore.createGraph(DUHO.ContextLog); URI metadataGraph = tripleStore.getOrCreateMetadataGraph(logGraph); Model metadata = RDF2Go.getModelFactory().createModel().open(); metadata.addAll(tripleStore.getModel(contextGraph).iterator()); metadata.removeStatements(Variable.ANY, NAO.hasDataGraph, Variable.ANY); metadata.removeStatements(Variable.ANY, NAO.isDataGraphFor, Variable.ANY); tripleStore.addAll(logGraph, metadata.iterator()); tripleStore.addStatement(metadataGraph, logGraph, DUHO.timestamp, DateUtil.currentDateTimeAsLiteral()); broadcastManager.sendBroadcast(new Event(resourceStore.getName(), Event.ACTION_GRAPH_ADD, logGraph)); return logGraph; } }
|
HistoryLogService { public URI createLogForContext(URI contextGraph) { TripleStore tripleStore = resourceStore.getTripleStore(); URI logGraph = resourceStore.createGraph(DUHO.ContextLog); URI metadataGraph = tripleStore.getOrCreateMetadataGraph(logGraph); Model metadata = RDF2Go.getModelFactory().createModel().open(); metadata.addAll(tripleStore.getModel(contextGraph).iterator()); metadata.removeStatements(Variable.ANY, NAO.hasDataGraph, Variable.ANY); metadata.removeStatements(Variable.ANY, NAO.isDataGraphFor, Variable.ANY); tripleStore.addAll(logGraph, metadata.iterator()); tripleStore.addStatement(metadataGraph, logGraph, DUHO.timestamp, DateUtil.currentDateTimeAsLiteral()); broadcastManager.sendBroadcast(new Event(resourceStore.getName(), Event.ACTION_GRAPH_ADD, logGraph)); return logGraph; } HistoryLogService(ResourceStore resourceStore); }
|
HistoryLogService { public URI createLogForContext(URI contextGraph) { TripleStore tripleStore = resourceStore.getTripleStore(); URI logGraph = resourceStore.createGraph(DUHO.ContextLog); URI metadataGraph = tripleStore.getOrCreateMetadataGraph(logGraph); Model metadata = RDF2Go.getModelFactory().createModel().open(); metadata.addAll(tripleStore.getModel(contextGraph).iterator()); metadata.removeStatements(Variable.ANY, NAO.hasDataGraph, Variable.ANY); metadata.removeStatements(Variable.ANY, NAO.isDataGraphFor, Variable.ANY); tripleStore.addAll(logGraph, metadata.iterator()); tripleStore.addStatement(metadataGraph, logGraph, DUHO.timestamp, DateUtil.currentDateTimeAsLiteral()); broadcastManager.sendBroadcast(new Event(resourceStore.getName(), Event.ACTION_GRAPH_ADD, logGraph)); return logGraph; } HistoryLogService(ResourceStore resourceStore); void cleanup(URI type, Calendar from); URI createLogForContext(URI contextGraph); URI createLogForPrivacyPreference(PrivacyPreference privacyPref); }
|
HistoryLogService { public URI createLogForContext(URI contextGraph) { TripleStore tripleStore = resourceStore.getTripleStore(); URI logGraph = resourceStore.createGraph(DUHO.ContextLog); URI metadataGraph = tripleStore.getOrCreateMetadataGraph(logGraph); Model metadata = RDF2Go.getModelFactory().createModel().open(); metadata.addAll(tripleStore.getModel(contextGraph).iterator()); metadata.removeStatements(Variable.ANY, NAO.hasDataGraph, Variable.ANY); metadata.removeStatements(Variable.ANY, NAO.isDataGraphFor, Variable.ANY); tripleStore.addAll(logGraph, metadata.iterator()); tripleStore.addStatement(metadataGraph, logGraph, DUHO.timestamp, DateUtil.currentDateTimeAsLiteral()); broadcastManager.sendBroadcast(new Event(resourceStore.getName(), Event.ACTION_GRAPH_ADD, logGraph)); return logGraph; } HistoryLogService(ResourceStore resourceStore); void cleanup(URI type, Calendar from); URI createLogForContext(URI contextGraph); URI createLogForPrivacyPreference(PrivacyPreference privacyPref); }
|
@Test public void testCreateLogForPrivacyPreference() throws ResourceExistsException { URI testGraph = new URIImpl("test:graph"); URI group1 = new URIImpl("urn:group:1"); URI person3 = new URIImpl("urn:person:3"); URI person14 = new URIImpl("urn:person:14"); PrivacyPreference privacyPref = modelFactory.getPPOFactory().createPrivacyPreference(); privacyPref.setPrefLabel("example"); AccessSpace accessSpace = modelFactory.getNSOFactory().createAccessSpace(); accessSpace.addIncludes(group1); accessSpace.addExcludes(person3); privacyPref.setAccessSpace(accessSpace); resourceStore.createOrUpdate(testGraph, privacyPref); resourceStore.createOrUpdate(testGraph, accessSpace); URI logUri = historyLogService.createLogForPrivacyPreference(privacyPref); URI metadataUri = tripleStore.getOrCreateMetadataGraph(logUri); accessSpace.addIncludes(person14); resourceStore.createOrUpdate(testGraph, accessSpace); assertTrue(tripleStore.containsStatements(metadataUri, logUri, RDF.type, DUHO.PrivacyPreferenceLog)); assertTrue(tripleStore.containsStatements(logUri, privacyPref, RDF.type, PPO.PrivacyPreference)); assertTrue(tripleStore.containsStatements(logUri, privacyPref, PPO.hasAccessSpace, accessSpace)); assertTrue(tripleStore.containsStatements(logUri, accessSpace, NSO.includes, group1)); assertTrue(tripleStore.containsStatements(logUri, accessSpace, NSO.excludes, person3)); assertFalse(tripleStore.containsStatements(logUri, accessSpace, NSO.includes, person14)); assertTrue(tripleStore.containsStatements(testGraph, accessSpace, NSO.includes, person14)); }
|
public URI createLogForPrivacyPreference(PrivacyPreference privacyPref) { TripleStore tripleStore = resourceStore.getTripleStore(); URI logGraph = resourceStore.createGraph(DUHO.PrivacyPreferenceLog); URI metadataGraph = tripleStore.getOrCreateMetadataGraph(logGraph); tripleStore.addAll(logGraph, privacyPref.getModel().iterator()); try { tripleStore.addAll(logGraph, resourceStore.get(privacyPref.getAllAccessSpace().next().asResource()).getModel().iterator()); } catch (NoSuchElementException e) { logger.error("The privacy preference "+privacyPref.asResource()+" does not contain any AccessSpace: "+e.getMessage(), e); } catch (NotFoundException e) { logger.error("The privacy preference "+privacyPref.asResource()+" references an AccessSpace which does not exist: "+e.getMessage(), e); } tripleStore.addStatement(metadataGraph, logGraph, DUHO.timestamp, DateUtil.currentDateTimeAsLiteral()); broadcastManager.sendBroadcast(new Event(resourceStore.getName(), Event.ACTION_GRAPH_ADD, logGraph)); return logGraph; }
|
HistoryLogService { public URI createLogForPrivacyPreference(PrivacyPreference privacyPref) { TripleStore tripleStore = resourceStore.getTripleStore(); URI logGraph = resourceStore.createGraph(DUHO.PrivacyPreferenceLog); URI metadataGraph = tripleStore.getOrCreateMetadataGraph(logGraph); tripleStore.addAll(logGraph, privacyPref.getModel().iterator()); try { tripleStore.addAll(logGraph, resourceStore.get(privacyPref.getAllAccessSpace().next().asResource()).getModel().iterator()); } catch (NoSuchElementException e) { logger.error("The privacy preference "+privacyPref.asResource()+" does not contain any AccessSpace: "+e.getMessage(), e); } catch (NotFoundException e) { logger.error("The privacy preference "+privacyPref.asResource()+" references an AccessSpace which does not exist: "+e.getMessage(), e); } tripleStore.addStatement(metadataGraph, logGraph, DUHO.timestamp, DateUtil.currentDateTimeAsLiteral()); broadcastManager.sendBroadcast(new Event(resourceStore.getName(), Event.ACTION_GRAPH_ADD, logGraph)); return logGraph; } }
|
HistoryLogService { public URI createLogForPrivacyPreference(PrivacyPreference privacyPref) { TripleStore tripleStore = resourceStore.getTripleStore(); URI logGraph = resourceStore.createGraph(DUHO.PrivacyPreferenceLog); URI metadataGraph = tripleStore.getOrCreateMetadataGraph(logGraph); tripleStore.addAll(logGraph, privacyPref.getModel().iterator()); try { tripleStore.addAll(logGraph, resourceStore.get(privacyPref.getAllAccessSpace().next().asResource()).getModel().iterator()); } catch (NoSuchElementException e) { logger.error("The privacy preference "+privacyPref.asResource()+" does not contain any AccessSpace: "+e.getMessage(), e); } catch (NotFoundException e) { logger.error("The privacy preference "+privacyPref.asResource()+" references an AccessSpace which does not exist: "+e.getMessage(), e); } tripleStore.addStatement(metadataGraph, logGraph, DUHO.timestamp, DateUtil.currentDateTimeAsLiteral()); broadcastManager.sendBroadcast(new Event(resourceStore.getName(), Event.ACTION_GRAPH_ADD, logGraph)); return logGraph; } HistoryLogService(ResourceStore resourceStore); }
|
HistoryLogService { public URI createLogForPrivacyPreference(PrivacyPreference privacyPref) { TripleStore tripleStore = resourceStore.getTripleStore(); URI logGraph = resourceStore.createGraph(DUHO.PrivacyPreferenceLog); URI metadataGraph = tripleStore.getOrCreateMetadataGraph(logGraph); tripleStore.addAll(logGraph, privacyPref.getModel().iterator()); try { tripleStore.addAll(logGraph, resourceStore.get(privacyPref.getAllAccessSpace().next().asResource()).getModel().iterator()); } catch (NoSuchElementException e) { logger.error("The privacy preference "+privacyPref.asResource()+" does not contain any AccessSpace: "+e.getMessage(), e); } catch (NotFoundException e) { logger.error("The privacy preference "+privacyPref.asResource()+" references an AccessSpace which does not exist: "+e.getMessage(), e); } tripleStore.addStatement(metadataGraph, logGraph, DUHO.timestamp, DateUtil.currentDateTimeAsLiteral()); broadcastManager.sendBroadcast(new Event(resourceStore.getName(), Event.ACTION_GRAPH_ADD, logGraph)); return logGraph; } HistoryLogService(ResourceStore resourceStore); void cleanup(URI type, Calendar from); URI createLogForContext(URI contextGraph); URI createLogForPrivacyPreference(PrivacyPreference privacyPref); }
|
HistoryLogService { public URI createLogForPrivacyPreference(PrivacyPreference privacyPref) { TripleStore tripleStore = resourceStore.getTripleStore(); URI logGraph = resourceStore.createGraph(DUHO.PrivacyPreferenceLog); URI metadataGraph = tripleStore.getOrCreateMetadataGraph(logGraph); tripleStore.addAll(logGraph, privacyPref.getModel().iterator()); try { tripleStore.addAll(logGraph, resourceStore.get(privacyPref.getAllAccessSpace().next().asResource()).getModel().iterator()); } catch (NoSuchElementException e) { logger.error("The privacy preference "+privacyPref.asResource()+" does not contain any AccessSpace: "+e.getMessage(), e); } catch (NotFoundException e) { logger.error("The privacy preference "+privacyPref.asResource()+" references an AccessSpace which does not exist: "+e.getMessage(), e); } tripleStore.addStatement(metadataGraph, logGraph, DUHO.timestamp, DateUtil.currentDateTimeAsLiteral()); broadcastManager.sendBroadcast(new Event(resourceStore.getName(), Event.ACTION_GRAPH_ADD, logGraph)); return logGraph; } HistoryLogService(ResourceStore resourceStore); void cleanup(URI type, Calendar from); URI createLogForContext(URI contextGraph); URI createLogForPrivacyPreference(PrivacyPreference privacyPref); }
|
@Test public void testUpdateSeveralResources() throws LiveContextException { List<Statement> toAdd = new ArrayList<Statement>(); List<Statement> toRemove = new ArrayList<Statement>(); URI environment = new URIImpl("urn:uuid:"+UUID.randomUUID()); URI temp = new URIImpl("urn:uuid:"+UUID.randomUUID()); URI weather = new URIImpl("urn:uuid:"+UUID.randomUUID()); toAdd.add(new StatementImpl(null, environment, RDF.type, DCON.Environment)); toAdd.add(new StatementImpl(null, environment, DCON.currentTemperature, temp)); toAdd.add(new StatementImpl(null, environment, DCON.currentWeather, weather)); toAdd.add(new StatementImpl(null, temp, RDF.type, DPO.Temperature)); toAdd.add(new StatementImpl(null, temp, DCON.temperature, new DatatypeLiteralImpl("34.0", XSD._double))); toAdd.add(new StatementImpl(null, weather, RDF.type, DPO.WeatherConditions)); toAdd.add(new StatementImpl(null, weather, DCON.cloudcover, new DatatypeLiteralImpl("5", XSD._int))); strategy.update(toAdd, toRemove); Resource aspectURI = null; URI weatherConditionsURI = null; URI temperatureURI = null; assertEquals(0, this.previousContext.size()); assertEquals(7, this.liveContext.size()); assertTrue(this.liveContext.findStatements(environment, RDF.type, DCON.Environment).hasNext()); aspectURI = this.liveContext.findStatements(environment, RDF.type, DCON.Environment).next().getSubject(); assertTrue(this.liveContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).hasNext()); weatherConditionsURI = this.liveContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).next().getObject().asURI(); assertTrue(this.liveContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).hasNext()); temperatureURI = this.liveContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).next().getObject().asURI(); assertTrue(this.liveContext.findStatements(temperatureURI, RDF.type, DPO.Temperature).hasNext()); assertTrue(this.liveContext.findStatements(temperatureURI, DCON.temperature, new DatatypeLiteralImpl("34.0", XSD._double)).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, RDF.type, DPO.WeatherConditions).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, DCON.cloudcover, new DatatypeLiteralImpl("5", XSD._int)).hasNext()); toAdd.clear(); toRemove.clear(); toAdd.add(new StatementImpl(null, temp, DCON.temperature, new DatatypeLiteralImpl("36.0", XSD._double))); toRemove.add(new StatementImpl(null, temp, DCON.temperature, new DatatypeLiteralImpl("34.0", XSD._double))); strategy.update(toAdd, toRemove); assertEquals(5, this.previousContext.size()); assertTrue(this.previousContext.findStatements(environment, RDF.type, DCON.Environment).hasNext()); assertTrue(this.previousContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).hasNext()); temperatureURI = this.previousContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).next().getObject().asURI(); assertTrue(this.previousContext.findStatements(temperatureURI, RDF.type, DPO.Temperature).hasNext()); assertTrue(this.previousContext.findStatements(temperatureURI, DCON.temperature, new DatatypeLiteralImpl("34.0", XSD._double)).hasNext()); assertEquals(7, this.liveContext.size()); assertTrue(this.liveContext.findStatements(environment, RDF.type, DCON.Environment).hasNext()); aspectURI = this.liveContext.findStatements(environment, RDF.type, DCON.Environment).next().getSubject(); assertTrue(this.liveContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).hasNext()); weatherConditionsURI = this.liveContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).next().getObject().asURI(); assertTrue(this.liveContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).hasNext()); temperatureURI = this.liveContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).next().getObject().asURI(); assertTrue(this.liveContext.findStatements(temperatureURI, RDF.type, DPO.Temperature).hasNext()); assertTrue(this.liveContext.findStatements(temperatureURI, DCON.temperature, new DatatypeLiteralImpl("36.0", XSD._double)).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, RDF.type, DPO.WeatherConditions).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, DCON.cloudcover, new DatatypeLiteralImpl("5", XSD._int)).hasNext()); toAdd.clear(); toRemove.clear(); toAdd.add(new StatementImpl(null, weather, DCON.humidity, new DatatypeLiteralImpl("70", XSD._int))); strategy.update(toAdd, toRemove); assertEquals(7, this.previousContext.size()); assertTrue(this.previousContext.findStatements(environment, RDF.type, DCON.Environment).hasNext()); aspectURI = this.previousContext.findStatements(environment, RDF.type, DCON.Environment).next().getSubject(); assertTrue(this.previousContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).hasNext()); weatherConditionsURI = this.previousContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).next().getObject().asURI(); assertTrue(this.previousContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).hasNext()); temperatureURI = this.previousContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).next().getObject().asURI(); assertTrue(this.previousContext.findStatements(temperatureURI, RDF.type, DPO.Temperature).hasNext()); assertTrue(this.previousContext.findStatements(temperatureURI, DCON.temperature, new DatatypeLiteralImpl("34.0", XSD._double)).hasNext()); assertTrue(this.previousContext.findStatements(weatherConditionsURI, RDF.type, DPO.WeatherConditions).hasNext()); assertTrue(this.previousContext.findStatements(weatherConditionsURI, DCON.cloudcover, new DatatypeLiteralImpl("5", XSD._int)).hasNext()); assertEquals(8, this.liveContext.size()); assertTrue(this.liveContext.findStatements(environment, RDF.type, DCON.Environment).hasNext()); aspectURI = this.liveContext.findStatements(environment, RDF.type, DCON.Environment).next().getSubject(); assertTrue(this.liveContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).hasNext()); weatherConditionsURI = this.liveContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).next().getObject().asURI(); assertTrue(this.liveContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).hasNext()); temperatureURI = this.liveContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).next().getObject().asURI(); assertTrue(this.liveContext.findStatements(temperatureURI, RDF.type, DPO.Temperature).hasNext()); assertTrue(this.liveContext.findStatements(temperatureURI, DCON.temperature, new DatatypeLiteralImpl("36.0", XSD._double)).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, RDF.type, DPO.WeatherConditions).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, DCON.cloudcover, new DatatypeLiteralImpl("5", XSD._int)).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, DCON.humidity, new DatatypeLiteralImpl("70", XSD._int)).hasNext()); toAdd.clear(); toRemove.clear(); toAdd.add(new StatementImpl(null, temp, DCON.temperature, new DatatypeLiteralImpl("20.0", XSD._double))); toRemove.add(new StatementImpl(null, temp, DCON.temperature, new DatatypeLiteralImpl("36.0", XSD._double))); strategy.update(toAdd, toRemove); toAdd.clear(); toRemove.clear(); toAdd.add(new StatementImpl(null, weather, DCON.humidity, new DatatypeLiteralImpl("80", XSD._int))); toRemove.add(new StatementImpl(null, weather, DCON.humidity, new DatatypeLiteralImpl("70", XSD._int))); strategy.update(toAdd, toRemove); assertEquals(8, this.previousContext.size()); assertTrue(this.previousContext.findStatements(environment, RDF.type, DCON.Environment).hasNext()); aspectURI = this.previousContext.findStatements(environment, RDF.type, DCON.Environment).next().getSubject(); assertTrue(this.previousContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).hasNext()); weatherConditionsURI = this.previousContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).next().getObject().asURI(); assertTrue(this.previousContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).hasNext()); temperatureURI = this.previousContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).next().getObject().asURI(); assertTrue(this.previousContext.findStatements(temperatureURI, RDF.type, DPO.Temperature).hasNext()); assertTrue(this.previousContext.findStatements(temperatureURI, DCON.temperature, new DatatypeLiteralImpl("36.0", XSD._double)).hasNext()); assertTrue(this.previousContext.findStatements(weatherConditionsURI, RDF.type, DPO.WeatherConditions).hasNext()); assertTrue(this.previousContext.findStatements(weatherConditionsURI, DCON.cloudcover, new DatatypeLiteralImpl("5", XSD._int)).hasNext()); assertTrue(this.previousContext.findStatements(weatherConditionsURI, DCON.humidity, new DatatypeLiteralImpl("70", XSD._int)).hasNext()); assertEquals(8, this.liveContext.size()); assertTrue(this.liveContext.findStatements(environment, RDF.type, DCON.Environment).hasNext()); aspectURI = this.liveContext.findStatements(environment, RDF.type, DCON.Environment).next().getSubject(); assertTrue(this.liveContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).hasNext()); weatherConditionsURI = this.liveContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).next().getObject().asURI(); assertTrue(this.liveContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).hasNext()); temperatureURI = this.liveContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).next().getObject().asURI(); assertTrue(this.liveContext.findStatements(temperatureURI, RDF.type, DPO.Temperature).hasNext()); assertTrue(this.liveContext.findStatements(temperatureURI, DCON.temperature, new DatatypeLiteralImpl("20.0", XSD._double)).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, RDF.type, DPO.WeatherConditions).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, DCON.cloudcover, new DatatypeLiteralImpl("5", XSD._int)).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, DCON.humidity, new DatatypeLiteralImpl("80", XSD._int)).hasNext()); toAdd.clear(); toRemove.clear(); toAdd.add(new StatementImpl(null, weather, DCON.cloudcover, new DatatypeLiteralImpl("10", XSD._int))); toAdd.add(new StatementImpl(null, weather, DCON.humidity, new DatatypeLiteralImpl("70", XSD._int))); toRemove.add(new StatementImpl(null, weather, DCON.cloudcover, new DatatypeLiteralImpl("5", XSD._int))); toRemove.add(new StatementImpl(null, weather, DCON.humidity, new DatatypeLiteralImpl("80", XSD._int))); strategy.update(toAdd, toRemove); assertEquals(8, this.previousContext.size()); assertTrue(this.previousContext.findStatements(environment, RDF.type, DCON.Environment).hasNext()); aspectURI = this.previousContext.findStatements(environment, RDF.type, DCON.Environment).next().getSubject(); assertTrue(this.previousContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).hasNext()); weatherConditionsURI = this.previousContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).next().getObject().asURI(); assertTrue(this.previousContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).hasNext()); temperatureURI = this.previousContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).next().getObject().asURI(); assertTrue(this.previousContext.findStatements(temperatureURI, RDF.type, DPO.Temperature).hasNext()); assertTrue(this.previousContext.findStatements(temperatureURI, DCON.temperature, new DatatypeLiteralImpl("36.0", XSD._double)).hasNext()); assertTrue(this.previousContext.findStatements(weatherConditionsURI, RDF.type, DPO.WeatherConditions).hasNext()); assertTrue(this.previousContext.findStatements(weatherConditionsURI, DCON.cloudcover, new DatatypeLiteralImpl("5", XSD._int)).hasNext()); assertTrue(this.previousContext.findStatements(weatherConditionsURI, DCON.humidity, new DatatypeLiteralImpl("80", XSD._int)).hasNext()); assertEquals(8, this.liveContext.size()); assertTrue(this.liveContext.findStatements(environment, RDF.type, DCON.Environment).hasNext()); aspectURI = this.liveContext.findStatements(environment, RDF.type, DCON.Environment).next().getSubject(); assertTrue(this.liveContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).hasNext()); weatherConditionsURI = this.liveContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).next().getObject().asURI(); assertTrue(this.liveContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).hasNext()); temperatureURI = this.liveContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).next().getObject().asURI(); assertTrue(this.liveContext.findStatements(temperatureURI, RDF.type, DPO.Temperature).hasNext()); assertTrue(this.liveContext.findStatements(temperatureURI, DCON.temperature, new DatatypeLiteralImpl("20.0", XSD._double)).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, RDF.type, DPO.WeatherConditions).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, DCON.cloudcover, new DatatypeLiteralImpl("10", XSD._int)).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, DCON.humidity, new DatatypeLiteralImpl("70", XSD._int)).hasNext()); }
|
@Override public void update(List<Statement> toAdd, List<Statement> toRemove) { ClosableIterator<Statement> lcStmts = liveContext.iterator(); List<URI> aspects = new ArrayList<URI>(); List<Statement> toKeep = new ArrayList<Statement>(); while (lcStmts.hasNext()) { Statement statement = lcStmts.next(); Node object = statement.getObject(); if (object instanceof URI && ArrayUtils.contains(ASPECTS, object.asURI())) { aspects.add(statement.getSubject().asURI()); toKeep.add(statement); } } lcStmts.close(); lcStmts = liveContext.iterator(); while (lcStmts.hasNext()) { Statement statement = lcStmts.next(); Resource subject = statement.getSubject(); if (subject instanceof URI && aspects.contains(subject.asURI())) { toKeep.add(statement); } } lcStmts.close(); for (Statement stmt : toRemove) { URI resource = stmt.getSubject().asURI(); if (!aspects.contains(resource)) { previousContext.removeStatements(resource.asResource(), Variable.ANY, Variable.ANY); } } List<Statement> all = new ArrayList<Statement>(); all.addAll(toAdd); all.addAll(toRemove); for (Statement stmt : all) { URI resource = stmt.getSubject().asURI(); if (!aspects.contains(resource)) { previousContext.addAll(liveContext.findStatements(resource, Variable.ANY, Variable.ANY)); } } previousContext.addAll(toKeep.iterator()); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); }
|
AspectBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { ClosableIterator<Statement> lcStmts = liveContext.iterator(); List<URI> aspects = new ArrayList<URI>(); List<Statement> toKeep = new ArrayList<Statement>(); while (lcStmts.hasNext()) { Statement statement = lcStmts.next(); Node object = statement.getObject(); if (object instanceof URI && ArrayUtils.contains(ASPECTS, object.asURI())) { aspects.add(statement.getSubject().asURI()); toKeep.add(statement); } } lcStmts.close(); lcStmts = liveContext.iterator(); while (lcStmts.hasNext()) { Statement statement = lcStmts.next(); Resource subject = statement.getSubject(); if (subject instanceof URI && aspects.contains(subject.asURI())) { toKeep.add(statement); } } lcStmts.close(); for (Statement stmt : toRemove) { URI resource = stmt.getSubject().asURI(); if (!aspects.contains(resource)) { previousContext.removeStatements(resource.asResource(), Variable.ANY, Variable.ANY); } } List<Statement> all = new ArrayList<Statement>(); all.addAll(toAdd); all.addAll(toRemove); for (Statement stmt : all) { URI resource = stmt.getSubject().asURI(); if (!aspects.contains(resource)) { previousContext.addAll(liveContext.findStatements(resource, Variable.ANY, Variable.ANY)); } } previousContext.addAll(toKeep.iterator()); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } }
|
AspectBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { ClosableIterator<Statement> lcStmts = liveContext.iterator(); List<URI> aspects = new ArrayList<URI>(); List<Statement> toKeep = new ArrayList<Statement>(); while (lcStmts.hasNext()) { Statement statement = lcStmts.next(); Node object = statement.getObject(); if (object instanceof URI && ArrayUtils.contains(ASPECTS, object.asURI())) { aspects.add(statement.getSubject().asURI()); toKeep.add(statement); } } lcStmts.close(); lcStmts = liveContext.iterator(); while (lcStmts.hasNext()) { Statement statement = lcStmts.next(); Resource subject = statement.getSubject(); if (subject instanceof URI && aspects.contains(subject.asURI())) { toKeep.add(statement); } } lcStmts.close(); for (Statement stmt : toRemove) { URI resource = stmt.getSubject().asURI(); if (!aspects.contains(resource)) { previousContext.removeStatements(resource.asResource(), Variable.ANY, Variable.ANY); } } List<Statement> all = new ArrayList<Statement>(); all.addAll(toAdd); all.addAll(toRemove); for (Statement stmt : all) { URI resource = stmt.getSubject().asURI(); if (!aspects.contains(resource)) { previousContext.addAll(liveContext.findStatements(resource, Variable.ANY, Variable.ANY)); } } previousContext.addAll(toKeep.iterator()); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } AspectBasedStrategy(Model previousContext, Model liveContext); }
|
AspectBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { ClosableIterator<Statement> lcStmts = liveContext.iterator(); List<URI> aspects = new ArrayList<URI>(); List<Statement> toKeep = new ArrayList<Statement>(); while (lcStmts.hasNext()) { Statement statement = lcStmts.next(); Node object = statement.getObject(); if (object instanceof URI && ArrayUtils.contains(ASPECTS, object.asURI())) { aspects.add(statement.getSubject().asURI()); toKeep.add(statement); } } lcStmts.close(); lcStmts = liveContext.iterator(); while (lcStmts.hasNext()) { Statement statement = lcStmts.next(); Resource subject = statement.getSubject(); if (subject instanceof URI && aspects.contains(subject.asURI())) { toKeep.add(statement); } } lcStmts.close(); for (Statement stmt : toRemove) { URI resource = stmt.getSubject().asURI(); if (!aspects.contains(resource)) { previousContext.removeStatements(resource.asResource(), Variable.ANY, Variable.ANY); } } List<Statement> all = new ArrayList<Statement>(); all.addAll(toAdd); all.addAll(toRemove); for (Statement stmt : all) { URI resource = stmt.getSubject().asURI(); if (!aspects.contains(resource)) { previousContext.addAll(liveContext.findStatements(resource, Variable.ANY, Variable.ANY)); } } previousContext.addAll(toKeep.iterator()); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } AspectBasedStrategy(Model previousContext, Model liveContext); @Override void update(List<Statement> toAdd, List<Statement> toRemove); }
|
AspectBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { ClosableIterator<Statement> lcStmts = liveContext.iterator(); List<URI> aspects = new ArrayList<URI>(); List<Statement> toKeep = new ArrayList<Statement>(); while (lcStmts.hasNext()) { Statement statement = lcStmts.next(); Node object = statement.getObject(); if (object instanceof URI && ArrayUtils.contains(ASPECTS, object.asURI())) { aspects.add(statement.getSubject().asURI()); toKeep.add(statement); } } lcStmts.close(); lcStmts = liveContext.iterator(); while (lcStmts.hasNext()) { Statement statement = lcStmts.next(); Resource subject = statement.getSubject(); if (subject instanceof URI && aspects.contains(subject.asURI())) { toKeep.add(statement); } } lcStmts.close(); for (Statement stmt : toRemove) { URI resource = stmt.getSubject().asURI(); if (!aspects.contains(resource)) { previousContext.removeStatements(resource.asResource(), Variable.ANY, Variable.ANY); } } List<Statement> all = new ArrayList<Statement>(); all.addAll(toAdd); all.addAll(toRemove); for (Statement stmt : all) { URI resource = stmt.getSubject().asURI(); if (!aspects.contains(resource)) { previousContext.addAll(liveContext.findStatements(resource, Variable.ANY, Variable.ANY)); } } previousContext.addAll(toKeep.iterator()); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } AspectBasedStrategy(Model previousContext, Model liveContext); @Override void update(List<Statement> toAdd, List<Statement> toRemove); }
|
@Test public void testAddElementToLiveContext() throws Exception { List<Statement> toAdd = new ArrayList<Statement>(); List<Statement> toRemove = new ArrayList<Statement>(); URI ismael = new URIImpl("urn:ismael"); toAdd.add(new StatementImpl(null, PEERS, DCON.nearbyPerson, ismael)); strategy.update(toAdd, toRemove); toAdd.clear(); toRemove.clear(); assertTrue(liveContext.contains(PEERS, DCON.nearbyPerson, ismael)); assertFalse(previousContext.contains(PEERS, DCON.nearbyPerson, Variable.ANY)); }
|
@Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); @Override void update(List<Statement> toAdd, List<Statement> toRemove); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); @Override void update(List<Statement> toAdd, List<Statement> toRemove); }
|
@Test public void testAddSecondElementToLiveContext() throws Exception { List<Statement> toAdd = new ArrayList<Statement>(); List<Statement> toRemove = new ArrayList<Statement>(); URI ismael = new URIImpl("urn:ismael"); toAdd.add(new StatementImpl(null, PEERS, DCON.nearbyPerson, ismael)); strategy.update(toAdd, toRemove); toAdd.clear(); toRemove.clear(); URI simon = new URIImpl("urn:simon"); toAdd.add(new StatementImpl(null, PEERS, DCON.nearbyPerson, simon)); strategy.update(toAdd, toRemove); toAdd.clear(); toRemove.clear(); assertTrue(liveContext.contains(PEERS, DCON.nearbyPerson, ismael)); assertTrue(liveContext.contains(PEERS, DCON.nearbyPerson, simon)); assertTrue(previousContext.contains(PEERS, DCON.nearbyPerson, ismael)); assertFalse(previousContext.contains(PEERS, DCON.nearbyPerson, simon)); }
|
@Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); @Override void update(List<Statement> toAdd, List<Statement> toRemove); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); @Override void update(List<Statement> toAdd, List<Statement> toRemove); }
|
@Test public void testAddRemoveElementFromLiveContext() throws Exception { List<Statement> toAdd = new ArrayList<Statement>(); List<Statement> toRemove = new ArrayList<Statement>(); URI ismael = new URIImpl("urn:ismael"); toAdd.add(new StatementImpl(null, PEERS, DCON.nearbyPerson, ismael)); strategy.update(toAdd, toRemove); toAdd.clear(); toRemove.clear(); toRemove.add(new StatementImpl(null, PEERS, DCON.nearbyPerson, ismael)); strategy.update(toAdd, toRemove); toAdd.clear(); toRemove.clear(); assertTrue(previousContext.contains(PEERS, DCON.nearbyPerson, ismael)); assertFalse(liveContext.contains(PEERS, DCON.nearbyPerson, Variable.ANY)); }
|
@Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); @Override void update(List<Statement> toAdd, List<Statement> toRemove); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); @Override void update(List<Statement> toAdd, List<Statement> toRemove); }
|
@Test public void testGetCredentials() { try { Response<AccountEntry> response = authenticationController.getCredentials(SAID_LOCAL, SAID_REMOTE); Collection<AccountEntry> col = response.getMessage().getData().getEntries(); AccountEntry account = col.iterator().next(); String tmpPassword = account.getPassword(); response = authenticationController.getCredentials(SAID_LOCAL, SAID_REMOTE); col = response.getMessage().getData().getEntries(); account = col.iterator().next(); Assert.assertFalse(!account.getPassword().equals(tmpPassword)); } catch (DimeException ex) { Logger.getLogger(AuthenticationControllerTest.class.getName()).log(Level.SEVERE, null, ex); } }
|
@GET @Produces(MediaType.APPLICATION_JSON) @Path("/credentials/{contact-said}") public Response<AccountEntry> getCredentials( @PathParam("said") String saidLocal, @PathParam("contact-said") String saidRequester) throws DimeException { Data<AccountEntry> data = new Data<AccountEntry>(); boolean unlocked; try { unlocked = lock.tryLock(50L, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { throw new DimeException("Password retrieval failed", e); } if (!unlocked) { logger.error("Could not aquire lock within 5 seconds. Returning."); throw new DimeException("Could not request credentials because the system is busy."); } try { User user = userManager.getUserForAccountAndTenant(saidRequester, saidLocal); if (user == null) { return Response.badRequest("Useraccount was null", null); } if (user.getPassword() == null || user.getPassword().equals("")) { user = userManager.generatePassword((user.getId())); } if (user != null) { AccountEntry jsonEntry = new AccountEntry(); jsonEntry.setUsername(user.getUsername()); jsonEntry.setPassword(user.getPassword()); jsonEntry.setRole(user.getRole().ordinal()); jsonEntry.setEnabled(user.isEnabled()); jsonEntry.setType("auth"); data.addEntry(jsonEntry); } else { return Response.badRequest("Useraccount was already activated!", null); } return Response.ok(data); } catch (Exception e) { return Response.serverError(); } finally { lock.unlock(); } }
|
AuthenticationController { @GET @Produces(MediaType.APPLICATION_JSON) @Path("/credentials/{contact-said}") public Response<AccountEntry> getCredentials( @PathParam("said") String saidLocal, @PathParam("contact-said") String saidRequester) throws DimeException { Data<AccountEntry> data = new Data<AccountEntry>(); boolean unlocked; try { unlocked = lock.tryLock(50L, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { throw new DimeException("Password retrieval failed", e); } if (!unlocked) { logger.error("Could not aquire lock within 5 seconds. Returning."); throw new DimeException("Could not request credentials because the system is busy."); } try { User user = userManager.getUserForAccountAndTenant(saidRequester, saidLocal); if (user == null) { return Response.badRequest("Useraccount was null", null); } if (user.getPassword() == null || user.getPassword().equals("")) { user = userManager.generatePassword((user.getId())); } if (user != null) { AccountEntry jsonEntry = new AccountEntry(); jsonEntry.setUsername(user.getUsername()); jsonEntry.setPassword(user.getPassword()); jsonEntry.setRole(user.getRole().ordinal()); jsonEntry.setEnabled(user.isEnabled()); jsonEntry.setType("auth"); data.addEntry(jsonEntry); } else { return Response.badRequest("Useraccount was already activated!", null); } return Response.ok(data); } catch (Exception e) { return Response.serverError(); } finally { lock.unlock(); } } }
|
AuthenticationController { @GET @Produces(MediaType.APPLICATION_JSON) @Path("/credentials/{contact-said}") public Response<AccountEntry> getCredentials( @PathParam("said") String saidLocal, @PathParam("contact-said") String saidRequester) throws DimeException { Data<AccountEntry> data = new Data<AccountEntry>(); boolean unlocked; try { unlocked = lock.tryLock(50L, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { throw new DimeException("Password retrieval failed", e); } if (!unlocked) { logger.error("Could not aquire lock within 5 seconds. Returning."); throw new DimeException("Could not request credentials because the system is busy."); } try { User user = userManager.getUserForAccountAndTenant(saidRequester, saidLocal); if (user == null) { return Response.badRequest("Useraccount was null", null); } if (user.getPassword() == null || user.getPassword().equals("")) { user = userManager.generatePassword((user.getId())); } if (user != null) { AccountEntry jsonEntry = new AccountEntry(); jsonEntry.setUsername(user.getUsername()); jsonEntry.setPassword(user.getPassword()); jsonEntry.setRole(user.getRole().ordinal()); jsonEntry.setEnabled(user.isEnabled()); jsonEntry.setType("auth"); data.addEntry(jsonEntry); } else { return Response.badRequest("Useraccount was already activated!", null); } return Response.ok(data); } catch (Exception e) { return Response.serverError(); } finally { lock.unlock(); } } }
|
AuthenticationController { @GET @Produces(MediaType.APPLICATION_JSON) @Path("/credentials/{contact-said}") public Response<AccountEntry> getCredentials( @PathParam("said") String saidLocal, @PathParam("contact-said") String saidRequester) throws DimeException { Data<AccountEntry> data = new Data<AccountEntry>(); boolean unlocked; try { unlocked = lock.tryLock(50L, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { throw new DimeException("Password retrieval failed", e); } if (!unlocked) { logger.error("Could not aquire lock within 5 seconds. Returning."); throw new DimeException("Could not request credentials because the system is busy."); } try { User user = userManager.getUserForAccountAndTenant(saidRequester, saidLocal); if (user == null) { return Response.badRequest("Useraccount was null", null); } if (user.getPassword() == null || user.getPassword().equals("")) { user = userManager.generatePassword((user.getId())); } if (user != null) { AccountEntry jsonEntry = new AccountEntry(); jsonEntry.setUsername(user.getUsername()); jsonEntry.setPassword(user.getPassword()); jsonEntry.setRole(user.getRole().ordinal()); jsonEntry.setEnabled(user.isEnabled()); jsonEntry.setType("auth"); data.addEntry(jsonEntry); } else { return Response.badRequest("Useraccount was already activated!", null); } return Response.ok(data); } catch (Exception e) { return Response.serverError(); } finally { lock.unlock(); } } void setUserManager(UserManager userManager); void setAccessControlManager(AccessControlManager accessControlManager); @GET @Path("{userName}") @Produces(MediaType.APPLICATION_JSON + ";charset=UTF-8") Response<AccountEntry> getUser(
@PathParam("userName") String userName); @POST @Path("{userName}")// can be @me - then updating the current user @Consumes(MediaType.APPLICATION_JSON + ";charset=UTF-8") @Produces(MediaType.APPLICATION_JSON + ";charset=UTF-8") Response<AccountEntry> updateUser(
@PathParam("said") String said,
@PathParam("userName") String userName,
Request<AccountEntry> request); @DELETE @Path("{userName}") @Consumes(MediaType.APPLICATION_JSON + ";charset=UTF-8") @Produces(MediaType.APPLICATION_JSON + ";charset=UTF-8") Response<AccountEntry> deleteAccount(Request<AccountEntry> request,
@PathParam("userName") String userName); @GET @Path("/username") String getCurrentUserName(); @GET @Path("/role") String getCurrentRole(); @GET @Produces(MediaType.APPLICATION_JSON) @Path("/credentials/{contact-said}") Response<AccountEntry> getCredentials(
@PathParam("said") String saidLocal,
@PathParam("contact-said") String saidRequester); @POST @Produces(MediaType.APPLICATION_JSON) @Path("/credentials/{contact-said}") Response<?> confirmCredentials(
@PathParam("said") String saidLocal,
@PathParam("contact-said") String saidRequester); }
|
AuthenticationController { @GET @Produces(MediaType.APPLICATION_JSON) @Path("/credentials/{contact-said}") public Response<AccountEntry> getCredentials( @PathParam("said") String saidLocal, @PathParam("contact-said") String saidRequester) throws DimeException { Data<AccountEntry> data = new Data<AccountEntry>(); boolean unlocked; try { unlocked = lock.tryLock(50L, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { throw new DimeException("Password retrieval failed", e); } if (!unlocked) { logger.error("Could not aquire lock within 5 seconds. Returning."); throw new DimeException("Could not request credentials because the system is busy."); } try { User user = userManager.getUserForAccountAndTenant(saidRequester, saidLocal); if (user == null) { return Response.badRequest("Useraccount was null", null); } if (user.getPassword() == null || user.getPassword().equals("")) { user = userManager.generatePassword((user.getId())); } if (user != null) { AccountEntry jsonEntry = new AccountEntry(); jsonEntry.setUsername(user.getUsername()); jsonEntry.setPassword(user.getPassword()); jsonEntry.setRole(user.getRole().ordinal()); jsonEntry.setEnabled(user.isEnabled()); jsonEntry.setType("auth"); data.addEntry(jsonEntry); } else { return Response.badRequest("Useraccount was already activated!", null); } return Response.ok(data); } catch (Exception e) { return Response.serverError(); } finally { lock.unlock(); } } void setUserManager(UserManager userManager); void setAccessControlManager(AccessControlManager accessControlManager); @GET @Path("{userName}") @Produces(MediaType.APPLICATION_JSON + ";charset=UTF-8") Response<AccountEntry> getUser(
@PathParam("userName") String userName); @POST @Path("{userName}")// can be @me - then updating the current user @Consumes(MediaType.APPLICATION_JSON + ";charset=UTF-8") @Produces(MediaType.APPLICATION_JSON + ";charset=UTF-8") Response<AccountEntry> updateUser(
@PathParam("said") String said,
@PathParam("userName") String userName,
Request<AccountEntry> request); @DELETE @Path("{userName}") @Consumes(MediaType.APPLICATION_JSON + ";charset=UTF-8") @Produces(MediaType.APPLICATION_JSON + ";charset=UTF-8") Response<AccountEntry> deleteAccount(Request<AccountEntry> request,
@PathParam("userName") String userName); @GET @Path("/username") String getCurrentUserName(); @GET @Path("/role") String getCurrentRole(); @GET @Produces(MediaType.APPLICATION_JSON) @Path("/credentials/{contact-said}") Response<AccountEntry> getCredentials(
@PathParam("said") String saidLocal,
@PathParam("contact-said") String saidRequester); @POST @Produces(MediaType.APPLICATION_JSON) @Path("/credentials/{contact-said}") Response<?> confirmCredentials(
@PathParam("said") String saidLocal,
@PathParam("contact-said") String saidRequester); }
|
@Test public void testAddUpdateRemoveElementFromLiveContext() throws Exception { List<Statement> toAdd = new ArrayList<Statement>(); List<Statement> toRemove = new ArrayList<Statement>(); URI temperature = new URIImpl("urn:uuid:" + UUID.randomUUID()); toAdd.add(new StatementImpl(null, ENVIRONMENT, DCON.currentTemperature, temperature)); toAdd.add(new StatementImpl(null, temperature, DCON.temperature, new PlainLiteralImpl("34"))); strategy.update(toAdd, toRemove); toAdd.clear(); toRemove.clear(); assertTrue(liveContext.contains(temperature, DCON.temperature, new PlainLiteralImpl("34"))); assertFalse(previousContext.contains(ENVIRONMENT, DCON.currentTemperature, temperature)); assertFalse(previousContext.contains(temperature, Variable.ANY, Variable.ANY)); toRemove.add(new StatementImpl(null, temperature, DCON.temperature, new PlainLiteralImpl("34"))); toAdd.add(new StatementImpl(null, temperature, DCON.temperature, new PlainLiteralImpl("39"))); strategy.update(toAdd, toRemove); toAdd.clear(); toRemove.clear(); assertTrue(liveContext.contains(temperature, DCON.temperature, new PlainLiteralImpl("39"))); assertTrue(previousContext.contains(temperature, DCON.temperature, new PlainLiteralImpl("34"))); }
|
@Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); @Override void update(List<Statement> toAdd, List<Statement> toRemove); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); @Override void update(List<Statement> toAdd, List<Statement> toRemove); }
|
@Test public void testCombinedAddition() throws LiveContextException { List<Statement> toAdd = new ArrayList<Statement>(); List<Statement> toRemove = new ArrayList<Statement>(); URI temperature = new URIImpl("urn:uuid:" + UUID.randomUUID()); toAdd.add(new StatementImpl(null, ENVIRONMENT, DCON.currentTemperature, temperature)); toAdd.add(new StatementImpl(null, temperature, DCON.temperature, new PlainLiteralImpl("34"))); URI weather = new URIImpl("urn:uuid:" + UUID.randomUUID()); toAdd.add(new StatementImpl(null, ENVIRONMENT, DCON.currentWeather, weather)); toAdd.add(new StatementImpl(null, weather, DCON.cloudcover, new PlainLiteralImpl("5"))); strategy.update(toAdd, toRemove); toAdd.clear(); toRemove.clear(); assertTrue(liveContext.contains(ENVIRONMENT, DCON.currentWeather, weather)); assertTrue(liveContext.contains(temperature, DCON.temperature, new PlainLiteralImpl("34"))); assertTrue(liveContext.contains(ENVIRONMENT, DCON.currentWeather, weather)); assertTrue(liveContext.contains(weather, DCON.cloudcover, new PlainLiteralImpl("5"))); assertFalse(previousContext.contains(ENVIRONMENT, DCON.currentWeather, Variable.ANY)); assertFalse(previousContext.contains(temperature, DCON.temperature, Variable.ANY)); assertFalse(previousContext.contains(weather, DCON.cloudcover, Variable.ANY)); }
|
@Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); @Override void update(List<Statement> toAdd, List<Statement> toRemove); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); @Override void update(List<Statement> toAdd, List<Statement> toRemove); }
|
@Test public void testCombinedAdditionAndUpdate() throws LiveContextException { List<Statement> toAdd = new ArrayList<Statement>(); List<Statement> toRemove = new ArrayList<Statement>(); URI temperature = new URIImpl("urn:uuid:" + UUID.randomUUID()); toAdd.add(new StatementImpl(null, ENVIRONMENT, DCON.currentTemperature, temperature)); toAdd.add(new StatementImpl(null, temperature, DCON.temperature, new PlainLiteralImpl("34"))); URI weather = new URIImpl("urn:uuid:" + UUID.randomUUID()); toAdd.add(new StatementImpl(null, ENVIRONMENT, DCON.currentWeather, weather)); toAdd.add(new StatementImpl(null, weather, DCON.cloudcover, new PlainLiteralImpl("5"))); strategy.update(toAdd, toRemove); toAdd.clear(); toRemove.clear(); toRemove.add(new StatementImpl(null, temperature, DCON.temperature, new PlainLiteralImpl("34"))); toAdd.add(new StatementImpl(null, temperature, DCON.temperature, new PlainLiteralImpl("36"))); strategy.update(toAdd, toRemove); toAdd.clear(); toRemove.clear(); assertTrue(liveContext.contains(temperature, DCON.temperature, new PlainLiteralImpl("36"))); assertTrue(previousContext.contains(temperature, DCON.temperature, new PlainLiteralImpl("34"))); assertFalse(previousContext.contains(ENVIRONMENT, DCON.currentWeather, weather)); assertFalse(previousContext.contains(weather, DCON.cloudcover, Variable.ANY)); }
|
@Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); @Override void update(List<Statement> toAdd, List<Statement> toRemove); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); @Override void update(List<Statement> toAdd, List<Statement> toRemove); }
|
@Test public void testSeveralAddAndUpdate() throws LiveContextException { List<Statement> toAdd = new ArrayList<Statement>(); List<Statement> toRemove = new ArrayList<Statement>(); URI temperature = new URIImpl("urn:uuid:" + UUID.randomUUID()); toAdd.add(new StatementImpl(null, ENVIRONMENT, DCON.currentTemperature, temperature)); toAdd.add(new StatementImpl(null, temperature, DCON.temperature, new PlainLiteralImpl("34"))); strategy.update(toAdd, toRemove); toAdd.clear(); toRemove.clear(); URI weather = new URIImpl("urn:uuid:" + UUID.randomUUID()); toAdd.add(new StatementImpl(null, ENVIRONMENT, DCON.currentWeather, weather)); toAdd.add(new StatementImpl(null, weather, DCON.cloudcover, new PlainLiteralImpl("5"))); strategy.update(toAdd, toRemove); toAdd.clear(); toRemove.clear(); assertTrue(liveContext.contains(ENVIRONMENT, DCON.currentTemperature, temperature)); assertTrue(liveContext.contains(temperature, DCON.temperature, new PlainLiteralImpl("34"))); assertTrue(liveContext.contains(ENVIRONMENT, DCON.currentWeather, weather)); assertTrue(liveContext.contains(weather, DCON.cloudcover, new PlainLiteralImpl("5"))); assertTrue(previousContext.contains(ENVIRONMENT, DCON.currentTemperature, temperature)); assertTrue(previousContext.contains(temperature, DCON.temperature, new PlainLiteralImpl("34"))); assertFalse(previousContext.contains(ENVIRONMENT, DCON.currentWeather, weather)); assertFalse(previousContext.contains(weather, DCON.cloudcover, Variable.ANY)); toRemove.add(new StatementImpl(null, temperature, DCON.temperature, new PlainLiteralImpl("34"))); toAdd.add(new StatementImpl(null, temperature, DCON.temperature, new PlainLiteralImpl("36"))); strategy.update(toAdd, toRemove); toAdd.clear(); toRemove.clear(); assertTrue(liveContext.contains(temperature, DCON.temperature, new PlainLiteralImpl("36"))); assertTrue(liveContext.contains(weather, DCON.cloudcover, new PlainLiteralImpl("5"))); assertTrue(previousContext.contains(temperature, DCON.temperature, new PlainLiteralImpl("34"))); assertFalse(previousContext.contains(ENVIRONMENT, DCON.currentWeather, weather)); assertFalse(previousContext.contains(weather, DCON.cloudcover, new PlainLiteralImpl("5"))); URI altitude = new URIImpl("urn:uuid:" + UUID.randomUUID()); toAdd.add(new StatementImpl(null, ENVIRONMENT, DCON.currentAbsoluteAltitude, altitude)); toAdd.add(new StatementImpl(null, altitude, DCON.altitude, new PlainLiteralImpl("628"))); strategy.update(toAdd, toRemove); toAdd.clear(); toRemove.clear(); assertTrue(liveContext.contains(ENVIRONMENT, DCON.currentAbsoluteAltitude, altitude)); assertTrue(liveContext.contains(altitude, DCON.altitude, new PlainLiteralImpl("628"))); assertTrue(previousContext.contains(temperature, DCON.temperature, new PlainLiteralImpl("34"))); assertTrue(previousContext.contains(weather, DCON.cloudcover, new PlainLiteralImpl("5"))); }
|
@Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); @Override void update(List<Statement> toAdd, List<Statement> toRemove); }
|
ElementBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { Model newData = RDF2Go.getModelFactory().createModel().open(); for (Statement s : toAdd) { newData.addStatement(s); } Set<URI> elements = new HashSet<URI>(); elements.addAll(findElements(toAdd)); elements.addAll(findElements(toRemove)); logger.debug("Updating live context... elements to be updated: "+StringUtils.join(elements, ", ")); for (URI element : elements) { if (liveContext.contains(Variable.ANY, Variable.ANY, element)) { previousContext.removeStatements(Variable.ANY, Variable.ANY, element); previousContext.removeStatements(element, Variable.ANY, Variable.ANY); previousContext.addAll(liveContext.findStatements(Variable.ANY, Variable.ANY, element)); previousContext.addAll(liveContext.findStatements(element, Variable.ANY, Variable.ANY)); } else { URI aspect = newData.findStatements(Variable.ANY, Variable.ANY, element).next().getSubject().asURI(); String query = "SELECT DISTINCT ?element WHERE { "+aspect.toSPARQL()+" ?p ?element . }"; Set<URI> existing = new HashSet<URI>(); ClosableIterator<QueryRow> results = liveContext.sparqlSelect(query).iterator(); while (results.hasNext()) { existing.add(results.next().getValue("element").asURI()); } results.close(); for (URI e : existing) { if (!previousContext.contains(aspect, Variable.ANY, e)) { previousContext.addAll(liveContext.findStatements(aspect, Variable.ANY, e)); previousContext.addAll(liveContext.findStatements(e, Variable.ANY, Variable.ANY)); } } } } newData.close(); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } ElementBasedStrategy(Model previousContext, Model liveContext); @Override void update(List<Statement> toAdd, List<Statement> toRemove); }
|
@Test public void testUpdateSeveralResources() throws LiveContextException { List<Statement> toAdd = new ArrayList<Statement>(); List<Statement> toRemove = new ArrayList<Statement>(); URI environment = new URIImpl("urn:uuid:"+UUID.randomUUID()); URI temp = new URIImpl("urn:uuid:"+UUID.randomUUID()); URI weather = new URIImpl("urn:uuid:"+UUID.randomUUID()); toAdd.add(new StatementImpl(null, environment, RDF.type, DCON.Environment)); toAdd.add(new StatementImpl(null, environment, DCON.currentTemperature, temp)); toAdd.add(new StatementImpl(null, environment, DCON.currentWeather, weather)); toAdd.add(new StatementImpl(null, temp, RDF.type, DPO.Temperature)); toAdd.add(new StatementImpl(null, temp, DCON.temperature, new DatatypeLiteralImpl("34.0", XSD._double))); toAdd.add(new StatementImpl(null, weather, RDF.type, DPO.WeatherConditions)); toAdd.add(new StatementImpl(null, weather, DCON.cloudcover, new DatatypeLiteralImpl("5", XSD._int))); strategy.update(toAdd, toRemove); Resource aspectURI = null; URI weatherConditionsURI = null; URI temperatureURI = null; assertEquals(0, this.previousContext.size()); assertEquals(7, this.liveContext.size()); assertTrue(this.liveContext.findStatements(environment, RDF.type, DCON.Environment).hasNext()); aspectURI = this.liveContext.findStatements(environment, RDF.type, DCON.Environment).next().getSubject(); assertTrue(this.liveContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).hasNext()); weatherConditionsURI = (URI) this.liveContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).next().getObject(); assertTrue(this.liveContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).hasNext()); temperatureURI = (URI) this.liveContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).next().getObject(); assertTrue(this.liveContext.findStatements(temperatureURI, RDF.type, DPO.Temperature).hasNext()); assertTrue(this.liveContext.findStatements(temperatureURI, DCON.temperature, new DatatypeLiteralImpl("34.0", XSD._double)).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, RDF.type, DPO.WeatherConditions).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, DCON.cloudcover, new DatatypeLiteralImpl("5", XSD._int)).hasNext()); toAdd.clear(); toRemove.clear(); toAdd.add(new StatementImpl(null, temp, DCON.temperature, new DatatypeLiteralImpl("36.0", XSD._double))); toRemove.add(new StatementImpl(null, temp, DCON.temperature, new DatatypeLiteralImpl("34.0", XSD._double))); strategy.update(toAdd, toRemove); assertEquals(7, this.previousContext.size()); assertTrue(this.previousContext.findStatements(environment, RDF.type, DCON.Environment).hasNext()); aspectURI = this.previousContext.findStatements(environment, RDF.type, DCON.Environment).next().getSubject(); assertTrue(this.previousContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).hasNext()); weatherConditionsURI = (URI) this.previousContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).next().getObject(); assertTrue(this.previousContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).hasNext()); temperatureURI = (URI) this.previousContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).next().getObject(); assertTrue(this.previousContext.findStatements(temperatureURI, RDF.type, DPO.Temperature).hasNext()); assertTrue(this.previousContext.findStatements(temperatureURI, DCON.temperature, new DatatypeLiteralImpl("34.0", XSD._double)).hasNext()); assertTrue(this.previousContext.findStatements(weatherConditionsURI, RDF.type, DPO.WeatherConditions).hasNext()); assertTrue(this.previousContext.findStatements(weatherConditionsURI, DCON.cloudcover, new DatatypeLiteralImpl("5", XSD._int)).hasNext()); assertEquals(7, this.liveContext.size()); assertTrue(this.liveContext.findStatements(environment, RDF.type, DCON.Environment).hasNext()); aspectURI = this.liveContext.findStatements(environment, RDF.type, DCON.Environment).next().getSubject(); assertTrue(this.liveContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).hasNext()); weatherConditionsURI = (URI) this.liveContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).next().getObject(); assertTrue(this.liveContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).hasNext()); temperatureURI = (URI) this.liveContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).next().getObject(); assertTrue(this.liveContext.findStatements(temperatureURI, RDF.type, DPO.Temperature).hasNext()); assertTrue(this.liveContext.findStatements(temperatureURI, DCON.temperature, new DatatypeLiteralImpl("36.0", XSD._double)).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, RDF.type, DPO.WeatherConditions).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, DCON.cloudcover, new DatatypeLiteralImpl("5", XSD._int)).hasNext()); toAdd.clear(); toRemove.clear(); toAdd.add(new StatementImpl(null, weather, DCON.cloudcover, new DatatypeLiteralImpl("10", XSD._int))); toAdd.add(new StatementImpl(null, weather, DCON.humidity, new DatatypeLiteralImpl("70", XSD._int))); toRemove.add(new StatementImpl(null, weather, DCON.cloudcover, new DatatypeLiteralImpl("5", XSD._int))); strategy.update(toAdd, toRemove); assertEquals(7, this.previousContext.size()); assertTrue(this.previousContext.findStatements(environment, RDF.type, DCON.Environment).hasNext()); aspectURI = this.previousContext.findStatements(environment, RDF.type, DCON.Environment).next().getSubject(); assertTrue(this.previousContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).hasNext()); weatherConditionsURI = (URI) this.previousContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).next().getObject(); assertTrue(this.previousContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).hasNext()); temperatureURI = (URI) this.previousContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).next().getObject(); assertTrue(this.previousContext.findStatements(temperatureURI, RDF.type, DPO.Temperature).hasNext()); assertTrue(this.previousContext.findStatements(temperatureURI, DCON.temperature, new DatatypeLiteralImpl("36.0", XSD._double)).hasNext()); assertTrue(this.previousContext.findStatements(weatherConditionsURI, RDF.type, DPO.WeatherConditions).hasNext()); assertTrue(this.previousContext.findStatements(weatherConditionsURI, DCON.cloudcover, new DatatypeLiteralImpl("5", XSD._int)).hasNext()); assertEquals(8, this.liveContext.size()); assertTrue(this.liveContext.findStatements(environment, RDF.type, DCON.Environment).hasNext()); aspectURI = this.liveContext.findStatements(environment, RDF.type, DCON.Environment).next().getSubject(); assertTrue(this.liveContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).hasNext()); weatherConditionsURI = (URI) this.liveContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).next().getObject(); assertTrue(this.liveContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).hasNext()); temperatureURI = (URI) this.liveContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).next().getObject(); assertTrue(this.liveContext.findStatements(temperatureURI, RDF.type, DPO.Temperature).hasNext()); assertTrue(this.liveContext.findStatements(temperatureURI, DCON.temperature, new DatatypeLiteralImpl("36.0", XSD._double)).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, RDF.type, DPO.WeatherConditions).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, DCON.cloudcover, new DatatypeLiteralImpl("10", XSD._int)).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, DCON.humidity, new DatatypeLiteralImpl("70", XSD._int)).hasNext()); toAdd.clear(); toRemove.clear(); toAdd.add(new StatementImpl(null, weather, DCON.cloudcover, new DatatypeLiteralImpl("5", XSD._int))); toRemove.add(new StatementImpl(null, weather, DCON.cloudcover, new DatatypeLiteralImpl("10", XSD._int))); strategy.update(toAdd, toRemove); assertEquals(8, this.previousContext.size()); assertTrue(this.previousContext.findStatements(environment, RDF.type, DCON.Environment).hasNext()); aspectURI = this.previousContext.findStatements(environment, RDF.type, DCON.Environment).next().getSubject(); assertTrue(this.previousContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).hasNext()); weatherConditionsURI = (URI) this.previousContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).next().getObject(); assertTrue(this.previousContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).hasNext()); temperatureURI = (URI) this.previousContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).next().getObject(); assertTrue(this.previousContext.findStatements(temperatureURI, RDF.type, DPO.Temperature).hasNext()); assertTrue(this.previousContext.findStatements(temperatureURI, DCON.temperature, new DatatypeLiteralImpl("36.0", XSD._double)).hasNext()); assertTrue(this.previousContext.findStatements(weatherConditionsURI, RDF.type, DPO.WeatherConditions).hasNext()); assertTrue(this.previousContext.findStatements(weatherConditionsURI, DCON.cloudcover, new DatatypeLiteralImpl("10", XSD._int)).hasNext()); assertTrue(this.previousContext.findStatements(weatherConditionsURI, DCON.humidity, new DatatypeLiteralImpl("70", XSD._int)).hasNext()); assertEquals(8, this.liveContext.size()); assertTrue(this.liveContext.findStatements(environment, RDF.type, DCON.Environment).hasNext()); aspectURI = this.liveContext.findStatements(environment, RDF.type, DCON.Environment).next().getSubject(); assertTrue(this.liveContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).hasNext()); weatherConditionsURI = (URI) this.liveContext.findStatements(aspectURI, DCON.currentWeather, Variable.ANY).next().getObject(); assertTrue(this.liveContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).hasNext()); temperatureURI = (URI) this.liveContext.findStatements(aspectURI, DCON.currentTemperature, Variable.ANY).next().getObject(); assertTrue(this.liveContext.findStatements(temperatureURI, RDF.type, DPO.Temperature).hasNext()); assertTrue(this.liveContext.findStatements(temperatureURI, DCON.temperature, new DatatypeLiteralImpl("36.0", XSD._double)).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, RDF.type, DPO.WeatherConditions).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, DCON.cloudcover, new DatatypeLiteralImpl("5", XSD._int)).hasNext()); assertTrue(this.liveContext.findStatements(weatherConditionsURI, DCON.humidity, new DatatypeLiteralImpl("70", XSD._int)).hasNext()); }
|
@Override public void update(List<Statement> toAdd, List<Statement> toRemove) { previousContext.removeAll(); previousContext.addAll(liveContext.iterator()); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); }
|
SnapshotBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { previousContext.removeAll(); previousContext.addAll(liveContext.iterator()); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } }
|
SnapshotBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { previousContext.removeAll(); previousContext.addAll(liveContext.iterator()); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } SnapshotBasedStrategy(Model previousContext, Model liveContext); }
|
SnapshotBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { previousContext.removeAll(); previousContext.addAll(liveContext.iterator()); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } SnapshotBasedStrategy(Model previousContext, Model liveContext); @Override void update(List<Statement> toAdd, List<Statement> toRemove); }
|
SnapshotBasedStrategy implements UpdateStrategy { @Override public void update(List<Statement> toAdd, List<Statement> toRemove) { previousContext.removeAll(); previousContext.addAll(liveContext.iterator()); liveContext.removeAll(toRemove.iterator()); liveContext.addAll(toAdd.iterator()); } SnapshotBasedStrategy(Model previousContext, Model liveContext); @Override void update(List<Statement> toAdd, List<Statement> toRemove); }
|
@Test public void testMethod() { int expectedCount = 13; EvaluationData.countEvaluationDatas(); org.springframework.mock.staticmock.AnnotationDrivenStaticEntityMockingControl.expectReturn(expectedCount); org.springframework.mock.staticmock.AnnotationDrivenStaticEntityMockingControl.playback(); org.junit.Assert.assertEquals(expectedCount, EvaluationData.countEvaluationDatas()); }
|
public static long countEvaluationDatas() { return entityManager().createQuery("SELECT COUNT(o) FROM EvaluationData o", Long.class).getSingleResult(); }
|
EvaluationData { public static long countEvaluationDatas() { return entityManager().createQuery("SELECT COUNT(o) FROM EvaluationData o", Long.class).getSingleResult(); } }
|
EvaluationData { public static long countEvaluationDatas() { return entityManager().createQuery("SELECT COUNT(o) FROM EvaluationData o", Long.class).getSingleResult(); } }
|
EvaluationData { public static long countEvaluationDatas() { return entityManager().createQuery("SELECT COUNT(o) FROM EvaluationData o", Long.class).getSingleResult(); } String toString(); String getInvolvedItems(); void setInvolvedItems(String involvedItems); Long getId(); void setId(Long id); Integer getVersion(); void setVersion(Integer version); @Transactional void persist(); @Transactional void remove(); @Transactional void flush(); @Transactional void clear(); @Transactional EvaluationData merge(); static final EntityManager entityManager(); static long countEvaluationDatas(); static List<EvaluationData> findAllEvaluationDatas(); static List<EvaluationData> findAllLogRegisterEvaluationDatas(); static EvaluationData findEvaluationData(Long id); static List<EvaluationData> findEvaluationDataEntries(int firstResult, int maxResults); Date getEvaluationdate(); void setEvaluationdate(Date evaluationdate); String getClientid(); String getTenantId(); void setTenantId(String tenantId); void setClientid(String clientid); String getEvaluationaction(); void setEvaluationaction(String evaluationaction); String getCurrentplace(); void setCurrentplace(String currentplace); String getCurrsituationid(); void setCurrsituationid(String currsituationid); String getViewstack(); void setViewstack(String viewstack); }
|
EvaluationData { public static long countEvaluationDatas() { return entityManager().createQuery("SELECT COUNT(o) FROM EvaluationData o", Long.class).getSingleResult(); } String toString(); String getInvolvedItems(); void setInvolvedItems(String involvedItems); Long getId(); void setId(Long id); Integer getVersion(); void setVersion(Integer version); @Transactional void persist(); @Transactional void remove(); @Transactional void flush(); @Transactional void clear(); @Transactional EvaluationData merge(); static final EntityManager entityManager(); static long countEvaluationDatas(); static List<EvaluationData> findAllEvaluationDatas(); static List<EvaluationData> findAllLogRegisterEvaluationDatas(); static EvaluationData findEvaluationData(Long id); static List<EvaluationData> findEvaluationDataEntries(int firstResult, int maxResults); Date getEvaluationdate(); void setEvaluationdate(Date evaluationdate); String getClientid(); String getTenantId(); void setTenantId(String tenantId); void setClientid(String clientid); String getEvaluationaction(); void setEvaluationaction(String evaluationaction); String getCurrentplace(); void setCurrentplace(String currentplace); String getCurrsituationid(); void setCurrsituationid(String currsituationid); String getViewstack(); void setViewstack(String viewstack); final static String EVALUATIONDATA_ACTION_REGISTER; }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.