aboutsummaryrefslogtreecommitdiffstats
path: root/src/eu
diff options
context:
space:
mode:
Diffstat (limited to 'src/eu')
-rw-r--r--src/eu/equalparts/cardbase/Cardbase.java27
-rw-r--r--src/eu/equalparts/cardbase/comparators/CardComparator.java102
-rw-r--r--src/eu/equalparts/cardbase/comparators/CardComparators.java76
-rw-r--r--src/eu/equalparts/cardbase/data/Card.java2
-rw-r--r--src/eu/equalparts/cardbase/standalone/CardbaseCLI.java11
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();
}
/**