From ddcfcf82baf737e183ec7b00edeee26894516c58 Mon Sep 17 00:00:00 2001 From: sowgro Date: Thu, 9 Oct 2025 08:06:56 -0400 Subject: fix formatting --- .../design/model/course_search/CourseList.java | 66 ++++++++++--------- .../model/course_search/CurrentSearchQuery.java | 75 +++++++++------------- .../model/course_search/SortByDifficulty.java | 13 ++-- .../design/model/course_search/SortByHoles.java | 13 ++-- .../design/model/course_search/SortByLocation.java | 15 ++--- .../design/model/course_search/SortByName.java | 13 ++-- .../java/design/model/course_search/SortByPar.java | 13 ++-- 7 files changed, 90 insertions(+), 118 deletions(-) (limited to 'src/main/java/design/model/course_search') diff --git a/src/main/java/design/model/course_search/CourseList.java b/src/main/java/design/model/course_search/CourseList.java index 360dc9b..c2411f7 100644 --- a/src/main/java/design/model/course_search/CourseList.java +++ b/src/main/java/design/model/course_search/CourseList.java @@ -1,10 +1,10 @@ package design.model.course_search; +import design.model.Hole; + import java.util.ArrayList; import java.util.List; -import design.model.*; - /* * Defines a list of courses that can be sorted, added to or removed from. * Willem Dalton @@ -13,83 +13,87 @@ public class CourseList implements ICourse { private CourseSorter sorter; private List courses; - public CourseList() - { + public CourseList() { courses = new ArrayList<>(); } /* * Grab the list of courses */ - public List getCourses() - { + public List getCourses() { return courses; } /* * Set the list of courses equal to an existing list */ - public void setCourses(List courses) - { + public void setCourses(List courses) { this.courses = courses; } /* - * set the chosen sorting algorithm for the given list. - */ - public void setSorter(CourseSorter courseSorter) - { + * set the chosen sorting algorithm for the given list. + */ + public void setSorter(CourseSorter courseSorter) { sorter = courseSorter; } /* * Add a new course to the list. */ - public void add(ICourse course) - { + public void add(ICourse course) { courses.add(course); } /* - * Remove a course from the list. + * Remove a course from the list. */ - public void remove(ICourse course) - { + public void remove(ICourse course) { courses.remove(course); } /* * Sort the list. */ - public void sort() - { + public void sort() { 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. */ @Override - public String getName() { return "Course List"; } - + public String getName() { + return "Course List"; + } + @Override - public float getDifficultyRating() { return 0; } + public float getDifficultyRating() { + return 0; + } @Override - public String getLocation() { return ""; } - + public String getLocation() { + return ""; + } + @Override - public int getTotalPar() { return 0; } + public int getTotalPar() { + return 0; + } @Override - public int getHoleCount() { return 0; } + public int getHoleCount() { + return 0; + } @Override - public List getHoles() { return null; } + public List getHoles() { + return null; + } - @Override - public String toString() - { + @Override + public String toString() { return "Course List"; } } diff --git a/src/main/java/design/model/course_search/CurrentSearchQuery.java b/src/main/java/design/model/course_search/CurrentSearchQuery.java index e1f52ce..999dfcb 100644 --- a/src/main/java/design/model/course_search/CurrentSearchQuery.java +++ b/src/main/java/design/model/course_search/CurrentSearchQuery.java @@ -1,81 +1,72 @@ package design.model.course_search; +import design.persistence.MasterDatabase; + 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 filters = new ArrayList(); // reset the query - public void reset() - { + public void reset() { query = db.getCourseList(); } // add a new filter - public void addFilter(CourseSorter filter) - { + public void addFilter(CourseSorter filter) { filters.add(filter); } // clear the filters - public void clearFilters() - { + public void clearFilters() { filters.clear(); } // print out the filters we're currently using and the order - public String printFilters() - { + public String printFilters() { String filterResult = ""; // no filters? let the user know. - if(filters.size() == 0) - { + if (filters.size() == 0) { return "nothing"; } - for( CourseSorter f : filters) - { + for (CourseSorter f : filters) { filterResult += f.toString() + " --> "; } // remove last arrow and add padding - filterResult = filterResult.substring(0, filterResult.length() - 5); + filterResult = filterResult.substring(0, filterResult.length() - 5); filterResult += "\n"; return filterResult; } // get all the filters - public List getFilters() - { + public List getFilters() { return filters; } // get our current query. - public CourseList getQueryResult() - { + public CourseList getQueryResult() { return query; } - public void search(String searchQuery) - { + public void search(String searchQuery) { // only grab courses which fit our search List courses = db.getCourseList().getCourses().stream() - .filter(s -> s.toString().toLowerCase().contains(searchQuery.toLowerCase())) - .collect(Collectors.toList()); + .filter(s -> s.toString().toLowerCase().contains(searchQuery.toLowerCase())) + .collect(Collectors.toList()); // and now, we filter it! CourseList filtered = applyFilters(filters, courses); @@ -83,19 +74,16 @@ public class CurrentSearchQuery { } // to apply our filters we need to traverse the tree and make new grouping as we go. - public CourseList applyFilters(List filters, List coursesToFilter) - { + public CourseList applyFilters(List filters, List 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 applyFiltersRecursive(List courses, List 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) - { + private List applyFiltersRecursive(List courses, List 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; } @@ -112,17 +100,14 @@ public class CurrentSearchQuery { ICourse prev = null; // run through the courses, if - for (ICourse c : courses) - { + 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)) - { + * 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()) - { + if (!currentGroup.isEmpty()) { result.add(makeGroup(currentGroup, filters, level)); currentGroup = new ArrayList<>(); } @@ -133,8 +118,7 @@ public class CurrentSearchQuery { } // handle the last group. - if (!currentGroup.isEmpty()) - { + if (!currentGroup.isEmpty()) { result.add(makeGroup(currentGroup, filters, level)); } @@ -142,8 +126,7 @@ public class CurrentSearchQuery { } // make a CourseList group, a sublist of a group, and filter it. - private ICourse makeGroup(List group, List filters, int level) - { + private ICourse makeGroup(List group, List filters, int level) { // base case, group only has one course in it (already sorted) if (group.size() == 1) return group.get(0); @@ -151,5 +134,5 @@ public class CurrentSearchQuery { 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 c6bb7ac..b8a8aea 100644 --- a/src/main/java/design/model/course_search/SortByDifficulty.java +++ b/src/main/java/design/model/course_search/SortByDifficulty.java @@ -1,29 +1,26 @@ package design.model.course_search; -import java.util.List; import java.util.Comparator; +import java.util.List; /* * Concrete strategy for sorting courses by their difficulty rating. * Willem Dalton */ public class SortByDifficulty implements CourseSorter { - + @Override - public void sortCourses(List courses) - { + public void sortCourses(List courses) { courses.sort(Comparator.comparing(ICourse::getDifficultyRating).reversed()); // hardest to easiest } @Override - public boolean isEqual(ICourse a, ICourse b) - { + public boolean isEqual(ICourse a, ICourse b) { return a.getDifficultyRating() == b.getDifficultyRating(); } @Override - public String toString() - { + 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 33c5473..1971e42 100644 --- a/src/main/java/design/model/course_search/SortByHoles.java +++ b/src/main/java/design/model/course_search/SortByHoles.java @@ -1,29 +1,26 @@ package design.model.course_search; -import java.util.List; import java.util.Comparator; +import java.util.List; /* * Concrete strategy by sorting courses by their hole count (9 or 18) * Willem Dalton */ public class SortByHoles implements CourseSorter { - + @Override - public void sortCourses(List courses) - { + public void sortCourses(List courses) { courses.sort(Comparator.comparing(ICourse::getHoleCount).reversed()); // highest par to lowest par } @Override - public boolean isEqual(ICourse a, ICourse b) - { + public boolean isEqual(ICourse a, ICourse b) { return a.getHoleCount() == b.getHoleCount(); } @Override - public String toString() - { + 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 98ca0c6..f748a51 100644 --- a/src/main/java/design/model/course_search/SortByLocation.java +++ b/src/main/java/design/model/course_search/SortByLocation.java @@ -1,29 +1,26 @@ package design.model.course_search; -import java.util.List; import java.util.Comparator; +import java.util.List; /* * Concrete strategy for sorting courses by their location. * Willem Dalton */ public class SortByLocation implements CourseSorter { - + @Override - public void sortCourses(List courses) - { + public void sortCourses(List courses) { courses.sort(Comparator.comparing(ICourse::getLocation)); } - + @Override - public boolean isEqual(ICourse a, ICourse b) - { + public boolean isEqual(ICourse a, ICourse b) { return a.getLocation().equals(b.getLocation()); } @Override - public String toString() - { + 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 17553a8..68f2a72 100644 --- a/src/main/java/design/model/course_search/SortByName.java +++ b/src/main/java/design/model/course_search/SortByName.java @@ -1,29 +1,26 @@ package design.model.course_search; -import java.util.List; import java.util.Comparator; +import java.util.List; /* * Concrete strategy for sorting courses base on their name. * Willem Dalton */ public class SortByName implements CourseSorter { - + @Override - public void sortCourses(List courses) - { + public void sortCourses(List courses) { courses.sort(Comparator.comparing(ICourse::getName)); } @Override - public boolean isEqual(ICourse a, ICourse b) - { + public boolean isEqual(ICourse a, ICourse b) { return a.getName().equals(b.getName()); } @Override - public String toString() - { + 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 203aeaf..868b39d 100644 --- a/src/main/java/design/model/course_search/SortByPar.java +++ b/src/main/java/design/model/course_search/SortByPar.java @@ -1,29 +1,26 @@ package design.model.course_search; -import java.util.List; import java.util.Comparator; +import java.util.List; /* * Concrete strategy for sorting courses based on their total par. * Willem Dalton */ public class SortByPar implements CourseSorter { - + @Override - public void sortCourses(List courses) - { + public void sortCourses(List courses) { courses.sort(Comparator.comparing(ICourse::getTotalPar)); } @Override - public boolean isEqual(ICourse a, ICourse b) - { + public boolean isEqual(ICourse a, ICourse b) { return a.getTotalPar() == b.getTotalPar(); } @Override - public String toString() - { + public String toString() { return "Total Par"; } } \ No newline at end of file -- cgit v1.2.3