Moved away from reflection for sorting, now looking into using a hashmap instead of a list

5 files changed, 86 insertions, 132 deletions

diff --git a/src/eu/equalparts/cardbase/Cardbase.java b/src/eu/equalparts/cardbase/Cardbase.java
index 14afc10..d842031 100644
--- a/src/eu/equalparts/cardbase/Cardbase.java
+++ b/src/eu/equalparts/cardbase/Cardbase.java
@@ -1,7 +1,6 @@
 package eu.equalparts.cardbase;
 import java.io.File;
 import java.io.IOException;
-import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -11,7 +10,7 @@ import com.fasterxml.jackson.core.JsonParseException;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.JsonMappingException;
 
-import eu.equalparts.cardbase.comparators.CardComparator;
+import eu.equalparts.cardbase.comparators.CardComparators;
 import eu.equalparts.cardbase.data.Card;
 import eu.equalparts.cardbase.utils.JSON;
 
@@ -119,7 +118,7 @@ public class Cardbase {
 	 * This method is intended to allow iteration directly on the list of cards,
 	 * while at the same time retaining control over the insert and remove procedures.
 	 * The returned {@code List} is a read-only; trying to modify its structure will
-	 * result in a {@code UnsupportedOperationException}.
+	 * result in an {@code UnsupportedOperationException}.
 	 * 
 	 * @return an unmodifiable list of all the cards in the cardbase.
 	 */
@@ -127,22 +126,8 @@ public class Cardbase {
 		return Collections.unmodifiableList(cards);
 	}
 	
-	/**
-	 * Sorts the cardbase by the specified field. The field must be specified exactly
-	 * as it is defined in {@code Card}, case-sensitive. It must also be comparable to
-	 * itself, as {@code String} and {@code Integer} are.
-	 * 
-	 * @param fieldName the declared name of the field to be used for sorting.
-	 * @return true if the sort was successful, false if no such field was found.
-	 */
-	public boolean sortBy(String fieldName) {
-		for (Field field : Card.class.getDeclaredFields()) {
-			if (field.getName().equals(fieldName)) {
-				cards.sort(new CardComparator(field));
-				return true;
-			}
-		}
-		return false;
+	public void sortByName() {
+		cards.sort(new CardComparators.NameComparator());
 	}
 
 	/**
@@ -161,4 +146,8 @@ public class Cardbase {
 		
 		return null;
 	}
+	
+	private String makeHash(String setCode, String number) {
+		return setCode + number;
+	}
 }
diff --git a/src/eu/equalparts/cardbase/comparators/CardComparator.java b/src/eu/equalparts/cardbase/comparators/CardComparator.java
deleted file mode 100644
index 3640c8b..0000000
--- a/src/eu/equalparts/cardbase/comparators/CardComparator.java
+++ /dev/null
@@ -1,102 +0,0 @@
-package eu.equalparts.cardbase.comparators;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.util.Comparator;
-
-import eu.equalparts.cardbase.Cardbase;
-import eu.equalparts.cardbase.data.Card;
-
-/**
- * I'm new to this reflection business, so bear with me.
- * <br><br>
- * The idea here is to avoid having to write one class
- * for each comparable field in {@code Card}. The program
- * can dynamically instantiate them as cards are compared 
- * by different fields.
- * <br><br>
- * This class uses reflection to determine if the specified
- * field is comparable with itself upon construction, and throws
- * an {@code IllegalArgumentException} if that is not the case.
- * 
- * @author Eduardo Pedroni
- *
- */
-@SuppressWarnings({"rawtypes", "unchecked"})
-public class CardComparator implements Comparator<Card> {
-
-	/**
-	 * The field being compared.
-	 */
-	private Field fieldToCompare;
-
-	/**
-	 * Creates a new comparator for the specified field only. This class
-	 * will only be constructed successfully if the field comes from
-	 * {@code Card} and can be compared to itself (i.e. implements
-	 * {@code Comparable<T>} where T is its own type.
-	 * <br>
-	 * For reference, {@code String} and {@code Integer} are both self comparable.
-	 * 
-	 * @param fieldToCompare the field this comparator will use to compare cards, as declared in {@code Card}.
-	 */
-	public CardComparator(Field fieldToCompare) {
-		if (fieldToCompare.getDeclaringClass().equals(Card.class) &&
-				isSelfComparable(fieldToCompare.getType())) {
-
-			this.fieldToCompare = fieldToCompare;
-		} else {
-			System.out.println(fieldToCompare.isAccessible());
-			System.out.println(fieldToCompare.getDeclaringClass().equals(Card.class));
-			System.out.println(isSelfComparable(fieldToCompare.getType()));
-			throw new IllegalArgumentException("The field provided is not valid.");
-		}
-	}
-
-	@Override
-	public int compare(Card o1, Card o2) {
-		try {
-			/*
-			 * we've already checked that the field is self comparable,
-			 * so we are now free to cast to whatever type it is and compare.
-			 */
-			Comparable field1 = (Comparable) fieldToCompare.get(o1);
-			Comparable field2 = (Comparable) fieldToCompare.get(o2);
-			
-			return field1.compareTo(field2);
-
-		} catch (IllegalArgumentException e) {
-			System.out.println("Error: class Card does not define field" + fieldToCompare.getName() + ".");
-			if (Cardbase.DEBUG) e.printStackTrace();
-		} catch (IllegalAccessException e) {
-			System.out.println("Error: field " + fieldToCompare.getName() + " in Card is not visible.");
-			if (Cardbase.DEBUG) e.printStackTrace();
-		}
-		
-		// not comparable, this should never happen
-		return 0;
-	}
-
-	/**
-	 * Use reflection to determine if the specified class can be compared with itself.
-	 * 
-	 * @param type the type to analyse.
-	 * @return true if the type can be compared to itself using {@code compareTo()}, false otherwise.
-	 */
-	private boolean isSelfComparable(Class<?> type) {
-
-		// go through all interfaces implemented by this class
-		for (Type implementedInterface : type.getGenericInterfaces()) {
-			// check if any parameterised interface found is "Comparable"
-			if (implementedInterface instanceof ParameterizedType) {
-				ParameterizedType genericInterface = (ParameterizedType) implementedInterface;
-				if (genericInterface.getRawType().equals(Comparable.class)) {
-					// check that the type argument of comparable is the same as the field type itself
-					return genericInterface.getActualTypeArguments()[0].equals(type);
-				}
-			}
-		}
-		return false;
-	}
-}
diff --git a/src/eu/equalparts/cardbase/comparators/CardComparators.java b/src/eu/equalparts/cardbase/comparators/CardComparators.java
new file mode 100644
index 0000000..99f7ded
--- /dev/null
+++ b/src/eu/equalparts/cardbase/comparators/CardComparators.java
@@ -0,0 +1,76 @@
+package eu.equalparts.cardbase.comparators;
+
+import java.util.Comparator;
+
+import eu.equalparts.cardbase.data.Card;
+
+public final class CardComparators {
+
+	private CardComparators() {}
+
+	public enum Order {
+		NATURAL, REVERSE;
+	}
+
+	public static class NameComparator implements Comparator<Card> {
+
+		private Order order = Order.NATURAL;
+
+		public NameComparator() {}
+
+		public NameComparator(Order order) {
+			this.order = order;
+		}
+
+		@Override
+		public int compare(Card o1, Card o2) {
+			if (order == Order.NATURAL) {
+				return o1.name.compareTo(o2.name);
+			} else {
+				return o2.name.compareTo(o1.name);
+			}
+
+		}
+	}
+
+	public static class LayoutComparator implements Comparator<Card> {
+
+		private Order order = Order.NATURAL;
+
+		public LayoutComparator() {}
+
+		public LayoutComparator(Order order) {
+			this.order = order;
+		}
+
+		@Override
+		public int compare(Card o1, Card o2) {
+			if (order == Order.NATURAL) {
+				return o1.layout.compareTo(o2.layout);
+			} else {
+				return o2.layout.compareTo(o1.layout);
+			}
+		}
+	}
+
+	public static class ManaCostComparator implements Comparator<Card> {
+
+		private Order order = Order.NATURAL;
+
+		public ManaCostComparator() {}
+
+		public ManaCostComparator(Order order) {
+			this.order = order;
+		}
+
+		@Override
+		public int compare(Card o1, Card o2) {
+			if (order == Order.NATURAL) {
+				return o1.manaCost.compareTo(o2.manaCost);
+			} else {
+				return o2.manaCost.compareTo(o1.manaCost);
+			}
+		}
+	}
+
+}
diff --git a/src/eu/equalparts/cardbase/data/Card.java b/src/eu/equalparts/cardbase/data/Card.java
index 03e7dea..3820223 100644
--- a/src/eu/equalparts/cardbase/data/Card.java
+++ b/src/eu/equalparts/cardbase/data/Card.java
@@ -4,8 +4,8 @@ import java.util.List;
 
 public class Card {
 	
-	public String layout = "";
 	public String name = "";
+	public String layout = "";
 	public List<String> names;
 	public String manaCost = "";
 	public Integer cmc = 0;
diff --git a/src/eu/equalparts/cardbase/standalone/CardbaseCLI.java b/src/eu/equalparts/cardbase/standalone/CardbaseCLI.java
index 108b753..f491f6c 100644
--- a/src/eu/equalparts/cardbase/standalone/CardbaseCLI.java
+++ b/src/eu/equalparts/cardbase/standalone/CardbaseCLI.java
@@ -416,16 +416,7 @@ public class CardbaseCLI {
 	 * @param args the ordering to sort by.
 	 */
 	public void sort(String[] args) {
-		if (args.length > 0) {
-			String fieldName = args[0];
-			if (cardbase.sortBy(fieldName)) {
-				System.out.println("Cardbase sorted by " + fieldName);
-			} else {
-				System.out.println("Unknown field: " + fieldName);
-			}
-		} else {
-			System.out.println("Please enter the field to use for sorting.");
-		}
+		cardbase.sortByName();
 	}
 
 	/**