CardPool is now parametrized, preparing to hold boosters and packaged decks in quest inventory

.gitattributes

@@ -9662,7 +9662,6 @@ src/main/java/forge/card/CardDb.java -text
 src/main/java/forge/card/CardInSet.java -text
 src/main/java/forge/card/CardManaCost.java -text
 src/main/java/forge/card/CardManaCostShard.java -text
-src/main/java/forge/card/CardParsingException.java -text
 src/main/java/forge/card/CardPool.java -text
 src/main/java/forge/card/CardPoolView.java -text
 src/main/java/forge/card/CardPrinted.java -text
@@ -9672,6 +9671,7 @@ src/main/java/forge/card/CardRulesReader.java svneol=native#text/plain
 src/main/java/forge/card/CardSet.java -text
 src/main/java/forge/card/CardSuperType.java -text
 src/main/java/forge/card/CardType.java -text
+src/main/java/forge/card/InventoryItem.java -text
 src/main/java/forge/card/MtgDataParser.java -text
 src/main/java/forge/card/abilityFactory/AbilityFactory.java svneol=native#text/plain
 src/main/java/forge/card/abilityFactory/AbilityFactory_AlterLife.java svneol=native#text/plain

src/main/java/forge/BoosterGenerator.java

@@ -85,7 +85,7 @@ public class BoosterGenerator {
             throw new RuntimeException("BoosterGenerator : deck not found - " + deckFile);
         }
 
-        CardPoolView tList = dPool.getMain();
+        CardPoolView<CardPrinted> tList = dPool.getMain();
         for (Entry<CardPrinted, Integer> e : tList) {
             if (ignoreRarity) { commons.add(e.getKey()); }
             else { addToRarity(e.getKey()); }

src/main/java/forge/GUI_DeckAnalysis.java

@@ -98,7 +98,7 @@ public class GUI_DeckAnalysis extends javax.swing.JDialog {
     // private ButtonGroup buttonGroup1;
 
     public CardList filterCardList;
-    public CardPoolView deck;
+    public CardPoolView<CardPrinted> deck;
 
     /**
      * <p>
@@ -110,7 +110,7 @@ public class GUI_DeckAnalysis extends javax.swing.JDialog {
      * @param tb
      *            a {@link forge.gui.deckeditor.TableModel} object.
      */
-    public GUI_DeckAnalysis(JFrame g, CardPoolView deckView) {
+    public GUI_DeckAnalysis(JFrame g, CardPoolView<CardPrinted> deckView) {
         super(g);
         deck = deckView;
 

src/main/java/forge/Gui_WinLose.java

@@ -187,7 +187,6 @@ public class Gui_WinLose extends JFrame implements NewConstants {
         if (Constant.Quest.fantasyQuest[0]) {
             int extraLife = 0;
             if (model.qa != null) {
-                forge.quest.data.QuestUtil.setupQuest(model.qa);
                 if (model.quest.getInventory().hasItem("Zeppelin")) {
                     extraLife = 3;
                 }

src/main/java/forge/ImageCache.java

@@ -7,7 +7,7 @@ import com.google.common.collect.ComputationException;
 import com.google.common.collect.MapMaker;
 import com.mortennobel.imagescaling.ResampleOp;
 
-import forge.card.CardPrinted;
+import forge.card.InventoryItem;
 import forge.properties.ForgeProps;
 import forge.properties.NewConstants;
 
@@ -141,7 +141,7 @@ public class ImageCache implements NewConstants {
         return getImage(key + "#" + scale);
     }
 
-    public static BufferedImage getImage(CardPrinted card, int width, int height) {
+    public static BufferedImage getImage(InventoryItem card, int width, int height) {
         String key = card.getImageFilename();
         BufferedImage original = getImage(key);
         if (original == null) return null;

src/main/java/forge/ReadBoosterPack.java

@@ -54,8 +54,8 @@ public class ReadBoosterPack implements NewConstants {
      *
      * @return a {@link forge.CardList} object.
      */
-    public CardPoolView getBoosterPack5() {
+    public CardPoolView<CardPrinted> getBoosterPack5() {
-        CardPool list = new CardPool();
+        CardPool<CardPrinted> list = new CardPool<CardPrinted>();
         for (int i = 0; i < 5; i++) { list.addAll(getBoosterPack()); }
 
         addBasicLands(list, 20);
@@ -67,7 +67,7 @@ public class ReadBoosterPack implements NewConstants {
         return list;
     }//getBoosterPack5()
 
-    public static final void addBasicLands(final CardPool pool, final int count) {
+    public static final void addBasicLands(final CardPool<CardPrinted> pool, final int count) {
         for (int i = 0; i < count; i++) {
             pool.add(CardDb.instance().getCard("Forest", "M10"));
             pool.add(CardDb.instance().getCard("Island", "M10"));
@@ -76,7 +76,7 @@ public class ReadBoosterPack implements NewConstants {
             pool.add(CardDb.instance().getCard("Swamp", "M10"));
         }
     }
-    public static final void addBasicSnowLands(final CardPool pool, final int count) {
+    public static final void addBasicSnowLands(final CardPool<CardPrinted> pool, final int count) {
         for (int i = 0; i < count; i++) {
             pool.add(CardDb.instance().getCard("Snow-Covered Forest", "ICE"));
             pool.add(CardDb.instance().getCard("Snow-Covered Island", "ICE"));
@@ -91,8 +91,8 @@ public class ReadBoosterPack implements NewConstants {
      *
      * @return a {@link forge.CardList} object.
      */
-    public CardPoolView getBoosterPack() {
+    public CardPoolView<CardPrinted> getBoosterPack() {
-        CardPool pack = new CardPool();
+        CardPool<CardPrinted> pack = new CardPool<CardPrinted>();
 
         pack.add(getRandomCard(rares));
 
@@ -125,8 +125,8 @@ public class ReadBoosterPack implements NewConstants {
      * @param questLevel a int.
      * @return a {@link forge.CardList} object.
      */
-    public CardPoolView getShopCards(int totalPacks) {
+    public CardPoolView<CardPrinted> getShopCards(int totalPacks) {
-        CardPool list = new CardPool();
+        CardPool<CardPrinted> list = new CardPool<CardPrinted>();
 
         // Number of Packs granted
 

src/main/java/forge/ReadDraftBoosterPack.java

@@ -45,8 +45,8 @@ public class ReadDraftBoosterPack implements NewConstants {
         setup();
     }
 
-    public CardPoolView getBoosterPack5() {
+    public CardPoolView<CardPrinted> getBoosterPack5() {
-        CardPool list = new CardPool();
+        CardPool<CardPrinted> list = new CardPool<CardPrinted>();
         for (int i = 0; i < 5; i++) { list.addAll(getBoosterPack()); }
 
         addBasicLands(list, 20);
@@ -59,7 +59,7 @@ public class ReadDraftBoosterPack implements NewConstants {
         return list;
     } //getBoosterPack5()
 
-    public static final void addBasicLands(final CardPool pool, final int count) {
+    public static final void addBasicLands(final CardPool<CardPrinted> pool, final int count) {
         CardDb db = CardDb.instance();
         pool.add(db.getCard("Forest", "M10"), count);
         pool.add(db.getCard("Island", "M10"), count);
@@ -68,7 +68,7 @@ public class ReadDraftBoosterPack implements NewConstants {
         pool.add(db.getCard("Swamp", "M10"), count);
 
     }
-    public static final void addBasicSnowLands(final CardPool pool, final int count) {
+    public static final void addBasicSnowLands(final CardPool<CardPrinted> pool, final int count) {
         CardDb db = CardDb.instance();
         pool.add(db.getCard("Snow-Covered Forest", "ICE"), count);
         pool.add(db.getCard("Snow-Covered Island", "ICE"), count);
@@ -81,8 +81,8 @@ public class ReadDraftBoosterPack implements NewConstants {
      *
      * @return a {@link forge.CardList} object.
      */
-    public final CardPoolView getBoosterPack() {
+    public final CardPoolView<CardPrinted> getBoosterPack() {
-        CardPool pack = new CardPool();
+        CardPool<CardPrinted> pack = new CardPool<CardPrinted>();
 
         pack.add(getRandomCard(rareList));
 

src/main/java/forge/card/CardColor.java

@@ -25,6 +25,9 @@ public final class CardColor implements Comparable<CardColor> {
         orderWeight = getOrderWeight(); 
     }
     
+    private CardColor() { myColor = 0; orderWeight = -1;}
+    public static CardColor nullColor = new CardColor();
+
     public boolean hasAnyColor(final byte colormask) { return (myColor & colormask) != 0; }
     public boolean hasAllColors(final byte colormask) { return (myColor & colormask) == colormask; }
 
@@ -55,6 +58,7 @@ public final class CardColor implements Comparable<CardColor> {
 
     @Override
     public String toString() {
+        if (orderWeight == -1) return "n/a";
         switch (myColor) {
             case 0: return Constant.Color.Colorless;
             case WHITE: return Constant.Color.White;

src/main/java/forge/card/CardParsingException.java

@@ -1,33 +0,0 @@
-package forge.card;
-
-/** 
- * Indicates an error parsing a card txt file.
- */
-public class CardParsingException extends Exception {
-
-    private static final long serialVersionUID = -6504223115741449784L;
-
-    /**
-     * Constructor with message.
-     * 
-     * @param txtFile  name of txt file with the problem
-     * @param lineNum  indicates the line number containing the problem
-     * @param message  describes the nature of the problem in the file
-     */
-    public CardParsingException(final String txtFile, final int lineNum, final String message) {
-        super("in '" + txtFile + "' line " + lineNum + ": " + message);
-    }
-
-    /**
-     * Constructor with message and cause.
-     * 
-     * @param txtFile  name of txt file with the problem
-     * @param lineNum  indicates the line number containing the problem
-     * @param message  describes the nature of the problem in the file
-     * @param cause  the original cause for the exception
-     */
-    public CardParsingException(final String txtFile, final int lineNum, final String message, final Throwable cause)
-    {
-        super("in '" + txtFile + "' line " + lineNum + ": " + message, cause);
-    }
-}

src/main/java/forge/card/CardPool.java

@@ -1,7 +1,6 @@
 package forge.card;
 
 import java.util.Collections;
-import java.util.Hashtable;
 import java.util.List;
 import java.util.Map.Entry;
 
@@ -9,51 +8,77 @@ import java.util.Map.Entry;
  * <p>CardPool class.</p>
  * Represents a list of cards with amount of each
  */
-public final class CardPool extends CardPoolView  {
+public final class CardPool<T extends InventoryItem> extends CardPoolView<T>  {
 
-    // Contructors here
+    // Constructors here
     public CardPool() { super(); }
-    public CardPool(final List<String> names) { super(); addAllCards(CardDb.instance().getCards(names)); }
 
-    // Copy ctor will create its own modifiable pool
+    @SuppressWarnings("unchecked") // conversion here must be safe
-    public CardPool(final CardPoolView from) {
+    public CardPool(final List<String> names) { super(); addAllCards((Iterable<T>) CardDb.instance().getCards(names)); }
-        super();
+
-        cards = new Hashtable<CardPrinted, Integer>();
+    @SuppressWarnings("unchecked")
-        if (from != null) { cards.putAll(from.cards); }
+    public static <Tin extends InventoryItem, Tout extends InventoryItem> CardPool<Tout> 
-     }
+        createFrom(CardPoolView<Tin> from, Class<Tout> clsHint) 
-    public CardPool(final Iterable<CardPrinted> list) {
+    {
-        this(); addAllCards(list);
+        CardPool<Tout> result = new CardPool<Tout>();
+        if (from != null) {
+            for (Entry<Tin, Integer> e : from) {
+                Tin srcKey = e.getKey();
+                if (clsHint.isInstance(srcKey)) {
+                    result.put((Tout) srcKey, e.getValue());
+                }
+            }
+        }
+        return result;
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static <Tin extends InventoryItem, Tout extends InventoryItem> CardPool<Tout>
+        createFrom(Iterable<Tin> from, Class<Tout> clsHint) {
+        CardPool<Tout> result = new CardPool<Tout>();
+        if (from != null) {
+            for (Tin srcKey : from) {
+                if (clsHint.isInstance(srcKey)) {
+                    result.put((Tout) srcKey, Integer.valueOf(1));
+                }
+            }
+        }
+        return result;
     }
 
     // get
-    public CardPoolView getView() { return new CardPoolView(Collections.unmodifiableMap(cards)); }
+    public CardPoolView<T> getView() { return new CardPoolView<T>(Collections.unmodifiableMap(cards)); }
 
     // Cards manipulation
-    public void add(final CardPrinted card) { add(card, 1); }
+    public void add(final T card) { add(card, 1); }
-    public void add(final CardPrinted card, final int amount) {
+    public void add(final T card, final int amount) {
         if (amount <= 0) { return; }
         cards.put(card, count(card) + amount);
         isListInSync = false;
     }
-    public void addAllCards(final Iterable<CardPrinted> cards) {
+    private void put(final T card, final int amount) {
-        for (CardPrinted cr : cards) { add(cr); }
+        cards.put(card, amount);
         isListInSync = false;
     }    
-    public void addAll(final Iterable<Entry<CardPrinted, Integer>> map) {
+    public void addAllCards(final Iterable<T> cards) {
-        for (Entry<CardPrinted, Integer> e : map) { add(e.getKey(), e.getValue()); }
+        for (T cr : cards) { add(cr); }
+        isListInSync = false;
+    }
+    public void addAll(final Iterable<Entry<T, Integer>> map) {
+        for (Entry<T, Integer> e : map) { add(e.getKey(), e.getValue()); }
         isListInSync = false;
     }
 
-    public void remove(final CardPrinted card) { remove(card, 1); }
+    public void remove(final T card) { remove(card, 1); }
-    public void remove(final CardPrinted card, final int amount) {
+    public void remove(final T card, final int amount) {
         int count = count(card);
         if (count == 0 || amount <= 0) { return; }
         if (count <= amount) { cards.remove(card); }
         else { cards.put(card, count - amount); }
         isListInSync = false;
     }
-    public void removeAll(final Iterable<Entry<CardPrinted, Integer>> map) {
+    public void removeAll(final Iterable<Entry<T, Integer>> map) {
-        for (Entry<CardPrinted, Integer> e : map) { remove(e.getKey(), e.getValue()); }
+        for (Entry<T, Integer> e : map) { remove(e.getKey(), e.getValue()); }
         isListInSync = false;
     }
 

src/main/java/forge/card/CardPoolView.java

@@ -17,46 +17,49 @@ import net.slightlymagic.braids.util.lambda.Lambda1;
  * @author Forge
  * @version $Id: CardPoolView.java 9708 2011-08-09 19:34:12Z jendave $
  */
-public class CardPoolView implements Iterable<Entry<CardPrinted, Integer>> {
+public class CardPoolView<T extends InventoryItem> implements Iterable<Entry<T, Integer>> {
 
     // Field Accessors for select/aggregate operations with filters.
-    public final static Lambda1<CardRules, Entry<CardPrinted, Integer>> fnToCard =
+    public final Lambda1<CardRules, Entry<T, Integer>> fnToCard =
-        new Lambda1<CardRules, Entry<CardPrinted, Integer>>() {
+        new Lambda1<CardRules, Entry<T, Integer>>() {
-          @Override public CardRules apply(final Entry<CardPrinted, Integer> from) { return from.getKey().getCard(); }
+          @Override public CardRules apply(final Entry<T, Integer> from) {
+              T item = from.getKey();
+              return item instanceof CardPrinted ? ((CardPrinted) item).getCard() : null; 
+          }
         };
-    public final static Lambda1<CardPrinted, Entry<CardPrinted, Integer>> fnToPrinted =
+    public final Lambda1<T, Entry<T, Integer>> fnToPrinted =
-        new Lambda1<CardPrinted, Entry<CardPrinted, Integer>>() {
+        new Lambda1<T, Entry<T, Integer>>() {
-          @Override public CardPrinted apply(final Entry<CardPrinted, Integer> from) { return from.getKey(); }
+          @Override public T apply(final Entry<T, Integer> from) { return from.getKey(); }
         };
-    public final static Lambda1<String, Entry<CardPrinted, Integer>> fnToCardName =
+    public final Lambda1<String, Entry<T, Integer>> fnToCardName =
-        new Lambda1<String, Entry<CardPrinted, Integer>>() {
+        new Lambda1<String, Entry<T, Integer>>() {
-          @Override public String apply(final Entry<CardPrinted, Integer> from) { return from.getKey().getName(); }
+          @Override public String apply(final Entry<T, Integer> from) { return from.getKey().getName(); }
         };
-    public final static Lambda1<Integer, Entry<CardPrinted, Integer>> fnToCount =
+    public final Lambda1<Integer, Entry<T, Integer>> fnToCount =
-        new Lambda1<Integer, Entry<CardPrinted, Integer>>() {
+        new Lambda1<Integer, Entry<T, Integer>>() {
-            @Override public Integer apply(final Entry<CardPrinted, Integer> from) { return from.getValue(); }
+            @Override public Integer apply(final Entry<T, Integer> from) { return from.getValue(); }
         };
 
     // Constructors
-    public CardPoolView() { cards = new Hashtable<CardPrinted, Integer>(); }
+    public CardPoolView() { cards = new Hashtable<T, Integer>(); }
-    public CardPoolView(final Map<CardPrinted, Integer> inMap) { cards = inMap; }
+    public CardPoolView(final Map<T, Integer> inMap) { cards = inMap; }
 
     // Data members
-    protected Map<CardPrinted, Integer> cards;
+    protected Map<T, Integer> cards;
 
     // same thing as above, it was copied to provide sorting (needed by table views in deck editors) 
-    protected List<Entry<CardPrinted, Integer>> cardsListOrdered = new ArrayList<Map.Entry<CardPrinted,Integer>>();
+    protected List<Entry<T, Integer>> cardsListOrdered = new ArrayList<Map.Entry<T,Integer>>();
     protected boolean isListInSync = false;
 
     @Override
-    public final Iterator<Entry<CardPrinted, Integer>> iterator() { return cards.entrySet().iterator(); }
+    public final Iterator<Entry<T, Integer>> iterator() { return cards.entrySet().iterator(); }
 
     // Cards read only operations
-    public final boolean contains(final CardPrinted card) {
+    public final boolean contains(final T card) {
         if (cards == null) { return false; }
         return cards.containsKey(card);
     }
-    public final int count(final CardPrinted card) {
+    public final int count(final T card) {
         if (cards == null) { return 0; }
         Integer boxed = cards.get(card);
         return boxed == null ? 0 : boxed.intValue();
@@ -69,7 +72,7 @@ public class CardPoolView implements Iterable<Entry<CardPrinted, Integer>> {
     public final int countDistinct() { return cards.size(); }
     public final boolean isEmpty() { return cards == null || cards.isEmpty(); }
 
-    public final List<Entry<CardPrinted, Integer>> getOrderedList() {
+    public final List<Entry<T, Integer>> getOrderedList() {
         if (!isListInSync) { rebuildOrderedList(); }
         return cardsListOrdered;
     }
@@ -77,16 +80,16 @@ public class CardPoolView implements Iterable<Entry<CardPrinted, Integer>> {
     private void rebuildOrderedList() {
         cardsListOrdered.clear();
         if (cards != null) {
-            for (Entry<CardPrinted, Integer> e : cards.entrySet()) {
+            for (Entry<T, Integer> e : cards.entrySet()) {
                 cardsListOrdered.add(e);
             }
         }
         isListInSync = true;
     }
 
-    public final List<CardPrinted> toFlatList() {
+    public final List<T> toFlatList() {
-        List<CardPrinted> result = new ArrayList<CardPrinted>();
+        List<T> result = new ArrayList<T>();
-        for (Entry<CardPrinted, Integer> e : this) {
+        for (Entry<T, Integer> e : this) {
             for (int i = 0; i < e.getValue(); i++) { result.add(e.getKey()); }
         }
         return result;
@@ -94,9 +97,12 @@ public class CardPoolView implements Iterable<Entry<CardPrinted, Integer>> {
 
     public final CardList toForgeCardList() {
         CardList result = new CardList();
-        for (Entry<CardPrinted, Integer> e : this) {
+        for (Entry<T, Integer> e : this) {
+            if ( e.getKey() instanceof CardPrinted )
+            {
             for (int i = 0; i < e.getValue(); i++) {
-                result.add(e.getKey().toForgeCard());
+                result.add(((CardPrinted) e.getKey()).toForgeCard());
+            }
             }
         }
         return result;

src/main/java/forge/card/CardPrinted.java

@@ -18,7 +18,7 @@ import forge.CardUtil;
  * @author Forge
  * @version $Id: CardReference.java 9708 2011-08-09 19:34:12Z jendave $
  */
-public final class CardPrinted implements Comparable<CardPrinted> {
+public final class CardPrinted implements Comparable<CardPrinted>, InventoryItem {
     // Reference to rules
     private final transient CardRules card;
 

src/main/java/forge/card/CardSet.java

@@ -21,6 +21,8 @@ public final class CardSet implements Comparable<CardSet> { // immutable
         this.name = name;
     }
     
+    public static final CardSet unknown = new CardSet(-1, "Undefined", "???", "??"); 
+
     public String getName() { return name; }
     public String getCode() { return code; }
     public String getCode2() { return code2; }

src/main/java/forge/card/InventoryItem.java

@@ -0,0 +1,12 @@
+package forge.card;
+
+/** 
+ * Interface to define a player's inventory may hold.
+ * Should include CardPrinted, Booster, Pets, Plants... etc
+ */
+public interface InventoryItem /* extends Comparable */ {
+    /** An inventory item has to provide a name. */
+    String getName();
+    /** An inventory item has to provide a picture. */
+    String getImageFilename();
+}

src/main/java/forge/deck/Deck.java

@@ -8,7 +8,6 @@ import forge.card.CardPrinted;
 import forge.game.GameType;
 
 import java.io.Serializable;
-import java.util.*;
 
 /**
  * <p>Deck class.</p>
@@ -33,12 +32,8 @@ public final class Deck implements Comparable<Deck>, Serializable {
     private String comment = null;
     private PlayerType playerType = null;
     
-    private CardPool main;
+    private CardPool<CardPrinted> main;
-    private CardPool sideboard;
+    private CardPool<CardPrinted> sideboard;
-
-
-
-
 
 
     //gameType is from Constant.GameType, like GameType.Regular
@@ -46,24 +41,8 @@ public final class Deck implements Comparable<Deck>, Serializable {
      * <p>Constructor for Deck.</p>
      */
     public Deck() {
-        main = new CardPool();
+        main = new CardPool<CardPrinted>();
-        sideboard = new CardPool();
+        sideboard = new CardPool<CardPrinted>();
-    }
-
-    /**
-     * <p>Constructor for Deck.</p>
-     *
-     * @param deckType a {@link java.lang.String} object.
-     * @param main a {@link java.util.List} object.
-     * @param sideboard a {@link java.util.List} object.
-     * @param name a {@link java.lang.String} object.
-     */
-    public Deck(GameType deckType, List<String> main, List<String> sideboard, String name) {
-        setDeckType(deckType);
-        setName(name);
-
-        this.main = new CardPool(main);
-        this.sideboard = new CardPool(sideboard);
     }
 
     /**
@@ -81,7 +60,7 @@ public final class Deck implements Comparable<Deck>, Serializable {
      *
      * @return a {@link java.util.List} object.
      */
-    public CardPoolView getMain() {
+    public CardPoolView<CardPrinted> getMain() {
         return main.getView();
     }
 
@@ -90,7 +69,7 @@ public final class Deck implements Comparable<Deck>, Serializable {
      *
      * @return a {@link java.util.List} object.
      */
-    public CardPoolView getSideboard() {
+    public CardPoolView<CardPrinted> getSideboard() {
         return sideboard.getView();
     }
 
@@ -161,7 +140,7 @@ public final class Deck implements Comparable<Deck>, Serializable {
      */
     public void addMain(final String cardName) { addMain(CardDb.instance().getCard(cardName)); }
     public void addMain(final CardPrinted card) { main.add(card); }
-    public void addMain(final CardPoolView list) { main.addAll(list); }
+    public void addMain(final CardPoolView<CardPrinted> list) { main.addAll(list); }
     public void removeMain(final CardPrinted card) { main.remove(card); }
     public void removeMain(final CardPrinted card, final int amount) { main.remove(card, amount); }
     public int countMain() { return main.countAll(); }
@@ -174,7 +153,7 @@ public final class Deck implements Comparable<Deck>, Serializable {
     public final void addSideboard(final String cardName) { addSideboard(CardDb.instance().getCard(cardName)); }
     public final void addSideboard(final CardPrinted card) { sideboard.add(card); }
     public final void addSideboard(final CardPrinted card, final int amount) { sideboard.add(card, amount); }
-    public final void addSideboard(final CardPoolView cards) { sideboard.addAll(cards); }
+    public final void addSideboard(final CardPoolView<CardPrinted> cards) { sideboard.addAll(cards); }
 
     /**
      * <p>countSideboard.</p>

src/main/java/forge/deck/DeckManager.java

@@ -502,7 +502,7 @@ public class DeckManager {
         writeCardPool(d.getSideboard(), out);
     }
 
-    private static void writeCardPool(final CardPoolView pool, final BufferedWriter out) throws IOException
+    private static void writeCardPool(final CardPoolView<CardPrinted> pool, final BufferedWriter out) throws IOException
     {
         List<Entry<CardPrinted, Integer>> main2sort = pool.getOrderedList();
         Collections.sort(main2sort, TableSorter.byNameThenSet);

src/main/java/forge/deck/DownloadDeck.java

@@ -1,7 +1,5 @@
 package forge.deck;
 
-import forge.AllZone;
-import forge.Card;
 import forge.card.CardDb;
 
 /**

src/main/java/forge/game/limited/BoosterDraft.java

@@ -18,7 +18,7 @@ public interface BoosterDraft {
      *
      * @return a {@link forge.CardList} object.
      */
-    CardPoolView nextChoice();
+    CardPoolView<CardPrinted> nextChoice();
 
     /**
      * <p>setChoice.</p>

src/main/java/forge/game/limited/BoosterDraft_1.java

@@ -237,13 +237,13 @@ public class BoosterDraft_1 implements BoosterDraft {
      *
      * @return a {@link forge.CardList} object.
      */
-    public final CardPoolView nextChoice() {
+    public final CardPoolView<CardPrinted> nextChoice() {
         if (pack.get(getCurrentBoosterIndex()).size() == 0) {
             pack = get8BoosterPack();
         }
 
         computerChoose();
-        return new CardPool(pack.get(getCurrentBoosterIndex()));
+        return CardPool.createFrom(pack.get(getCurrentBoosterIndex()), CardPrinted.class);
     }
 
     /**

src/main/java/forge/game/limited/SealedDeck.java

@@ -13,6 +13,7 @@ import forge.SetUtils;
 import forge.card.CardBlock;
 import forge.card.CardDb;
 import forge.card.CardPool;
+import forge.card.CardPrinted;
 import forge.card.CardSet;
 import forge.card.spellability.Ability_Mana;
 import forge.deck.Deck;
@@ -180,8 +181,8 @@ public class SealedDeck {
      *
      * @return a {@link forge.CardList} object.
      */
-    public CardPool getCardpool() {
+    public CardPool<CardPrinted> getCardpool() {
-        CardPool pool = new CardPool();
+        CardPool<CardPrinted> pool = new CardPool<CardPrinted>();
 
         for (int i = 0; i < packs.size(); i++)
             pool.addAllCards(packs.get(i).getBoosterPack());

src/main/java/forge/gui/deckeditor/CardPanelBase.java

@@ -1,7 +1,7 @@
 package forge.gui.deckeditor;
 
 import javax.swing.JPanel;
-import forge.card.CardPrinted;
+import forge.card.InventoryItem;
 
 /** 
  * Base class for any cardView panel
@@ -10,6 +10,6 @@ import forge.card.CardPrinted;
 public abstract class CardPanelBase extends JPanel {
     private static final long serialVersionUID = -2230733670423143126L;
 
-    public abstract void showCard(CardPrinted card);
+    public abstract void showCard(InventoryItem card);
 
 }

src/main/java/forge/gui/deckeditor/CardPanelHeavy.java

@@ -19,6 +19,7 @@ import forge.GuiDisplayUtil;
 import forge.ImagePreviewPanel;
 import forge.Singletons;
 import forge.card.CardPrinted;
+import forge.card.InventoryItem;
 import forge.gui.game.CardDetailPanel;
 import forge.properties.ForgeProps;
 import forge.properties.NewConstants;
@@ -73,8 +74,8 @@ public class CardPanelHeavy extends CardPanelBase {
         this.add(pictureViewPanel, "wmin 239, hmin 323, grow");
     }
 
-    public void showCard(CardPrinted card) {
+    public void showCard(InventoryItem card) {
-        Card card2 = card.toForgeCard();
+        Card card2 = card instanceof CardPrinted ? ((CardPrinted) card).toForgeCard() : null;
         detail.setCard(card2);
         setCard(card2);
     }

src/main/java/forge/gui/deckeditor/CardPanelLite.java

@@ -4,6 +4,7 @@ import net.miginfocom.swing.MigLayout;
 
 import forge.Card;
 import forge.card.CardPrinted;
+import forge.card.InventoryItem;
 import forge.gui.game.CardDetailPanel;
 import forge.gui.game.CardPicturePanel;
 
@@ -25,9 +26,9 @@ public class CardPanelLite extends CardPanelBase {
         this.add(picture, "wmin 239, hmin 323, grow");
     }
 
-    public void showCard(CardPrinted card) {
+    public void showCard(InventoryItem card) {
         picture.setCard(card);
-        detail.setCard(card != null ? card.toForgeCard() : null);
+        detail.setCard(card != null && card instanceof CardPrinted ? ((CardPrinted) card).toForgeCard() : null);
     }
 
     public Card getCard() { return detail.getCard(); }

src/main/java/forge/gui/deckeditor/DeckDisplay.java

@@ -1,6 +1,8 @@
 package forge.gui.deckeditor;
 
 import forge.card.CardPoolView;
+import forge.card.CardPrinted;
+import forge.card.InventoryItem;
 import forge.deck.Deck;
 import forge.game.GameType;
 
@@ -13,16 +15,16 @@ import forge.game.GameType;
  * @version $Id$
  */
 public interface DeckDisplay {
-    void setDeck(CardPoolView top, CardPoolView bottom, GameType gameType);
+    void setDeck(CardPoolView<CardPrinted> top, CardPoolView<CardPrinted> bottom, GameType gameType);
 
     //top shows available card pool
     //if constructed, top shows all cards
     //if sealed, top shows 5 booster packs
     //if draft, top shows cards that were chosen
-    CardPoolView getTop();
+    CardPoolView<InventoryItem> getTop();
 
     //bottom shows cards that the user has chosen for his library
-    CardPoolView getBottom();
+    CardPoolView<InventoryItem> getBottom();
 
     void setTitle(String message);
 

src/main/java/forge/gui/deckeditor/DeckEditor.java

@@ -25,6 +25,7 @@ import forge.card.CardDb;
 import forge.card.CardPool;
 import forge.card.CardPoolView;
 import forge.card.CardPrinted;
+import forge.card.InventoryItem;
 import forge.error.ErrorViewer;
 import forge.game.GameType;
 //import forge.view.swing.OldGuiNewGame;
@@ -88,16 +89,16 @@ public final class DeckEditor extends DeckEditorBase {
 
 
     private void setup() {
-        List<TableColumnInfo<CardPrinted>> columns = new ArrayList<TableColumnInfo<CardPrinted>>();
+        List<TableColumnInfo<InventoryItem>> columns = new ArrayList<TableColumnInfo<InventoryItem>>();
-        columns.add(new TableColumnInfo<CardPrinted>("Qty", 30, PresetColumns.fnQtyCompare, PresetColumns.fnQtyGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Qty", 30, PresetColumns.fnQtyCompare, PresetColumns.fnQtyGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Name", 175, PresetColumns.fnNameCompare, PresetColumns.fnNameGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Name", 175, PresetColumns.fnNameCompare, PresetColumns.fnNameGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Cost", 75, PresetColumns.fnCostCompare, PresetColumns.fnCostGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Cost", 75, PresetColumns.fnCostCompare, PresetColumns.fnCostGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Color", 50, PresetColumns.fnColorCompare, PresetColumns.fnColorGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Color", 50, PresetColumns.fnColorCompare, PresetColumns.fnColorGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Type", 100, PresetColumns.fnTypeCompare, PresetColumns.fnTypeGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Type", 100, PresetColumns.fnTypeCompare, PresetColumns.fnTypeGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Stats", 40, PresetColumns.fnStatsCompare, PresetColumns.fnStatsGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Stats", 40, PresetColumns.fnStatsCompare, PresetColumns.fnStatsGet));
-        columns.add(new TableColumnInfo<CardPrinted>("R", 35, PresetColumns.fnRarityCompare, PresetColumns.fnRarityGet));
+        columns.add(new TableColumnInfo<InventoryItem>("R", 35, PresetColumns.fnRarityCompare, PresetColumns.fnRarityGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Set", 40, PresetColumns.fnSetCompare, PresetColumns.fnSetGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Set", 40, PresetColumns.fnSetCompare, PresetColumns.fnSetGet));
-        columns.add(new TableColumnInfo<CardPrinted>("AI", 30, PresetColumns.fnAiStatusCompare, PresetColumns.fnAiStatusGet));
+        columns.add(new TableColumnInfo<InventoryItem>("AI", 30, PresetColumns.fnAiStatusCompare, PresetColumns.fnAiStatusGet));
         columns.get(2).setCellRenderer(new ManaCostRenderer());
         
         top.setup(columns, cardView);
@@ -214,19 +215,19 @@ public final class DeckEditor extends DeckEditorBase {
     }
 
     @Override
-    protected Predicate<CardPrinted> buildFilter() {
+    protected Predicate<InventoryItem> buildFilter() {
-        return Predicate.and(filterBoxes.buildFilter(), filterNameTypeSet.buildFilter());
+        Predicate<CardPrinted> cardFilter = Predicate.and(filterBoxes.buildFilter(), filterNameTypeSet.buildFilter());
+        return Predicate.instanceOf(cardFilter, CardPrinted.class);
     }
 
     @Override
-    public void setDeck(CardPoolView topParam, CardPoolView bottomParam, GameType gt)
+    public void setDeck(CardPoolView<CardPrinted> topParam, CardPoolView<CardPrinted> bottomParam, GameType gt)
     {
         boolean keepRecievedCards = gt.isLimited() || topParam != null;  
         // if constructed, can add the all cards above
-        CardPoolView top = keepRecievedCards ? topParam : new CardPool(CardDb.instance().getAllCards());
+        CardPoolView<CardPrinted> top = keepRecievedCards ? topParam : CardPool.createFrom(CardDb.instance().getAllCards(), CardPrinted.class);
 
         super.setDeck(top, bottomParam, gt);
-        
     }
     
     void clearFilterButton_actionPerformed(ActionEvent e) {
@@ -248,9 +249,10 @@ public final class DeckEditor extends DeckEditorBase {
     }
 
     void addCardToDeck() {
-        CardPrinted card = top.getSelectedCard();
+        InventoryItem item = top.getSelectedCard();
-        if (card == null) { return; }
+        if (item == null || !( item instanceof CardPrinted )) { return; }
 
+        CardPrinted card = (CardPrinted) item;
         setTitle("Deck Editor : " + customMenu.getDeckName() + " : unsaved");
 
         bottom.addCard(card);
@@ -262,8 +264,10 @@ public final class DeckEditor extends DeckEditorBase {
     }
 
     void removeButtonClicked(ActionEvent e) {
-        CardPrinted card = bottom.getSelectedCard();
+        InventoryItem item = bottom.getSelectedCard();
-        if (card == null) { return; }
+        if (item == null || !( item instanceof CardPrinted )) { return; }
+
+        CardPrinted card = (CardPrinted) item;
 
         setTitle("Deck Editor : " + customMenu.getDeckName() + " : unsaved");
 

src/main/java/forge/gui/deckeditor/DeckEditorBase.java

@@ -12,8 +12,10 @@ import javax.swing.event.DocumentListener;
 import net.slightlymagic.maxmtg.Predicate;
 
 import forge.GUI_DeckAnalysis;
+import forge.card.CardPool;
 import forge.card.CardPrinted;
 import forge.card.CardPoolView;
+import forge.card.InventoryItem;
 import forge.deck.Deck;
 import forge.game.GameType;
 
@@ -40,16 +42,16 @@ public abstract class DeckEditorBase extends JFrame implements DeckDisplay  {
     // if sealed, top shows N booster packs
     // if draft, top shows cards that were chosen
     public final TableWithCards getTopTableModel() { return top; }
-    public final CardPoolView getTop() { return top.getCards(); }
+    public final CardPoolView<InventoryItem> getTop() { return top.getCards(); }
     // bottom shows player's choice - be it deck or draft
-    public final CardPoolView getBottom() { return bottom.getCards(); }
+    public final CardPoolView<InventoryItem> getBottom() { return bottom.getCards(); }
 
     // THIS IS HERE FOR OVERLOADING!!!1
     // or may be return abstract getFilter from derived class + this filter ... virtual protected member, but later
-    protected abstract Predicate<CardPrinted> buildFilter();
+    protected abstract Predicate<InventoryItem> buildFilter();
 
     void analysisButton_actionPerformed(ActionEvent e) {
-        CardPoolView deck = bottom.getCards(); 
+        CardPoolView<CardPrinted> deck = CardPool.createFrom(bottom.getCards(), CardPrinted.class); 
         if (deck.isEmpty()) {
             JOptionPane.showMessageDialog(null, "Cards in deck not found.", "Analysis Deck",
                     JOptionPane.INFORMATION_MESSAGE);
@@ -66,7 +68,7 @@ public abstract class DeckEditorBase extends JFrame implements DeckDisplay  {
         gameType = gametype;
     }
     
-    public void setDeck(CardPoolView topParam, CardPoolView bottomParam, GameType gt) {
+    public void setDeck(CardPoolView<CardPrinted> topParam, CardPoolView<CardPrinted> bottomParam, GameType gt) {
         gameType = gt;
         top.setDeck(topParam);
         bottom.setDeck(bottomParam);
@@ -91,11 +93,11 @@ public abstract class DeckEditorBase extends JFrame implements DeckDisplay  {
     
     public Deck getDeck() {
         Deck deck = new Deck(gameType);
-        deck.addMain(getBottom());
+        deck.addMain(CardPool.createFrom(getBottom(), CardPrinted.class));
 
         //if sealed or draft, move "top" to sideboard
         if (gameType.isLimited() && gameType != GameType.Quest) {
-            deck.addSideboard(getTop());
+            deck.addSideboard(CardPool.createFrom(getTop(), CardPrinted.class));
         }
         return deck;
     }//getDeck()

src/main/java/forge/gui/deckeditor/DeckEditorDraft.java

@@ -5,8 +5,10 @@ import forge.Constant;
 import forge.FileUtil;
 import forge.HttpUtil;
 import forge.card.CardDb;
+import forge.card.CardPool;
 import forge.card.CardPoolView;
 import forge.card.CardPrinted;
+import forge.card.InventoryItem;
 import forge.deck.Deck;
 import forge.deck.DeckManager;
 import forge.error.ErrorViewer;
@@ -75,7 +77,7 @@ public class DeckEditorDraft extends DeckEditorBase implements NewConstants, New
 
         setup();
         showChoices(boosterDraft.nextChoice());
-        bottom.setDeck((CardPoolView) null);
+        bottom.setDeck((Iterable<InventoryItem>)null);
         
         top.sort(1, true);
         bottom.sort(1, true);
@@ -107,16 +109,16 @@ public class DeckEditorDraft extends DeckEditorBase implements NewConstants, New
         addListeners();
 //    setupMenu();
 
-        List<TableColumnInfo<CardPrinted>> columns = new ArrayList<TableColumnInfo<CardPrinted>>();
+        List<TableColumnInfo<InventoryItem>> columns = new ArrayList<TableColumnInfo<InventoryItem>>();
-        columns.add(new TableColumnInfo<CardPrinted>("Qty", 30, PresetColumns.fnQtyCompare, PresetColumns.fnQtyGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Qty", 30, PresetColumns.fnQtyCompare, PresetColumns.fnQtyGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Name", 180, PresetColumns.fnNameCompare, PresetColumns.fnNameGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Name", 180, PresetColumns.fnNameCompare, PresetColumns.fnNameGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Cost", 70, PresetColumns.fnCostCompare, PresetColumns.fnCostGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Cost", 70, PresetColumns.fnCostCompare, PresetColumns.fnCostGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Color", 50, PresetColumns.fnColorCompare, PresetColumns.fnColorGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Color", 50, PresetColumns.fnColorCompare, PresetColumns.fnColorGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Type", 100, PresetColumns.fnTypeCompare, PresetColumns.fnTypeGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Type", 100, PresetColumns.fnTypeCompare, PresetColumns.fnTypeGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Stats", 40, PresetColumns.fnStatsCompare, PresetColumns.fnStatsGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Stats", 40, PresetColumns.fnStatsCompare, PresetColumns.fnStatsGet));
-        columns.add(new TableColumnInfo<CardPrinted>("R", 35, PresetColumns.fnRarityCompare, PresetColumns.fnRarityGet));
+        columns.add(new TableColumnInfo<InventoryItem>("R", 35, PresetColumns.fnRarityCompare, PresetColumns.fnRarityGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Set", 40, PresetColumns.fnSetCompare, PresetColumns.fnSetGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Set", 40, PresetColumns.fnSetCompare, PresetColumns.fnSetGet));
-        columns.add(new TableColumnInfo<CardPrinted>("AI", 30, PresetColumns.fnAiStatusCompare, PresetColumns.fnAiStatusGet));
+        columns.add(new TableColumnInfo<InventoryItem>("AI", 30, PresetColumns.fnAiStatusCompare, PresetColumns.fnAiStatusGet));
         columns.get(2).setCellRenderer(new ManaCostRenderer());
 
         top.setup(columns, cardView);
@@ -186,8 +188,10 @@ public class DeckEditorDraft extends DeckEditorBase implements NewConstants, New
      * @param e a {@link java.awt.event.ActionEvent} object.
      */
     void jButtonPickClicked(final ActionEvent e) {
-        CardPrinted card = top.getSelectedCard();
+        InventoryItem item = top.getSelectedCard();
-        if (null == card) { return; }
+        if (item == null || !( item instanceof CardPrinted )) { return; }
+
+        CardPrinted card = (CardPrinted) item;
 
         bottom.addCard(card);
 
@@ -224,7 +228,7 @@ public class DeckEditorDraft extends DeckEditorBase implements NewConstants, New
      *
      * @param list a {@link forge.CardList} object.
      */
-    private void showChoices(CardPoolView list) {
+    private void showChoices(CardPoolView<CardPrinted> list) {
         top.setDeck(list);
         cardView.showCard(null);
         top.fixSelection(0);
@@ -240,7 +244,7 @@ public class DeckEditorDraft extends DeckEditorBase implements NewConstants, New
         Constant.Runtime.HumanDeck[0] = deck;
 
         //add sideboard to deck
-        CardPoolView list = bottom.getCards();
+        CardPoolView<CardPrinted> list = CardPool.createFrom(bottom.getCards(), CardPrinted.class);
         deck.addSideboard(list);
         
         String landSet = BoosterDraft.LandSetCode[0];
@@ -293,7 +297,7 @@ public class DeckEditorDraft extends DeckEditorBase implements NewConstants, New
 
 
     @Override
-    protected Predicate<CardPrinted> buildFilter() {
+    protected Predicate<InventoryItem> buildFilter() {
-        return CardPrinted.Predicates.Presets.isTrue;
+        return Predicate.getTrue(InventoryItem.class);
     }
 }

src/main/java/forge/gui/deckeditor/DeckEditorMenu.java

@@ -5,6 +5,7 @@ import forge.CardList;
 import forge.Command;
 import forge.card.CardDb;
 import forge.card.CardPool;
+import forge.card.CardPrinted;
 import forge.deck.Deck;
 import forge.deck.DeckManager;
 import forge.deck.generate.GenerateConstructedDeck;
@@ -146,7 +147,7 @@ public final class DeckEditorMenu extends JMenuBar implements NewConstants {
         // The only remaining reference to global variable!
         CardList random = new CardList(forge.AllZone.getCardFactory().getRandomCombinationWithoutRepetition(15 * 5));
 
-        CardPool cpRandom = new CardPool();
+        CardPool<CardPrinted> cpRandom = new CardPool<CardPrinted>();
         for (Card c : random) { cpRandom.add(CardDb.instance().getCard(c)); }
         cpRandom.add(CardDb.instance().getCard("Forest"));
         cpRandom.add(CardDb.instance().getCard("Island"));
@@ -165,7 +166,7 @@ public final class DeckEditorMenu extends JMenuBar implements NewConstants {
 
         GenerateConstructedDeck gen = new GenerateConstructedDeck();
 
-        CardPool generated = new CardPool();
+        CardPool<CardPrinted> generated = new CardPool<CardPrinted>();
         for (Card c : gen.generateDeck()) { generated.add(CardDb.instance().getCard(c)); }
         deckDisplay.setDeck(null, generated, GameType.Constructed);
     }

src/main/java/forge/gui/deckeditor/DeckEditorQuest.java

@@ -6,6 +6,7 @@ import forge.Singletons;
 import forge.card.CardPool;
 import forge.card.CardPoolView;
 import forge.card.CardPrinted;
+import forge.card.InventoryItem;
 import forge.deck.Deck;
 import forge.error.ErrorViewer;
 import forge.game.GameType;
@@ -97,14 +98,14 @@ public final class DeckEditorQuest extends DeckEditorBase implements NewConstant
         // tell Gui_Quest_DeckEditor the name of the deck
         customMenu.setPlayerDeckName(deck.getName());
 
-        CardPoolView bottomPool = deck.getMain();
+        CardPoolView<CardPrinted> bottomPool = deck.getMain();
-        CardPool cardpool = new CardPool();
+        CardPool<CardPrinted> cardpool = new CardPool<CardPrinted>();
         cardpool.addAll(questData.getCards().getCardpool());
 
         // remove bottom cards that are in the deck from the card pool
         cardpool.removeAll(bottomPool);
 
-        // show cards, makes this user friendly, lol, well may, ha
+        // show cards, makes this user friendly
         setDeck(cardpool, bottomPool, GameType.Quest);
 
         // this affects the card pool
@@ -123,16 +124,16 @@ public final class DeckEditorQuest extends DeckEditorBase implements NewConstant
     public void setup() {
         this.setLayout(null);
         
-        List<TableColumnInfo<CardPrinted>> columns = new ArrayList<TableColumnInfo<CardPrinted>>();
+        List<TableColumnInfo<InventoryItem>> columns = new ArrayList<TableColumnInfo<InventoryItem>>();
-        columns.add(new TableColumnInfo<CardPrinted>("Qty", 30, PresetColumns.fnQtyCompare, PresetColumns.fnQtyGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Qty", 30, PresetColumns.fnQtyCompare, PresetColumns.fnQtyGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Name", 180, PresetColumns.fnNameCompare, PresetColumns.fnNameGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Name", 180, PresetColumns.fnNameCompare, PresetColumns.fnNameGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Cost", 70, PresetColumns.fnCostCompare, PresetColumns.fnCostGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Cost", 70, PresetColumns.fnCostCompare, PresetColumns.fnCostGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Color", 50, PresetColumns.fnColorCompare, PresetColumns.fnColorGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Color", 50, PresetColumns.fnColorCompare, PresetColumns.fnColorGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Type", 100, PresetColumns.fnTypeCompare, PresetColumns.fnTypeGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Type", 100, PresetColumns.fnTypeCompare, PresetColumns.fnTypeGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Stats", 40, PresetColumns.fnStatsCompare, PresetColumns.fnStatsGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Stats", 40, PresetColumns.fnStatsCompare, PresetColumns.fnStatsGet));
-        columns.add(new TableColumnInfo<CardPrinted>("R", 35, PresetColumns.fnRarityCompare, PresetColumns.fnRarityGet));
+        columns.add(new TableColumnInfo<InventoryItem>("R", 35, PresetColumns.fnRarityCompare, PresetColumns.fnRarityGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Set", 40, PresetColumns.fnSetCompare, PresetColumns.fnSetGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Set", 40, PresetColumns.fnSetCompare, PresetColumns.fnSetGet));
-        columns.add(new TableColumnInfo<CardPrinted>("New", 30, questData.getCards().fnNewCompare, questData.getCards().fnNewGet));
+        columns.add(new TableColumnInfo<InventoryItem>("New", 30, questData.getCards().fnNewCompare, questData.getCards().fnNewGet));
 
         columns.get(2).setCellRenderer(new ManaCostRenderer());
 
@@ -282,13 +283,16 @@ public final class DeckEditorQuest extends DeckEditorBase implements NewConstant
 
 
     @Override
-    protected Predicate<CardPrinted> buildFilter() {
+    protected Predicate<InventoryItem> buildFilter() {
-        return Predicate.and(filterBoxes.buildFilter(), filterNameTypeSet.buildFilter());
+        Predicate<CardPrinted> cardFilter = Predicate.and(filterBoxes.buildFilter(), filterNameTypeSet.buildFilter());
+        return Predicate.instanceOf(cardFilter, CardPrinted.class);        
     }    
     
     private  void addButtonActionPerformed(final ActionEvent e) {
-        CardPrinted card = top.getSelectedCard();
+        InventoryItem item = top.getSelectedCard();
-        if (card == null) { return; }
+        if (item == null || !( item instanceof CardPrinted )) { return; }
+
+        CardPrinted card = (CardPrinted) item;
 
         setTitle("Deck Editor : " + customMenu.getDeckName() + " : unsaved");
 
@@ -298,8 +302,10 @@ public final class DeckEditorQuest extends DeckEditorBase implements NewConstant
 
 
     private void removeButtonActionPerformed(final ActionEvent e) {
-        CardPrinted card = bottom.getSelectedCard();
+        InventoryItem item = bottom.getSelectedCard();
-        if (card == null) { return; }
+        if (item == null || !( item instanceof CardPrinted )) { return; }
+
+        CardPrinted card = (CardPrinted) item;
 
         setTitle("Deck Editor : " + customMenu.getDeckName() + " : unsaved");
 

src/main/java/forge/gui/deckeditor/DeckEditorQuestMenu.java

@@ -8,6 +8,7 @@ import forge.card.CardDb;
 import forge.card.CardPool;
 import forge.card.CardPoolView;
 import forge.card.CardPrinted;
+import forge.card.InventoryItem;
 import forge.deck.Deck;
 import forge.deck.DeckManager;
 import forge.error.ErrorViewer;
@@ -170,7 +171,7 @@ public class DeckEditorQuestMenu extends JMenuBar {
      */
     private String getExportDeckText(final Deck aDeck) {
         //convert Deck into CardList
-        CardPoolView all = aDeck.getMain();
+        CardPoolView<CardPrinted> all = aDeck.getMain();
         //sort by card name
         Collections.sort(all.getOrderedList(), TableSorter.byNameThenSet);
 
@@ -180,20 +181,21 @@ public class DeckEditorQuestMenu extends JMenuBar {
         sb.append(String.format("%d Total Cards%n%n", all.countAll()));
 
         //creatures
-        sb.append(String.format("%d Creatures%n-------------%n", CardRules.Predicates.Presets.isCreature.aggregate(all, CardPoolView.fnToCard, CardPoolView.fnToCount)));
+        
-        for (Entry<CardPrinted, Integer> e : CardRules.Predicates.Presets.isCreature.select(all, CardPoolView.fnToCard)) {
+        sb.append(String.format("%d Creatures%n-------------%n", CardRules.Predicates.Presets.isCreature.aggregate(all, all.fnToCard, all.fnToCount)));
+        for (Entry<CardPrinted, Integer> e : CardRules.Predicates.Presets.isCreature.select(all, all.fnToCard)) {
             sb.append(String.format("%d x %s%n", e.getValue(), e.getKey().getName()));
         }
 
         //spells
-        sb.append(String.format("%d Spells%n----------%n", CardRules.Predicates.Presets.isNonCreatureSpell.aggregate(all, CardPoolView.fnToCard, CardPoolView.fnToCount)));
+        sb.append(String.format("%d Spells%n----------%n", CardRules.Predicates.Presets.isNonCreatureSpell.aggregate(all, all.fnToCard, all.fnToCount)));
-        for (Entry<CardPrinted, Integer> e : CardRules.Predicates.Presets.isNonCreatureSpell.select(all, CardPoolView.fnToCard)) {
+        for (Entry<CardPrinted, Integer> e : CardRules.Predicates.Presets.isNonCreatureSpell.select(all, all.fnToCard)) {
             sb.append(String.format("%d x %s%n", e.getValue(), e.getKey().getName()));
         }
 
         //lands
-        sb.append(String.format("%d Land%n--------%n", CardRules.Predicates.Presets.isLand.aggregate(all, CardPoolView.fnToCard, CardPoolView.fnToCount)));
+        sb.append(String.format("%d Land%n--------%n", CardRules.Predicates.Presets.isLand.aggregate(all, all.fnToCard, all.fnToCount)));
-        for (Entry<CardPrinted, Integer> e : CardRules.Predicates.Presets.isLand.select(all, CardPoolView.fnToCard)) {
+        for (Entry<CardPrinted, Integer> e : CardRules.Predicates.Presets.isLand.select(all, all.fnToCard)) {
             sb.append(String.format("%d x %s%n", e.getValue(), e.getKey().getName()));
         }
 
@@ -268,8 +270,8 @@ public class DeckEditorQuestMenu extends JMenuBar {
                 Deck newDeck = DeckManager.readDeck(file);
                 questData.addDeck(newDeck);
 
-                CardPool cardpool = new CardPool(questData.getCards().getCardpool());
+                CardPool<CardPrinted> cardpool = CardPool.createFrom(questData.getCards().getCardpool(), CardPrinted.class);
-                CardPool decklist = new CardPool();
+                CardPool<CardPrinted> decklist = new CardPool<CardPrinted>();
                 for (Entry<CardPrinted, Integer> s : newDeck.getMain()) {
                     CardPrinted cp = s.getKey();
                     decklist.add(cp, s.getValue());
@@ -335,8 +337,8 @@ public class DeckEditorQuestMenu extends JMenuBar {
             if (StringUtils.isBlank(deckName)) { return; }
 
             setPlayerDeckName(deckName);
-            CardPool cards = new CardPool(questData.getCards().getCardpool().getView());
+            CardPool<CardPrinted> cards = CardPool.createFrom(questData.getCards().getCardpool().getView(), CardPrinted.class);
-            CardPoolView deck = questData.getDeck(deckName).getMain();
+            CardPoolView<CardPrinted> deck = questData.getDeck(deckName).getMain();
 
             // show in pool all cards except ones used in deck
             cards.removeAll(deck);
@@ -346,7 +348,7 @@ public class DeckEditorQuestMenu extends JMenuBar {
 
     private final ActionListener newDeckActionListener = new ActionListener() {
         public void actionPerformed(final ActionEvent a) {
-            deckDisplay.setDeck(questData.getCards().getCardpool().getView(), new CardPool(), GameType.Quest);
+            deckDisplay.setDeck(questData.getCards().getCardpool().getView(), null, GameType.Quest);
             setPlayerDeckName("");
         }
     };
@@ -429,7 +431,7 @@ public class DeckEditorQuestMenu extends JMenuBar {
             questData.removeDeck(currentDeck.getName());
 
             //show card pool
-            deckDisplay.setDeck(questData.getCards().getCardpool().getView(), new CardPool(), GameType.Quest);
+            deckDisplay.setDeck(questData.getCards().getCardpool().getView(), null, GameType.Quest);
 
             setPlayerDeckName("");
         }
@@ -497,10 +499,10 @@ public class DeckEditorQuestMenu extends JMenuBar {
      * @param list a {@link forge.CardPool} object.
      * @return a {@link forge.deck.Deck} object.
      */
-    private Deck cardPoolToDeck(final CardPoolView list) {
+    private Deck cardPoolToDeck(final CardPoolView<InventoryItem> list) {
         //put CardPool into Deck main
         Deck deck = new Deck(GameType.Sealed);
-        deck.addMain(list);
+        deck.addMain(CardPool.createFrom(list, CardPrinted.class));
         return deck;
     }
 

src/main/java/forge/gui/deckeditor/DeckEditorShop.java

@@ -24,6 +24,7 @@ import forge.ReadPriceList;
 import forge.Singletons;
 import forge.card.CardPoolView;
 import forge.card.CardPrinted;
+import forge.card.InventoryItem;
 import forge.deck.Deck;
 import forge.error.ErrorViewer;
 import forge.game.GameType;
@@ -87,12 +88,12 @@ public final class DeckEditorShop extends DeckEditorBase {
 
         multiplier = questData.getCards().getSellMutliplier();
 
-        CardPoolView forSale = questData.getCards().getShopList();
+        CardPoolView<CardPrinted> forSale = questData.getCards().getShopList();
         if (forSale.isEmpty()) {
             questData.getCards().generateCardsInShop();
             forSale = questData.getCards().getShopList();
         }
-        CardPoolView owned = questData.getCards().getCardpool().getView();
+        CardPoolView<CardPrinted> owned = questData.getCards().getCardpool().getView();
         //newCardsList = questData.getCards().getNewCards();
 
         setDeck(forSale, owned, GameType.Quest);
@@ -130,24 +131,24 @@ public final class DeckEditorShop extends DeckEditorBase {
      * </p>
      */
     private void setup() {
-        List<TableColumnInfo<CardPrinted>> columns = new ArrayList<TableColumnInfo<CardPrinted>>();
+        List<TableColumnInfo<InventoryItem>> columns = new ArrayList<TableColumnInfo<InventoryItem>>();
-        columns.add(new TableColumnInfo<CardPrinted>("Qty", 30, PresetColumns.fnQtyCompare, PresetColumns.fnQtyGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Qty", 30, PresetColumns.fnQtyCompare, PresetColumns.fnQtyGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Name", 180, PresetColumns.fnNameCompare, PresetColumns.fnNameGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Name", 180, PresetColumns.fnNameCompare, PresetColumns.fnNameGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Cost", 70, PresetColumns.fnCostCompare, PresetColumns.fnCostGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Cost", 70, PresetColumns.fnCostCompare, PresetColumns.fnCostGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Color", 50, PresetColumns.fnColorCompare, PresetColumns.fnColorGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Color", 50, PresetColumns.fnColorCompare, PresetColumns.fnColorGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Type", 100, PresetColumns.fnTypeCompare, PresetColumns.fnTypeGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Type", 100, PresetColumns.fnTypeCompare, PresetColumns.fnTypeGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Stats", 40, PresetColumns.fnStatsCompare, PresetColumns.fnStatsGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Stats", 40, PresetColumns.fnStatsCompare, PresetColumns.fnStatsGet));
-        columns.add(new TableColumnInfo<CardPrinted>("R", 30, PresetColumns.fnRarityCompare, PresetColumns.fnRarityGet));
+        columns.add(new TableColumnInfo<InventoryItem>("R", 30, PresetColumns.fnRarityCompare, PresetColumns.fnRarityGet));
-        columns.add(new TableColumnInfo<CardPrinted>("Set", 35, PresetColumns.fnSetCompare, PresetColumns.fnSetGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Set", 35, PresetColumns.fnSetCompare, PresetColumns.fnSetGet));
         columns.get(2).setCellRenderer(new ManaCostRenderer());
         
-        List<TableColumnInfo<CardPrinted>> columnsBelow = new ArrayList<TableColumnInfo<CardPrinted>>(columns);
+        List<TableColumnInfo<InventoryItem>> columnsBelow = new ArrayList<TableColumnInfo<InventoryItem>>(columns);
-        columns.add(new TableColumnInfo<CardPrinted>("Price", 40, fnPriceCompare, fnPriceGet));
+        columns.add(new TableColumnInfo<InventoryItem>("Price", 40, fnPriceCompare, fnPriceGet));
         top.setup(columns, cardView);
 
-        columnsBelow.add(new TableColumnInfo<CardPrinted>("#Dk", 30, fnDeckCompare, fnDeckGet));
+        columnsBelow.add(new TableColumnInfo<InventoryItem>("#Dk", 30, fnDeckCompare, fnDeckGet));
-        columnsBelow.add(new TableColumnInfo<CardPrinted>("New", 30, questData.getCards().fnNewCompare, questData.getCards().fnNewGet));
+        columnsBelow.add(new TableColumnInfo<InventoryItem>("New", 30, questData.getCards().fnNewCompare, questData.getCards().fnNewGet));
-        columnsBelow.add(new TableColumnInfo<CardPrinted>("Price", 40, fnPriceCompare, fnPriceGet));
+        columnsBelow.add(new TableColumnInfo<InventoryItem>("Price", 40, fnPriceCompare, fnPriceGet));
         bottom.setup(columnsBelow, cardView);
 
         this.setSize(1024, 768);
@@ -240,11 +241,11 @@ public final class DeckEditorShop extends DeckEditorBase {
     }
 
     // TODO: move to cardshop
-    private Integer getCardValue(final CardPrinted card) {
+    private Integer getCardValue(final InventoryItem card) {
         if (mapPrices.containsKey(card.getName())) {
             return mapPrices.get(card.getName());
-        } else {
+        } else if (card instanceof CardPrinted)  {
-            switch (card.getRarity()) {
+            switch (((CardPrinted) card).getRarity()) {
             case BasicLand: return Integer.valueOf(4);
             case Common: return Integer.valueOf(6);
             case Uncommon: return Integer.valueOf(40);
@@ -253,19 +254,22 @@ public final class DeckEditorShop extends DeckEditorBase {
             default: return Integer.valueOf(15);
             }
         }
+        return 1337;
     }
 
     private void buyButton_actionPerformed(ActionEvent e) {
-        CardPrinted c = top.getSelectedCard();
+        InventoryItem item = top.getSelectedCard();
-        if (c == null) { return; }
+        if (item == null || !( item instanceof CardPrinted )) { return; }
 
-        int value = getCardValue(c);
+        CardPrinted card = (CardPrinted) item;
+
+        int value = getCardValue(card);
 
         if (value <= questData.getCredits()) {
-            bottom.addCard(c);
+            bottom.addCard(card);
-            top.removeCard(c);
+            top.removeCard(card);
 
-            questData.getCards().buyCard(c, value);
+            questData.getCards().buyCard(card, value);
 
             creditsLabel.setText("Total credits: " + questData.getCredits());
         } else {
@@ -274,41 +278,42 @@ public final class DeckEditorShop extends DeckEditorBase {
     }
 
     @Override
-    protected Predicate<CardPrinted> buildFilter() {
+    protected Predicate<InventoryItem> buildFilter() {
-        return CardPrinted.Predicates.Presets.isTrue;
+        return Predicate.getTrue(InventoryItem.class);
     }
 
     private void sellButton_actionPerformed(ActionEvent e) {
-        CardPrinted c = bottom.getSelectedCard();
+        InventoryItem item = bottom.getSelectedCard();
-        if (c == null) { return; }
+        if (item == null || !( item instanceof CardPrinted )) { return; }
 
-        bottom.removeCard(c);
+        CardPrinted card = (CardPrinted) item;
-        top.addCard(c);
+        bottom.removeCard(card);
+        top.addCard(card);
 
-        int price = Math.min((int) (multiplier * getCardValue(c)), questData.getCards().getSellPriceLimit());
+        int price = Math.min((int) (multiplier * getCardValue(card)), questData.getCards().getSellPriceLimit());
-        questData.getCards().sellCard(c, price);
+        questData.getCards().sellCard(card, price);
 
         creditsLabel.setText("Total credits: " + questData.getCredits());
     }
 
     @SuppressWarnings("rawtypes")
-    private final Lambda1<Comparable, Entry<CardPrinted, Integer>> fnPriceCompare =
+    private final Lambda1<Comparable, Entry<InventoryItem, Integer>> fnPriceCompare =
-        new Lambda1<Comparable, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Comparable, Entry<InventoryItem, Integer>>() { @Override
-            public Comparable apply(final Entry<CardPrinted, Integer> from) { return getCardValue(from.getKey()); } };
+            public Comparable apply(final Entry<InventoryItem, Integer> from) { return getCardValue(from.getKey()); } };
-    private final Lambda1<Object, Entry<CardPrinted, Integer>> fnPriceGet =
+    private final Lambda1<Object, Entry<InventoryItem, Integer>> fnPriceGet =
-        new Lambda1<Object, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Object, Entry<InventoryItem, Integer>>() { @Override
-            public Object apply(final Entry<CardPrinted, Integer> from) { return getCardValue(from.getKey()); } };
+            public Object apply(final Entry<InventoryItem, Integer> from) { return getCardValue(from.getKey()); } };
 
     @SuppressWarnings("rawtypes")
-    private final Lambda1<Comparable, Entry<CardPrinted, Integer>> fnDeckCompare =
+    private final Lambda1<Comparable, Entry<InventoryItem, Integer>> fnDeckCompare =
-        new Lambda1<Comparable, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Comparable, Entry<InventoryItem, Integer>>() { @Override
-            public Comparable apply(final Entry<CardPrinted, Integer> from) {
+            public Comparable apply(final Entry<InventoryItem, Integer> from) {
                 Integer iValue = decksUsingMyCards.get(from.getKey());
                 return iValue == null ? Integer.valueOf(0) : iValue;
             } };
-    private final Lambda1<Object, Entry<CardPrinted, Integer>> fnDeckGet =
+    private final Lambda1<Object, Entry<InventoryItem, Integer>> fnDeckGet =
-        new Lambda1<Object, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Object, Entry<InventoryItem, Integer>>() { @Override
-            public Object apply(final Entry<CardPrinted, Integer> from) {
+            public Object apply(final Entry<InventoryItem, Integer> from) {
                 Integer iValue = decksUsingMyCards.get(from.getKey());
                 return iValue == null ? "" : iValue.toString();
             } };

src/main/java/forge/gui/deckeditor/PresetColumns.java

@@ -4,7 +4,12 @@ import java.util.Map.Entry;
 
 import net.slightlymagic.braids.util.lambda.Lambda1;
 import forge.SetUtils;
+import forge.card.CardColor;
+import forge.card.CardManaCost;
 import forge.card.CardPrinted;
+import forge.card.CardRarity;
+import forge.card.CardSet;
+import forge.card.InventoryItem;
 
 /** 
  * TODO: Write javadoc for this type.
@@ -12,75 +17,85 @@ import forge.card.CardPrinted;
  */
 public abstract class PresetColumns {
 
-    @SuppressWarnings("rawtypes")
+    private static CardManaCost toManaCost(InventoryItem i) { return i instanceof CardPrinted ? ((CardPrinted) i).getCard().getManaCost() : CardManaCost.empty; }
-    public static final Lambda1<Comparable, Entry<CardPrinted, Integer>> fnQtyCompare =
+    private static CardColor toColor(InventoryItem i) { return i instanceof CardPrinted ? ((CardPrinted) i).getCard().getColor() : CardColor.nullColor; }
-        new Lambda1<Comparable, Entry<CardPrinted, Integer>>() { @Override
+    private static String toType(InventoryItem i) { return i instanceof CardPrinted ? ((CardPrinted) i).getCard().getType().toString() : i.getClass().toString(); }
-            public Comparable apply(final Entry<CardPrinted, Integer> from) { return from.getValue(); } };
+    private static String toPTL(InventoryItem i) { return i instanceof CardPrinted ? ((CardPrinted) i).getCard().getPTorLoyalty() : ""; }
-    public static final Lambda1<Object, Entry<CardPrinted, Integer>> fnQtyGet =
+    private static CardRarity toRarity(InventoryItem i) { return i instanceof CardPrinted ? ((CardPrinted) i).getRarity() : CardRarity.Unknown; }
-        new Lambda1<Object, Entry<CardPrinted, Integer>>() { @Override
+    private static CardSet toSetCmp(InventoryItem i) { return i instanceof CardPrinted ? SetUtils.getSetByCode(((CardPrinted) i).getSet()) : CardSet.unknown; }
-            public Object apply(final Entry<CardPrinted, Integer> from) { return from.getValue(); } };
+    private static String toSetStr(InventoryItem i) { return i instanceof CardPrinted ? ((CardPrinted) i).getSet() : "n/a"; }
+    private static Integer toAiCmp(InventoryItem i) { return i instanceof CardPrinted ? ((CardPrinted) i).getCard().getAiStatusComparable() : Integer.valueOf(-1); }
+    private static String toAiStr(InventoryItem i) { return i instanceof CardPrinted ? ((CardPrinted) i).getCard().getAiStatus() : "n/a"; }
     
     @SuppressWarnings("rawtypes")
-    public static final Lambda1<Comparable, Entry<CardPrinted, Integer>> fnNameCompare =
+    public static final Lambda1<Comparable, Entry<InventoryItem, Integer>> fnQtyCompare =
-        new Lambda1<Comparable, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Comparable, Entry<InventoryItem, Integer>>() { @Override
-            public Comparable apply(final Entry<CardPrinted, Integer> from) { return from.getKey().getName(); } };
+            public Comparable apply(final Entry<InventoryItem, Integer> from) { return from.getValue(); } };
-    public static final Lambda1<Object, Entry<CardPrinted, Integer>> fnNameGet =
+    public static final Lambda1<Object, Entry<InventoryItem, Integer>> fnQtyGet =
-        new Lambda1<Object, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Object, Entry<InventoryItem, Integer>>() { @Override
-            public Object apply(final Entry<CardPrinted, Integer> from) { return from.getKey().getName(); } };
+            public Object apply(final Entry<InventoryItem, Integer> from) { return from.getValue(); } };
 
     @SuppressWarnings("rawtypes")
-    public static final Lambda1<Comparable, Entry<CardPrinted, Integer>> fnCostCompare =
+    public static final Lambda1<Comparable, Entry<InventoryItem, Integer>> fnNameCompare =
-        new Lambda1<Comparable, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Comparable, Entry<InventoryItem, Integer>>() { @Override
-            public Comparable apply(final Entry<CardPrinted, Integer> from) { return from.getKey().getCard().getManaCost(); } };
+            public Comparable apply(final Entry<InventoryItem, Integer> from) { return from.getKey().getName(); } };
-    public static final Lambda1<Object, Entry<CardPrinted, Integer>> fnCostGet =
+    public static final Lambda1<Object, Entry<InventoryItem, Integer>> fnNameGet =
-        new Lambda1<Object, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Object, Entry<InventoryItem, Integer>>() { @Override
-            public Object apply(final Entry<CardPrinted, Integer> from) { return from.getKey().getCard().getManaCost(); } };
+            public Object apply(final Entry<InventoryItem, Integer> from) { return from.getKey().getName(); } };
 
     @SuppressWarnings("rawtypes")
-    public static final Lambda1<Comparable, Entry<CardPrinted, Integer>> fnColorCompare =
+    public static final Lambda1<Comparable, Entry<InventoryItem, Integer>> fnCostCompare =
-        new Lambda1<Comparable, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Comparable, Entry<InventoryItem, Integer>>() { @Override
-            public Comparable apply(final Entry<CardPrinted, Integer> from) { return from.getKey().getCard().getColor(); } };
+            public Comparable apply(final Entry<InventoryItem, Integer> from) { return toManaCost(from.getKey()); } };
-    public static final Lambda1<Object, Entry<CardPrinted, Integer>> fnColorGet =
+    public static final Lambda1<Object, Entry<InventoryItem, Integer>> fnCostGet =
-        new Lambda1<Object, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Object, Entry<InventoryItem, Integer>>() { @Override
-            public Object apply(final Entry<CardPrinted, Integer> from) { return from.getKey().getCard().getColor().toString(); } };
+            public Object apply(final Entry<InventoryItem, Integer> from) { return toManaCost(from.getKey()); } };
 
     @SuppressWarnings("rawtypes")
-    public static final Lambda1<Comparable, Entry<CardPrinted, Integer>> fnTypeCompare =
+    public static final Lambda1<Comparable, Entry<InventoryItem, Integer>> fnColorCompare =
-       new Lambda1<Comparable, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Comparable, Entry<InventoryItem, Integer>>() { @Override
-            public Comparable apply(final Entry<CardPrinted, Integer> from) { return from.getKey().getCard().getType(); } };
+            public Comparable apply(final Entry<InventoryItem, Integer> from) { return toColor(from.getKey()); } };
-   public static final Lambda1<Object, Entry<CardPrinted, Integer>> fnTypeGet =
+    public static final Lambda1<Object, Entry<InventoryItem, Integer>> fnColorGet =
-       new Lambda1<Object, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Object, Entry<InventoryItem, Integer>>() { @Override
-            public Object apply(final Entry<CardPrinted, Integer> from) { return from.getKey().getCard().getType().toString(); } };
+            public Object apply(final Entry<InventoryItem, Integer> from) { return toColor(from.getKey()); } };
 
     @SuppressWarnings("rawtypes")
-    public static final Lambda1<Comparable, Entry<CardPrinted, Integer>> fnStatsCompare =
+    public static final Lambda1<Comparable, Entry<InventoryItem, Integer>> fnTypeCompare =
-        new Lambda1<Comparable, Entry<CardPrinted, Integer>>() { @Override
+       new Lambda1<Comparable, Entry<InventoryItem, Integer>>() { @Override
-            public Comparable apply(final Entry<CardPrinted, Integer> from) { return from.getKey().getCard().getPTorLoyalty(); } };
+            public Comparable apply(final Entry<InventoryItem, Integer> from) { return toType(from.getKey()); } };
-    public static final Lambda1<Object, Entry<CardPrinted, Integer>> fnStatsGet =
+   public static final Lambda1<Object, Entry<InventoryItem, Integer>> fnTypeGet =
-        new Lambda1<Object, Entry<CardPrinted, Integer>>() { @Override
+       new Lambda1<Object, Entry<InventoryItem, Integer>>() { @Override
-            public Object apply(final Entry<CardPrinted, Integer> from) { return from.getKey().getCard().getPTorLoyalty(); } };
+            public Object apply(final Entry<InventoryItem, Integer> from) { return toType(from.getKey()); } };
 
     @SuppressWarnings("rawtypes")
-    public static final Lambda1<Comparable, Entry<CardPrinted, Integer>> fnRarityCompare =
+    public static final Lambda1<Comparable, Entry<InventoryItem, Integer>> fnStatsCompare =
-        new Lambda1<Comparable, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Comparable, Entry<InventoryItem, Integer>>() { @Override
-            public Comparable apply(final Entry<CardPrinted, Integer> from) { return from.getKey().getRarity(); } };
+            public Comparable apply(final Entry<InventoryItem, Integer> from) { return toPTL(from.getKey()); } };
-    public static final Lambda1<Object, Entry<CardPrinted, Integer>> fnRarityGet =
+    public static final Lambda1<Object, Entry<InventoryItem, Integer>> fnStatsGet =
-        new Lambda1<Object, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Object, Entry<InventoryItem, Integer>>() { @Override
-            public Object apply(final Entry<CardPrinted, Integer> from) { return from.getKey().getRarity(); } };
+            public Object apply(final Entry<InventoryItem, Integer> from) { return toPTL(from.getKey()); } };
 
     @SuppressWarnings("rawtypes")
-    public static final Lambda1<Comparable, Entry<CardPrinted, Integer>> fnSetCompare =
+    public static final Lambda1<Comparable, Entry<InventoryItem, Integer>> fnRarityCompare =
-        new Lambda1<Comparable, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Comparable, Entry<InventoryItem, Integer>>() { @Override
-            public Comparable apply(final Entry<CardPrinted, Integer> from) { return SetUtils.getSetByCode(from.getKey().getSet()); } };
+            public Comparable apply(final Entry<InventoryItem, Integer> from) { return toRarity(from.getKey()); } };
-    public static final Lambda1<Object, Entry<CardPrinted, Integer>> fnSetGet =
+    public static final Lambda1<Object, Entry<InventoryItem, Integer>> fnRarityGet =
-        new Lambda1<Object, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Object, Entry<InventoryItem, Integer>>() { @Override
-            public Object apply(final Entry<CardPrinted, Integer> from) { return from.getKey().getSet(); } };
+            public Object apply(final Entry<InventoryItem, Integer> from) { return toRarity(from.getKey()); } };
 
     @SuppressWarnings("rawtypes")
-    public static final Lambda1<Comparable, Entry<CardPrinted, Integer>> fnAiStatusCompare =
+    public static final Lambda1<Comparable, Entry<InventoryItem, Integer>> fnSetCompare =
-        new Lambda1<Comparable, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Comparable, Entry<InventoryItem, Integer>>() { @Override
-            public Comparable apply(final Entry<CardPrinted, Integer> from) { return from.getKey().getCard().getAiStatusComparable(); } };
+            public Comparable apply(final Entry<InventoryItem, Integer> from) { return toSetCmp(from.getKey()); } };
-    public static final Lambda1<Object, Entry<CardPrinted, Integer>> fnAiStatusGet =
+    public static final Lambda1<Object, Entry<InventoryItem, Integer>> fnSetGet =
-        new Lambda1<Object, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Object, Entry<InventoryItem, Integer>>() { @Override
-            public Object apply(final Entry<CardPrinted, Integer> from) { return from.getKey().getCard().getAiStatus(); } };
+            public Object apply(final Entry<InventoryItem, Integer> from) { return toSetStr(from.getKey()); } };
+
+    @SuppressWarnings("rawtypes")
+    public static final Lambda1<Comparable, Entry<InventoryItem, Integer>> fnAiStatusCompare =
+        new Lambda1<Comparable, Entry<InventoryItem, Integer>>() { @Override
+            public Comparable apply(final Entry<InventoryItem, Integer> from) { return toAiCmp(from.getKey()); } };
+    public static final Lambda1<Object, Entry<InventoryItem, Integer>> fnAiStatusGet =
+        new Lambda1<Object, Entry<InventoryItem, Integer>>() { @Override
+            public Object apply(final Entry<InventoryItem, Integer> from) { return toAiStr(from.getKey()); } };
 }

src/main/java/forge/gui/deckeditor/TableModel.java

@@ -11,9 +11,10 @@ import javax.swing.table.TableColumnModel;
 
 import forge.card.CardPool;
 import forge.card.CardPoolView;
-import forge.card.CardPrinted;
+import forge.card.InventoryItem;
 
 import java.awt.event.*;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map.Entry;
@@ -25,7 +26,7 @@ import java.util.Map.Entry;
  * @author Forge
  * @version $Id$
  */
-public final class TableModel extends AbstractTableModel {
+public final class TableModel<T extends InventoryItem> extends AbstractTableModel {
     /**
      * 
      */
@@ -39,13 +40,13 @@ public final class TableModel extends AbstractTableModel {
         };
 
         private final int MAX_DEPTH = 3;
-        private Order[] orders = new Order[] {null, null, null};
+        private List<Order> orders = new ArrayList<Order>(3);
-        private TableSorterCascade sorter = null;
+        private TableSorterCascade<T> sorter = null;
         private boolean isSorterReady = false;
         private int indexOfColumn(final int column) {
-            int posColumn = orders.length - 1;
+            int posColumn = orders.size() - 1;
             for (; posColumn >= 0; posColumn--) {
-                if (orders[posColumn] != null && orders[posColumn].sortColumn == column) {
+                if (orders.get(posColumn) != null && orders.get(posColumn).sortColumn == column) {
                     break;
                 }
             }
@@ -55,7 +56,7 @@ public final class TableModel extends AbstractTableModel {
         // index of column to sort by, desired direction
         public void add(final int column, final boolean wantAsc) {
             add(column);
-            orders[0].isSortAsc = wantAsc;
+            orders.get(0).isSortAsc = wantAsc;
             isSorterReady = false;
         }
 
@@ -64,43 +65,38 @@ public final class TableModel extends AbstractTableModel {
             int posColumn = indexOfColumn(column);
             switch (posColumn) {
                 case -1: // no such column here - let's add then
-                    System.arraycopy(orders, 0, orders, 1, MAX_DEPTH - 1);
+                    orders.add(0, new Order(column));
-                    orders[0] = new Order(column);
                     break;
                 case 0: // found at top-level, should invert
-                    orders[0].isSortAsc ^= true; // invert
+                    orders.get(0).isSortAsc ^= true; // invert
                     break;
                 default: // found somewhere, move down others, set this one onto top;
-                    System.arraycopy(orders, 0, orders, 1, posColumn);
+                    orders.remove(posColumn);
-                    orders[0] = new Order(column);
+                    orders.add(0, new Order(column));
                     break;
             }
+            if(orders.size() > MAX_DEPTH) { orders.remove(MAX_DEPTH); } 
             isSorterReady = false;
         }
 
-        public TableSorterCascade getSorter() {
+        public TableSorterCascade<T> getSorter() {
             if (!isSorterReady) {
-                TableSorter[] oneColSorters = new TableSorter[MAX_DEPTH];
+                List<TableSorter<T>> oneColSorters = new ArrayList<TableSorter<T>>(MAX_DEPTH);
-                for (int i = 0; i < orders.length; i++) {
+                for (Order order : orders) {
-                    Order order = orders[i];
+                    oneColSorters.add(new TableSorter<T>(columns.get(order.sortColumn).fnSort, order.isSortAsc));
-                    if (order == null) {
-                        oneColSorters[i] = null;
-                    } else {
-                        oneColSorters[i] = new TableSorter(columns.get(order.sortColumn).fnSort, order.isSortAsc);
-                    }
                 }
-                sorter = new TableSorterCascade(oneColSorters);
+                sorter = new TableSorterCascade<T>(oneColSorters);
             }
             return sorter;
         }
     }
 
-    private CardPool data = new CardPool();
+    private CardPool<T> data = new CardPool<T>();
     private final CardPanelBase cardDisplay;
-    private final List<TableColumnInfo<CardPrinted>> columns;
+    private final List<TableColumnInfo<T>> columns;
     private final SortOrders sortOrders = new SortOrders();
 
-    public TableModel(final CardPanelBase cd, final List<TableColumnInfo<CardPrinted>> columnsToShow) {
+    public TableModel(final CardPanelBase cd, final List<TableColumnInfo<T>> columnsToShow) {
         cardDisplay = cd;
         columns = columnsToShow;
         columns.get(4).isMinMaxApplied = false;
@@ -111,7 +107,7 @@ public final class TableModel extends AbstractTableModel {
         TableColumn tableColumn = null;
         for (int i = 0; i < table.getColumnCount(); i++) {
             tableColumn = table.getColumnModel().getColumn(i);
-            TableColumnInfo<CardPrinted> colInfo = columns.get(i);
+            TableColumnInfo<T> colInfo = columns.get(i);
 
             tableColumn.setPreferredWidth(colInfo.nominalWidth);
             if (colInfo.isMinMaxApplied) {
@@ -122,14 +118,14 @@ public final class TableModel extends AbstractTableModel {
     }
 
     public void clear() { data.clear(); }
-    public CardPoolView getCards() { return data.getView(); }
+    public CardPoolView<T> getCards() { return data.getView(); }
 
     /**
      * <p>removeCard.</p>
      *
      * @param c a {@link forge.Card} object.
      */
-    public void removeCard(final CardPrinted c) {
+    public void removeCard(final T c) {
         boolean wasThere = data.count(c) > 0;
         if (wasThere) {
             data.remove(c);
@@ -138,29 +134,29 @@ public final class TableModel extends AbstractTableModel {
     }
 
 
-    public void addCard(final CardPrinted c) {
+    public void addCard(final T c) {
         data.add(c);
         fireTableDataChanged();
     }
-    public void addCard(final CardPrinted c, final int count) {
+    public void addCard(final T c, final int count) {
         data.add(c, count);
         fireTableDataChanged();
     }
-    public void addCard(final Entry<CardPrinted, Integer> e) {
+    public void addCard(final Entry<T, Integer> e) {
         data.add(e.getKey(), e.getValue());
         fireTableDataChanged();
     }
-    public void addCards(final Iterable<Entry<CardPrinted, Integer>> c) {
+    public void addCards(final Iterable<Entry<T, Integer>> c) {
         data.addAll(c);
         fireTableDataChanged();
     }
-    public void addAllCards(final Iterable<CardPrinted> c) {
+    public void addAllCards(final Iterable<T> c) {
         data.addAllCards(c);
         fireTableDataChanged();
     }
 
-    public Entry<CardPrinted, Integer> rowToCard(final int row) {
+    public Entry<T, Integer> rowToCard(final int row) {
-        List<Entry<CardPrinted, Integer>> model = data.getOrderedList();
+        List<Entry<T, Integer>> model = data.getOrderedList();
         return row >= 0 && row < model.size() ? model.get(row) : null;
     }
     public int getRowCount() {
@@ -213,7 +209,7 @@ public final class TableModel extends AbstractTableModel {
     public void showSelectedCard(final JTable table) {
         int row = table.getSelectedRow();
         if (row != -1) {
-            CardPrinted cp = rowToCard(row).getKey();
+            T cp = rowToCard(row).getKey();
             cardDisplay.showCard(cp);
         }
     }

src/main/java/forge/gui/deckeditor/TableSorter.java

@@ -14,10 +14,10 @@ import net.slightlymagic.braids.util.lambda.Lambda1;
  * @version $Id$
  */
 @SuppressWarnings("unchecked") // Comparable needs <type>
-public class TableSorter implements Comparator<Entry<CardPrinted, Integer>> {
+public class TableSorter<T> implements Comparator<Entry<T, Integer>> {
     private boolean ascending;
     @SuppressWarnings("rawtypes")
-    private Lambda1<Comparable,  Entry<CardPrinted, Integer>> field;
+    private Lambda1<Comparable, Entry<T, Integer>> field;
 
     /**
      * <p>Constructor for TableSorter.</p>
@@ -27,20 +27,20 @@ public class TableSorter implements Comparator<Entry<CardPrinted, Integer>> {
      * @param in_ascending a boolean.
      */
     @SuppressWarnings("rawtypes")
-    public TableSorter(Lambda1<Comparable, Entry<CardPrinted, Integer>> field, boolean in_ascending) {
+    public TableSorter(Lambda1<Comparable, Entry<T, Integer>> field, boolean in_ascending) {
         this.field = field;
         ascending = in_ascending;
     }
 
     @SuppressWarnings("rawtypes")
-    public static final TableSorter byNameThenSet = new TableSorter(
+    public static final TableSorter<CardPrinted> byNameThenSet = new TableSorter<CardPrinted>(
         new Lambda1<Comparable, Entry<CardPrinted, Integer>>() {
         @Override public Comparable apply(final Entry<CardPrinted, Integer> from) { return from.getKey(); }
         }, true);
 
     @SuppressWarnings("rawtypes")
     @Override
-    public int compare(Entry<CardPrinted, Integer> arg0, Entry<CardPrinted, Integer> arg1) {
+    public int compare(Entry<T, Integer> arg0, Entry<T, Integer> arg1) {
         Comparable obj1 = field.apply(arg0);
         Comparable obj2 = field.apply(arg1);
         //System.out.println(String.format("%s vs %s _______ %s vs %s", arg0, arg1, obj1, obj2));

src/main/java/forge/gui/deckeditor/TableSorterCascade.java

@@ -1,6 +1,7 @@
 package forge.gui.deckeditor;
 
-import forge.card.CardPrinted;
+import forge.card.InventoryItem;
+
 import java.util.Comparator;
 import java.util.List;
 import java.util.Map.Entry;
@@ -11,26 +12,21 @@ import java.util.Map.Entry;
  * @author Forge
  * @version $Id: TableSorter.java 10146 2011-09-01 18:11:00Z Max mtg $
  */
-public class TableSorterCascade implements Comparator<Entry<CardPrinted, Integer>> {
+public class TableSorterCascade<T extends InventoryItem> implements Comparator<Entry<T, Integer>> {
-    private TableSorter[] sorters;
+    private List<TableSorter<T>> sorters;
     private final int cntFields;
-    private static final TableSorter[] EMPTY_SORTER_ARRAY = new TableSorter[0];
 
-    public TableSorterCascade(final List<TableSorter> sortersCascade) {
+    public TableSorterCascade(final List<TableSorter<T>> sortersCascade) {
-        this(sortersCascade.toArray(EMPTY_SORTER_ARRAY));
-    }
-
-    public TableSorterCascade(final TableSorter[] sortersCascade) {
         this.sorters = sortersCascade;
-        cntFields = sortersCascade.length;
+        cntFields = sortersCascade.size();
     }
 
     @Override
-    public final int compare(final Entry<CardPrinted, Integer> arg0, final Entry<CardPrinted, Integer> arg1) {
+    public final int compare(final Entry<T, Integer> arg0, final Entry<T, Integer> arg1) {
         int lastCompare = 0;
         int iField = -1;
-        while (++iField < cntFields && lastCompare == 0) {
+        while (++iField < cntFields && lastCompare == 0) { // reverse iteration
-            TableSorter sorter = sorters[iField];
+            TableSorter<T> sorter = sorters.get(iField);
             if (sorter == null) { break; }
             lastCompare = sorter.compare(arg0, arg1);
         }

src/main/java/forge/gui/deckeditor/TableWithCards.java

@@ -21,7 +21,7 @@ import forge.card.CardPool;
 import forge.card.CardPoolView;
 import forge.card.CardPrinted;
 import forge.card.CardRules;
-//import forge.view.swing.OldGuiNewGame;
+import forge.card.InventoryItem;
 
 /** 
  * TODO: Write javadoc for this type.
@@ -29,12 +29,12 @@ import forge.card.CardRules;
  */
 public final class TableWithCards {
 
-    protected CardPool pool;
+    protected CardPool<InventoryItem> pool;
-    protected TableModel model;
+    protected TableModel<InventoryItem> model;
     protected JTable table = new JTable();
     protected JScrollPane jScrollPane = new JScrollPane();
     protected JLabel statsLabel = new JLabel();
-    protected Predicate<CardPrinted> filter = null;
+    protected Predicate<InventoryItem> filter = null;
     protected boolean isTrackingStats = false;
     protected boolean wantUnique = false;
 
@@ -64,9 +64,9 @@ public final class TableWithCards {
         wantUnique = forceUnique;
     }
 
-    public void setup(final List<TableColumnInfo<CardPrinted>> columns, final CardPanelBase cardView)
+    public void setup(final List<TableColumnInfo<InventoryItem>> columns, final CardPanelBase cardView)
     {
-        model = new TableModel(cardView, columns);
+        model = new TableModel<InventoryItem>(cardView, columns);
         model.addListeners(table);
         table.setModel(model);
         model.resizeCols(table);
@@ -82,7 +82,7 @@ public final class TableWithCards {
             // get stats from deck
             model.addTableModelListener(new TableModelListener() {
                 public void tableChanged(final TableModelEvent ev) {
-                    CardPoolView deck = model.getCards();
+                    CardPoolView<InventoryItem> deck = model.getCards();
                     statsLabel.setText(getStats(deck));
                 }
             });
@@ -90,17 +90,17 @@ public final class TableWithCards {
     }
 
     // This should not be here, but still found no better place
-    public static String getStats(final CardPoolView deck) {
+    public static String getStats(final CardPoolView<InventoryItem> deck) {
         int total = deck.countAll();
-        int creature = CardRules.Predicates.Presets.isCreature.aggregate(deck, CardPoolView.fnToCard, CardPoolView.fnToCount);
+        int creature = CardRules.Predicates.Presets.isCreature.aggregate(deck, deck.fnToCard, deck.fnToCount);
-        int land = CardRules.Predicates.Presets.isLand.aggregate(deck, CardPoolView.fnToCard, CardPoolView.fnToCount);
+        int land = CardRules.Predicates.Presets.isLand.aggregate(deck, deck.fnToCard, deck.fnToCount);
 
         StringBuffer show = new StringBuffer();
         show.append("Total - ").append(total).append(", Creatures - ").append(creature).append(", Land - ").append(land);
         String[] color = Constant.Color.onlyColors;
         List<Predicate<CardRules>> predicates = CardRules.Predicates.Presets.colors;
         for (int i = 0; i < color.length; ++i) {
-            show.append(String.format(", %s - %d", color[i], predicates.get(i).count(deck, CardPoolView.fnToCard)));
+            show.append(String.format(", %s - %d", color[i], predicates.get(i).count(deck, deck.fnToCard)));
         }
 
         return show.toString();
@@ -123,15 +123,15 @@ public final class TableWithCards {
         }
     }
 
-    public void setDeck(final Iterable<CardPrinted> cards) {
+    public void setDeck(final Iterable<InventoryItem> cards) {
-        setDeckImpl(new CardPool(cards));
+        setDeckImpl(CardPool.createFrom(cards, InventoryItem.class));
     }
 
-    public void setDeck(final CardPoolView poolView) {
+    public <T extends InventoryItem> void setDeck(final CardPoolView<T> poolView) {
-        setDeckImpl(new CardPool(poolView));
+        setDeckImpl(CardPool.createFrom(poolView, InventoryItem.class));
     }
     
-    protected void setDeckImpl(CardPool thePool)
+    protected void setDeckImpl(CardPool<InventoryItem> thePool)
     {
         model.clear();
         pool = thePool;
@@ -139,14 +139,14 @@ public final class TableWithCards {
         updateView(true);
     }
 
-    public CardPrinted getSelectedCard() {
+    public InventoryItem getSelectedCard() {
         int iRow = table.getSelectedRow();
         return iRow >= 0 ? model.rowToCard(iRow).getKey() : null;
     }
 
     private boolean isUnfiltered() { return filter == null || filter.is1(); }
 
-    public void setFilter(final Predicate<CardPrinted> filterToSet) {
+    public void setFilter(final Predicate<InventoryItem> filterToSet) {
         filter = filterToSet;
         updateView(true);
     }
@@ -174,17 +174,17 @@ public final class TableWithCards {
         }
 
         if (useFilter && wantUnique) {
-            model.addCards(filter.uniqueByLast(pool, CardPoolView.fnToCardName, CardPoolView.fnToPrinted));
+            model.addCards(filter.uniqueByLast(pool, pool.fnToCardName, pool.fnToPrinted));
         } else if (useFilter) {
-            model.addCards(filter.select(pool, CardPoolView.fnToPrinted));
+            model.addCards(filter.select(pool, pool.fnToPrinted));
         } else if (wantUnique) {
-            model.addCards(CardRules.Predicates.Presets.constantTrue.uniqueByLast(pool, CardPoolView.fnToCardName, CardPoolView.fnToCard));
+            model.addCards(CardRules.Predicates.Presets.constantTrue.uniqueByLast(pool, pool.fnToCardName, pool.fnToCard));
         }
 
         model.resort();
     }
 
-    public CardPoolView getCards() {
+    public CardPoolView<InventoryItem> getCards() {
         return pool;
     }
 

src/main/java/forge/gui/game/CardPicturePanel.java

@@ -14,6 +14,7 @@ import forge.Card;
 import forge.CardContainer;
 import forge.ImageCache;
 import forge.card.CardPrinted;
+import forge.card.InventoryItem;
 
 import javax.swing.*;
 import java.awt.*;
@@ -33,7 +34,7 @@ public final class CardPicturePanel extends JPanel implements CardContainer {
     private static final long serialVersionUID = -3160874016387273383L;
 
     private Card card;
-    private CardPrinted cardPrinted;
+    private InventoryItem inventoryItem;
 
     //    private JLabel           label;
 //    private ImageIcon        icon;
@@ -73,9 +74,9 @@ public final class CardPicturePanel extends JPanel implements CardContainer {
      */
     public void update() { setCard(getCard()); }
 
-    public void setCard(final CardPrinted cp) {
+    public void setCard(final InventoryItem cp) {
         card = null;
-        cardPrinted = cp;
+        inventoryItem = cp;
         if (!isShowing()) { return; }
 
         setImage();
@@ -84,7 +85,7 @@ public final class CardPicturePanel extends JPanel implements CardContainer {
     /** {@inheritDoc} */
     public void setCard(final Card c) {
         card = c;
-        cardPrinted = null;
+        inventoryItem = null;
         if (!isShowing()) { return; }
 
         setImage();
@@ -93,8 +94,8 @@ public final class CardPicturePanel extends JPanel implements CardContainer {
     private void setImage() {
         Insets i = getInsets();
         Image image = null;
-        if (cardPrinted != null) {
+        if (inventoryItem != null) {
-            image = ImageCache.getImage(cardPrinted, getWidth() - i.left - i.right, getHeight() - i.top - i.bottom); }
+            image = ImageCache.getImage(inventoryItem, getWidth() - i.left - i.right, getHeight() - i.top - i.bottom); }
         if (card != null && image == null) {
             image = ImageCache.getImage(card, getWidth() - i.left - i.right, getHeight() - i.top - i.bottom); }
 
@@ -120,8 +121,8 @@ public final class CardPicturePanel extends JPanel implements CardContainer {
      * @return a {@link forge.Card} object.
      */
     public Card getCard() {
-        if ( card == null && cardPrinted != null ) {
+        if ( card == null && inventoryItem != null && inventoryItem instanceof CardPrinted ) {
-            card = cardPrinted.toForgeCard();
+            card = ((CardPrinted) inventoryItem).toForgeCard();
         }
         return card;
     }

src/main/java/forge/quest/data/QuestData.java

@@ -4,6 +4,7 @@ import forge.MyRandom;
 import forge.SetUtils;
 import forge.card.CardPool;
 import forge.card.CardPrinted;
+import forge.card.InventoryItem;
 import forge.deck.Deck;
 import forge.error.ErrorViewer;
 import forge.properties.ForgeProps;
@@ -67,9 +68,9 @@ public final class QuestData {
     Map<String, Deck> myDecks = new HashMap<String, Deck>();
 
     // Cards associated with quest
-    CardPool cardPool = new CardPool();     // player's belonging
+    CardPool<CardPrinted> cardPool = new CardPool<CardPrinted>();     // player's belonging
-    CardPool shopList = new CardPool();     // the current shop list
+    CardPool<CardPrinted> shopList = new CardPool<CardPrinted>();     // the current shop list
-    CardPool newCardList = new CardPool();  // cards acquired since last game-win/loss
+    CardPool<InventoryItem> newCardList = new CardPool<InventoryItem>();  // cards acquired since last game-win/loss
 
     // Quests history
     int questsPlayed;
@@ -115,8 +116,8 @@ public final class QuestData {
         myRewards = new QuestUtilRewards(this);
 
         // to avoid NPE some pools will be created here if they are null
-        if (null == newCardList) { newCardList = new CardPool(); }
+        if (null == newCardList) { newCardList = new CardPool<InventoryItem>(); }
-        if (null == shopList) { shopList = new CardPool(); }
+        if (null == shopList) { shopList = new CardPool<CardPrinted>(); }
 
     }
 

src/main/java/forge/quest/data/QuestDataIO.java

@@ -11,6 +11,7 @@ import com.thoughtworks.xstream.converters.UnmarshallingContext;
 import forge.card.CardDb;
 import forge.card.CardPool;
 import forge.card.CardPrinted;
+import forge.card.InventoryItem;
 import forge.error.ErrorViewer;
 import forge.game.GameType;
 import forge.properties.ForgeProps;
@@ -232,19 +233,23 @@ public class QuestDataIO {
         
         @Override
         public void marshal(Object source, HierarchicalStreamWriter writer, MarshallingContext context) {
-            CardPool pool = (CardPool) source;
+            @SuppressWarnings("unchecked")
-            for (Entry<CardPrinted, Integer> e : pool) {
+            CardPool<InventoryItem> pool = (CardPool<InventoryItem>) source;
-                writer.startNode("card");
+            for (Entry<InventoryItem, Integer> e : pool) {
-                writeCardRef(e.getKey(), writer);
+                if ( e.getKey() instanceof CardPrinted)
-                writer.addAttribute("n", e.getValue().toString());
+                {
-                writer.endNode();
+                    writer.startNode("card");
+                    writeCardRef((CardPrinted) e.getKey(), writer);
+                    writer.addAttribute("n", e.getValue().toString());
+                    writer.endNode();
+                }
             }
             
         }
 
         @Override
         public Object unmarshal(final HierarchicalStreamReader reader, final UnmarshallingContext context) {
-            CardPool result = new CardPool();
+            CardPool<CardPrinted> result = new CardPool<CardPrinted>();
             while (reader.hasMoreChildren()) {
                 reader.moveDown();
                 String nodename = reader.getNodeName();

src/main/java/forge/quest/data/QuestUtil.java

@@ -7,7 +7,6 @@ import forge.Quest_Assignment;
 import forge.card.CardPrinted;
 import forge.card.CardRarity;
 
-import java.util.ArrayList;
 import java.util.List;
 
 /**

src/main/java/forge/quest/data/QuestUtilCards.java

@@ -13,6 +13,7 @@ import forge.card.CardPool;
 import forge.card.CardPoolView;
 import forge.card.CardPrinted;
 import forge.card.CardRarity;
+import forge.card.InventoryItem;
 import forge.deck.Deck;
 
 /** 
@@ -145,23 +146,23 @@ public final class QuestUtilCards {
         int winPacks = q.getWin() / 10;
         int totalPacks = Math.min(levelPacks + winPacks, 6);
 
-        CardPoolView fromBoosters = pack.getShopCards(totalPacks);
+        CardPoolView<CardPrinted> fromBoosters = pack.getShopCards(totalPacks);
         q.shopList.clear();
         q.shopList.addAll(fromBoosters);
     }
 
-    public CardPool getCardpool() {
+    public CardPool<CardPrinted> getCardpool() {
         return q.cardPool;
     }
 
-    public CardPoolView getShopList() {
+    public CardPoolView<CardPrinted> getShopList() {
         if (q.shopList.isEmpty()) {
             generateCardsInShop();
         }
         return q.shopList;
     }
 
-    public CardPoolView getNewCards() {
+    public CardPoolView<InventoryItem> getNewCards() {
         return q.newCardList;
     }
 
@@ -173,14 +174,14 @@ public final class QuestUtilCards {
     // It might be a good idea to store them in a base class for both quest-mode deck editors
     // Maybe we should consider doing so later
     @SuppressWarnings("rawtypes")
-    public final Lambda1<Comparable, Entry<CardPrinted, Integer>> fnNewCompare =
+    public final Lambda1<Comparable, Entry<InventoryItem, Integer>> fnNewCompare =
-        new Lambda1<Comparable, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Comparable, Entry<InventoryItem, Integer>>() { @Override
-            public Comparable apply(final Entry<CardPrinted, Integer> from) {
+            public Comparable apply(final Entry<InventoryItem, Integer> from) {
                 return q.newCardList.contains(from.getKey()) ? Integer.valueOf(1) : Integer.valueOf(0);
             } };
-    public final Lambda1<Object, Entry<CardPrinted, Integer>> fnNewGet =
+    public final Lambda1<Object, Entry<InventoryItem, Integer>> fnNewGet =
-        new Lambda1<Object, Entry<CardPrinted, Integer>>() { @Override
+        new Lambda1<Object, Entry<InventoryItem, Integer>>() { @Override
-            public Object apply(final Entry<CardPrinted, Integer> from) {
+            public Object apply(final Entry<InventoryItem, Integer> from) {
                 return q.newCardList.contains(from.getKey()) ? "NEW" : "";
             } };
 }

src/main/java/forge/view/swing/OldGuiNewGame.java

@@ -4,6 +4,7 @@ import arcane.ui.util.ManaSymbols;
 import com.esotericsoftware.minlog.Log;
 import forge.*;
 import forge.card.CardPool;
+import forge.card.CardPrinted;
 import forge.deck.Deck;
 import forge.deck.DeckGeneration;
 import forge.deck.DeckManager;
@@ -335,7 +336,7 @@ public class OldGuiNewGame extends JFrame implements NewConstants, NewConstants.
                     "choice <<" + safeToString(o) + ">> does not equal any of the sealedTypes.");
         }
 
-        CardPool sDeck = sd.getCardpool();
+        CardPool<CardPrinted> sDeck = sd.getCardpool();
 
         if (sDeck.countAll() > 1) {
 

src/main/java/net/slightlymagic/maxmtg/Predicate.java

@@ -198,6 +198,9 @@ public abstract class Predicate<T> {
     public static <U, T> Predicate<U> brigde(final Predicate<T> predicate, final Lambda1<T, U> fnBridge) {
         return new Bridge<T, U>(predicate, fnBridge);
     }
+    public static <U, T> Predicate<U> instanceOf(final Predicate<T> predicate, final Class<T> clsTarget) {
+        return new BridgeToInstance<T, U>(predicate, clsTarget);
+    }
 
     public static <T> Predicate<T> not(final Predicate<T> operand1) { return new Not<T>(operand1); }
     public static <T> Predicate<T> compose(final Predicate<T> operand1,
@@ -220,111 +223,123 @@ public abstract class Predicate<T> {
     public static <T, U> Predicate<T> or(final Predicate<T> operand1, final Predicate<U> operand2, final Lambda1<U, T> bridge)
         { return new NodeOrBridged<T, U>(operand1, operand2, bridge); }
 
-    // Concrete implementations
-    // unary operators
-    protected static final class Not<T> extends Predicate<T> {
-        protected final Predicate<T> filter;
-        public Not(final Predicate<T> operand) { filter = operand; }
-        @Override public boolean isTrue(final T card) { return !filter.isTrue(card); }
-    }
-    protected static final class Bridge<T, U> extends Predicate<U> {
-        protected final Predicate<T> filter;
-        protected final Lambda1<T, U> fnBridge;
-        public Bridge(final Predicate<T> operand, final Lambda1<T, U> fnTfromU) { filter = operand; fnBridge = fnTfromU; }
-        @Override public boolean isTrue(final U card) { return filter.isTrue(fnBridge.apply(card)); }
-        @Override public boolean is1() { return filter.is1(); }
-    }
-    // binary operators
-    protected static class Node<T> extends Predicate<T> {
-        private final PredicatesOp operator;
-        protected final Predicate<T> filter1;
-        protected final Predicate<T> filter2;
  
-        public Node(final Predicate<T> operand1, final PredicatesOp op, final Predicate<T> operand2)
-        {
-            operator = op;
-            filter1 = operand1;
-            filter2 = operand2;
-        }
-
-        @Override public boolean isTrue(final T card) {
-            switch (operator) {
-                case AND: return filter1.isTrue(card) && filter2.isTrue(card);
-                case NAND: return !(filter1.isTrue(card) && filter2.isTrue(card));
-                case OR: return filter1.isTrue(card) || filter2.isTrue(card);
-                case NOR: return !(filter1.isTrue(card) || filter2.isTrue(card));
-                case XOR: return filter1.isTrue(card) ^ filter2.isTrue(card);
-                case EQ: return filter1.isTrue(card) == filter2.isTrue(card);
-                default: return false;
-            }
-        }
-    }
-    protected static final class NodeOr<T> extends Node<T> {
-        public NodeOr(final Predicate<T> operand1, final Predicate<T> operand2) {
-            super(operand1, PredicatesOp.OR, operand2);
-        }
-        @Override public boolean isTrue(final T card) { return filter1.isTrue(card) || filter2.isTrue(card); }
-    }
-    protected static final class NodeAnd<T> extends Node<T> {
-        public NodeAnd(final Predicate<T> operand1, final Predicate<T> operand2) {
-            super(operand1, PredicatesOp.AND, operand2);
-        }
-        @Override public boolean isTrue(final T card) { return filter1.isTrue(card) && filter2.isTrue(card); }
-    }
-
-    // Bridged OR and AND
-    protected static final class NodeOrBridged<T,U> extends Predicate<T> {
-        private final Predicate<T> filter1;
-        private final Predicate<U> filter2;
-        private final Lambda1<U, T> bridge;
-        public NodeOrBridged(final Predicate<T> operand1, final Predicate<U> operand2, final Lambda1<U, T> accessor) {
-            filter1 = operand1;
-            filter2 = operand2;
-            bridge = accessor;
-        }
-        @Override public boolean isTrue(final T card) { return filter1.isTrue(card) || filter2.isTrue(bridge.apply(card)); }
-    }
-    protected static final class NodeAndBridged<T,U> extends Predicate<T> {
-        private final Predicate<T> filter1;
-        private final Predicate<U> filter2;
-        private final Lambda1<U, T> bridge;
-        public NodeAndBridged(final Predicate<T> operand1, final Predicate<U> operand2, final Lambda1<U, T> accessor) {
-            filter1 = operand1;
-            filter2 = operand2;
-            bridge = accessor;
-        }
-        @Override public boolean isTrue(final T card) { return filter1.isTrue(card) && filter2.isTrue(bridge.apply(card)); }
-    }
-
-    // multi-operand operators
-    protected abstract static class MultiNode<T> extends Predicate<T> {
-        protected final Iterable<Predicate<T>> operands;
-        public MultiNode(Iterable<Predicate<T>> filters) { operands = filters; }
-    }
-    protected final static class MultiNodeAnd<T> extends MultiNode<T> {
-        public MultiNodeAnd(final Iterable<Predicate<T>> filters) { super(filters); }
-        @Override public boolean isTrue(final T subject) {
-            for (Predicate<T> p : operands) { if (!p.isTrue(subject)) { return false; } }
-            return true;
-        }
-    }
-    protected final static class MultiNodeOr<T> extends MultiNode<T> {
-        public MultiNodeOr(final Iterable<Predicate<T>> filters) { super(filters); }
-        @Override public boolean isTrue(final T subject) {
-            for (Predicate<T> p : operands) { if (p.isTrue(subject)) { return true; } }
-            return false;
-        }
-    }
-
-    protected static class LeafConstant<T> extends Predicate<T> {
-        private final boolean bValue;
-
-        @Override public boolean is1() { return bValue; }
-        @Override public boolean is0() { return !bValue; }
-        @Override public boolean isTrue(final T card) { return bValue; }
-        public LeafConstant(final boolean value) { bValue = value; }
-    }
     
     public static <T> Predicate<T> getTrue(final Class<T> cls) { return new LeafConstant<T>(true); }
     public static <T> Predicate<T> getFalse(final Class<T> cls) { return new LeafConstant<T>(false); }
 }
+
+// Concrete implementations
+// unary operators
+final class Not<T> extends Predicate<T> {
+    protected final Predicate<T> filter;
+    public Not(final Predicate<T> operand) { filter = operand; }
+    @Override public boolean isTrue(final T card) { return !filter.isTrue(card); }
+}
+final class Bridge<T, U> extends Predicate<U> {
+    protected final Predicate<T> filter;
+    protected final Lambda1<T, U> fnBridge;
+    public Bridge(final Predicate<T> operand, final Lambda1<T, U> fnTfromU) { filter = operand; fnBridge = fnTfromU; }
+    @Override public boolean isTrue(final U card) { return filter.isTrue(fnBridge.apply(card)); }
+    @Override public boolean is1() { return filter.is1(); }
+}
+
+final class BridgeToInstance<T, U> extends Predicate<U> {
+    protected final Predicate<T> filter;
+    protected final Class<T> clsBridge;
+    public BridgeToInstance(final Predicate<T> operand, final Class<T> clsT) { filter = operand; clsBridge = clsT; }
+    @SuppressWarnings("unchecked") @Override
+    public boolean isTrue(final U card) { return clsBridge.isInstance(card) && filter.isTrue((T) card); }
+    @Override public boolean is1() { return filter.is1(); }
+}
+
+// binary operators
+class Node<T> extends Predicate<T> {
+    private final PredicatesOp operator;
+    protected final Predicate<T> filter1;
+    protected final Predicate<T> filter2;
+
+    public Node(final Predicate<T> operand1, final PredicatesOp op, final Predicate<T> operand2)
+    {
+        operator = op;
+        filter1 = operand1;
+        filter2 = operand2;
+    }
+
+    @Override public boolean isTrue(final T card) {
+        switch (operator) {
+            case AND: return filter1.isTrue(card) && filter2.isTrue(card);
+            case NAND: return !(filter1.isTrue(card) && filter2.isTrue(card));
+            case OR: return filter1.isTrue(card) || filter2.isTrue(card);
+            case NOR: return !(filter1.isTrue(card) || filter2.isTrue(card));
+            case XOR: return filter1.isTrue(card) ^ filter2.isTrue(card);
+            case EQ: return filter1.isTrue(card) == filter2.isTrue(card);
+            default: return false;
+        }
+    }
+}
+final class NodeOr<T> extends Node<T> {
+    public NodeOr(final Predicate<T> operand1, final Predicate<T> operand2) {
+        super(operand1, PredicatesOp.OR, operand2);
+    }
+    @Override public boolean isTrue(final T card) { return filter1.isTrue(card) || filter2.isTrue(card); }
+}
+final class NodeAnd<T> extends Node<T> {
+    public NodeAnd(final Predicate<T> operand1, final Predicate<T> operand2) {
+        super(operand1, PredicatesOp.AND, operand2);
+    }
+    @Override public boolean isTrue(final T card) { return filter1.isTrue(card) && filter2.isTrue(card); }
+}
+
+// Bridged OR and AND
+final class NodeOrBridged<T,U> extends Predicate<T> {
+    private final Predicate<T> filter1;
+    private final Predicate<U> filter2;
+    private final Lambda1<U, T> bridge;
+    public NodeOrBridged(final Predicate<T> operand1, final Predicate<U> operand2, final Lambda1<U, T> accessor) {
+        filter1 = operand1;
+        filter2 = operand2;
+        bridge = accessor;
+    }
+    @Override public boolean isTrue(final T card) { return filter1.isTrue(card) || filter2.isTrue(bridge.apply(card)); }
+}
+final class NodeAndBridged<T,U> extends Predicate<T> {
+    private final Predicate<T> filter1;
+    private final Predicate<U> filter2;
+    private final Lambda1<U, T> bridge;
+    public NodeAndBridged(final Predicate<T> operand1, final Predicate<U> operand2, final Lambda1<U, T> accessor) {
+        filter1 = operand1;
+        filter2 = operand2;
+        bridge = accessor;
+    }
+    @Override public boolean isTrue(final T card) { return filter1.isTrue(card) && filter2.isTrue(bridge.apply(card)); }
+}
+
+// multi-operand operators
+abstract class MultiNode<T> extends Predicate<T> {
+    protected final Iterable<Predicate<T>> operands;
+    public MultiNode(Iterable<Predicate<T>> filters) { operands = filters; }
+}
+final class MultiNodeAnd<T> extends MultiNode<T> {
+    public MultiNodeAnd(final Iterable<Predicate<T>> filters) { super(filters); }
+    @Override public boolean isTrue(final T subject) {
+        for (Predicate<T> p : operands) { if (!p.isTrue(subject)) { return false; } }
+        return true;
+    }
+}
+final class MultiNodeOr<T> extends MultiNode<T> {
+    public MultiNodeOr(final Iterable<Predicate<T>> filters) { super(filters); }
+    @Override public boolean isTrue(final T subject) {
+        for (Predicate<T> p : operands) { if (p.isTrue(subject)) { return true; } }
+        return false;
+    }
+}
+
+class LeafConstant<T> extends Predicate<T> {
+    private final boolean bValue;
+
+    @Override public boolean is1() { return bValue; }
+    @Override public boolean is0() { return !bValue; }
+    @Override public boolean isTrue(final T card) { return bValue; }
+    public LeafConstant(final boolean value) { bValue = value; }
+}

src/test/java/forge/BoosterDraftAITest.java

@@ -43,7 +43,7 @@ public class BoosterDraftAITest {
     public void runTest(BoosterDraftAI ai) {
         ReadDraftBoosterPack booster = new ReadDraftBoosterPack();
         for (int outer = 0; outer < 1; outer++) {
-            CardPool allBooster = new CardPool();
+            CardPool<CardPrinted> allBooster = new CardPool<CardPrinted>();
             for (int i = 0; i < 21; i++)
                 allBooster.addAll(booster.getBoosterPack());
             

src/test/java/forge/BoosterDraftTest.java

@@ -32,7 +32,7 @@ public class BoosterDraftTest implements BoosterDraft {
      *
      * @return a {@link forge.CardList} object.
      */
-    public CardPoolView nextChoice() {
+    public CardPoolView<CardPrinted> nextChoice() {
         n--;
         ReadDraftBoosterPack pack = new ReadDraftBoosterPack();
         return pack.getBoosterPack();

src/test/java/forge/BoosterDraft_1Test.java

@@ -1,10 +1,8 @@
 package forge;
 
-import net.slightlymagic.maxmtg.Predicate;
-
 import org.testng.annotations.Test;
 
-import forge.card.CardRules;
+import forge.card.CardPrinted;
 import forge.card.CardPoolView;
 
 import forge.game.limited.BoosterDraft_1;
@@ -23,9 +21,9 @@ public class BoosterDraft_1Test {
     public void BoosterDraft_1Test1() throws Exception {
         BoosterDraft_1 draft = new BoosterDraft_1();
         while (draft.hasNextChoice()) {
-            CardPoolView list = draft.nextChoice();
+            CardPoolView<CardPrinted> list = draft.nextChoice();
             System.out.println(list.countAll());
-            draft.setChoice(Predicate.getTrue(CardRules.class).first(list, CardPoolView.fnToCard, CardPoolView.fnToPrinted));
+            draft.setChoice(list.toFlatList().get(0));
         }
     }
 }