diff options
Diffstat (limited to 'src/main/java/design/model/course_search')
8 files changed, 238 insertions, 4 deletions
diff --git a/src/main/java/design/model/course_search/CourseList.java b/src/main/java/design/model/course_search/CourseList.java index 82648c2..360dc9b 100644 --- a/src/main/java/design/model/course_search/CourseList.java +++ b/src/main/java/design/model/course_search/CourseList.java @@ -65,7 +65,7 @@ public class CourseList implements ICourse { { sorter.sortCourses(courses); } - + /* * All overrides of the ICourse class. This is a drawback of the composite pattern, but it's pretty negligible here. return some dummy values. */ @@ -86,4 +86,10 @@ public class CourseList implements ICourse { @Override public List<Hole> getHoles() { return null; } + + @Override + public String toString() + { + return "Course List"; + } } diff --git a/src/main/java/design/model/course_search/CourseSorter.java b/src/main/java/design/model/course_search/CourseSorter.java index 7549645..8b4d42c 100644 --- a/src/main/java/design/model/course_search/CourseSorter.java +++ b/src/main/java/design/model/course_search/CourseSorter.java @@ -8,4 +8,6 @@ import java.util.List; */ public interface CourseSorter { public void sortCourses(List<ICourse> courses); + public String toString(); + public boolean isEqual(ICourse a, ICourse b); }
\ No newline at end of file diff --git a/src/main/java/design/model/course_search/CurrentSearchQuery.java b/src/main/java/design/model/course_search/CurrentSearchQuery.java new file mode 100644 index 0000000..e1f52ce --- /dev/null +++ b/src/main/java/design/model/course_search/CurrentSearchQuery.java @@ -0,0 +1,155 @@ +package design.model.course_search; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; + +import design.persistence.MasterDatabase; + +/* + * Represents the state of our current search. + */ +public class CurrentSearchQuery { + public static final CurrentSearchQuery INSTANCE = new CurrentSearchQuery(); + + // initialize our search with the master db data + MasterDatabase db = MasterDatabase.INSTANCE; + private CourseList query = db.getCourseList(); + private final List<CourseSorter> filters = new ArrayList<CourseSorter>(); + + // reset the query + public void reset() + { + query = db.getCourseList(); + } + + // add a new filter + public void addFilter(CourseSorter filter) + { + filters.add(filter); + } + + // clear the filters + public void clearFilters() + { + filters.clear(); + } + + // print out the filters we're currently using and the order + public String printFilters() + { + String filterResult = ""; + + // no filters? let the user know. + if(filters.size() == 0) + { + return "nothing"; + } + + for( CourseSorter f : filters) + { + filterResult += f.toString() + " --> "; + } + + // remove last arrow and add padding + filterResult = filterResult.substring(0, filterResult.length() - 5); + filterResult += "\n"; + + return filterResult; + } + + // get all the filters + public List<CourseSorter> getFilters() + { + return filters; + } + + // get our current query. + public CourseList getQueryResult() + { + return query; + } + + public void search(String searchQuery) + { + // only grab courses which fit our search + List<ICourse> courses = db.getCourseList().getCourses().stream() + .filter(s -> s.toString().toLowerCase().contains(searchQuery.toLowerCase())) + .collect(Collectors.toList()); + + // and now, we filter it! + CourseList filtered = applyFilters(filters, courses); + query.setCourses(filtered.getCourses()); + } + + // to apply our filters we need to traverse the tree and make new grouping as we go. + public CourseList applyFilters(List<CourseSorter> filters, List<ICourse> coursesToFilter) + { + CourseList root = new CourseList(); + root.setCourses(applyFiltersRecursive(coursesToFilter, filters, 0)); + return root; + } + + // the actual recursive part. Level is how many filters deep we are. + private List<ICourse> applyFiltersRecursive(List<ICourse> courses, List<CourseSorter> filters, int level) + { + // base case. we have gone past all filters or theres only one course in this list. already sorted! + if (level >= filters.size() || courses.size() <= 1) + { + return courses; + } + + // grab out current sorting strategy for this level, and sort the courselist. + CourseSorter sorter = filters.get(level); + sorter.sortCourses(courses); + + // the resulting sorted list, with new groupings + List<ICourse> result = new ArrayList<>(); + + // courses with an equal value. + List<ICourse> currentGroup = new ArrayList<>(); + + ICourse prev = null; + + // run through the courses, if + for (ICourse c : courses) + { + /* always add the first course to a new group. when iterating through courses, if we have to values that are equal, we need to add them into a group together. + * think about it this way. If we have [ 1, 2, 2, 2, 3, 4 ]. 1 is first, so its in it's own group. 2 /= 1, so 2 gets its own group. + * now do 2 again. we add it to the existing group 2. Same with the next 2. Now 3. 3 /= 2, so we put it in it's own group. + */ + if (prev == null || !sorter.isEqual(prev, c)) + { + // already a course in that group? we now have two equal values and so + if (!currentGroup.isEmpty()) + { + result.add(makeGroup(currentGroup, filters, level)); + currentGroup = new ArrayList<>(); + } + } + + currentGroup.add(c); + prev = c; + } + + // handle the last group. + if (!currentGroup.isEmpty()) + { + result.add(makeGroup(currentGroup, filters, level)); + } + + return result; + } + + // make a CourseList group, a sublist of a group, and filter it. + private ICourse makeGroup(List<ICourse> group, List<CourseSorter> filters, int level) + { + // base case, group only has one course in it (already sorted) + if (group.size() == 1) return group.get(0); + + // group has more than 1 course in it, it needs to be sorted more if possible. + CourseList subList = new CourseList(); + subList.setCourses(applyFiltersRecursive(group, filters, level + 1)); + return subList; + } +} diff --git a/src/main/java/design/model/course_search/SortByDifficulty.java b/src/main/java/design/model/course_search/SortByDifficulty.java index 8c3251c..c6bb7ac 100644 --- a/src/main/java/design/model/course_search/SortByDifficulty.java +++ b/src/main/java/design/model/course_search/SortByDifficulty.java @@ -8,8 +8,22 @@ import java.util.Comparator; * Willem Dalton */ public class SortByDifficulty implements CourseSorter { + + @Override public void sortCourses(List<ICourse> courses) { - courses.sort(Comparator.comparing(ICourse::getDifficultyRating)); + courses.sort(Comparator.comparing(ICourse::getDifficultyRating).reversed()); // hardest to easiest + } + + @Override + public boolean isEqual(ICourse a, ICourse b) + { + return a.getDifficultyRating() == b.getDifficultyRating(); + } + + @Override + public String toString() + { + return "Difficulty"; } }
\ No newline at end of file diff --git a/src/main/java/design/model/course_search/SortByHoles.java b/src/main/java/design/model/course_search/SortByHoles.java index b1badab..33c5473 100644 --- a/src/main/java/design/model/course_search/SortByHoles.java +++ b/src/main/java/design/model/course_search/SortByHoles.java @@ -8,8 +8,23 @@ import java.util.Comparator; * Willem Dalton */ public class SortByHoles implements CourseSorter { + + @Override public void sortCourses(List<ICourse> courses) { - courses.sort(Comparator.comparing(ICourse::getHoleCount)); + courses.sort(Comparator.comparing(ICourse::getHoleCount).reversed()); // highest par to lowest par } -}
\ No newline at end of file + + @Override + public boolean isEqual(ICourse a, ICourse b) + { + return a.getHoleCount() == b.getHoleCount(); + } + + @Override + public String toString() + { + return "Hole Count"; + } + +} diff --git a/src/main/java/design/model/course_search/SortByLocation.java b/src/main/java/design/model/course_search/SortByLocation.java index 0d8a8d2..98ca0c6 100644 --- a/src/main/java/design/model/course_search/SortByLocation.java +++ b/src/main/java/design/model/course_search/SortByLocation.java @@ -8,8 +8,22 @@ import java.util.Comparator; * Willem Dalton */ public class SortByLocation implements CourseSorter { + + @Override public void sortCourses(List<ICourse> courses) { courses.sort(Comparator.comparing(ICourse::getLocation)); } + + @Override + public boolean isEqual(ICourse a, ICourse b) + { + return a.getLocation().equals(b.getLocation()); + } + + @Override + public String toString() + { + return "Location"; + } }
\ No newline at end of file diff --git a/src/main/java/design/model/course_search/SortByName.java b/src/main/java/design/model/course_search/SortByName.java index 2847d3e..17553a8 100644 --- a/src/main/java/design/model/course_search/SortByName.java +++ b/src/main/java/design/model/course_search/SortByName.java @@ -8,8 +8,22 @@ import java.util.Comparator; * Willem Dalton */ public class SortByName implements CourseSorter { + + @Override public void sortCourses(List<ICourse> courses) { courses.sort(Comparator.comparing(ICourse::getName)); } + + @Override + public boolean isEqual(ICourse a, ICourse b) + { + return a.getName().equals(b.getName()); + } + + @Override + public String toString() + { + return "Name"; + } }
\ No newline at end of file diff --git a/src/main/java/design/model/course_search/SortByPar.java b/src/main/java/design/model/course_search/SortByPar.java index 9a3eaf9..203aeaf 100644 --- a/src/main/java/design/model/course_search/SortByPar.java +++ b/src/main/java/design/model/course_search/SortByPar.java @@ -8,8 +8,22 @@ import java.util.Comparator; * Willem Dalton */ public class SortByPar implements CourseSorter { + + @Override public void sortCourses(List<ICourse> courses) { courses.sort(Comparator.comparing(ICourse::getTotalPar)); } + + @Override + public boolean isEqual(ICourse a, ICourse b) + { + return a.getTotalPar() == b.getTotalPar(); + } + + @Override + public String toString() + { + return "Total Par"; + } }
\ No newline at end of file |