Page History

Ta utgangspunkt i den abstrakte klassen LoyaltyAward og klassen CarRentalAwards. Disse klassene implementerer metoder for å tildele poeng til en bruker ut ifra hvilket bilmerke den har leid.

Under implementasjonen av disse klassene har det kommet inn to feil som eksponeres ved kjøring av main-metoden i CarRentalAwards.

Rett opp feilene (dette vil innebære både at koden ikke krasjer og at riktig logikk utføres).

Følgende metoder finnes i LoyaltyAward:

• LoyaltyAward(String awardName) - Oppretter et LoyaltyAward objekt med det gitte navnet.
• setAwardName(String awardName) - Oppdaterer navnet på prisen.
• awardPoints(int points, LoyaltyUser loyaltyUser) Gir antall poeng til den gitte brukeren.

Følgende metoder finnes i CarRentalAwards:

• CarRentalAwards(String awardName Oppretter et CarRentalAwards objekt med det gitte navnet.
• setAwardName(String awardName) - Oppdaterer navnet på prisen dersom det er gyldig.
• awardPoints(int carBrand, LoyaltyUser loyaltyUser) - Gir et visst antall poeng til den gitte brukeren. Antall poeng er beregnet ut ifra hvilket bilmerke brukeren har leid.

public abstract class LoyaltyAward {

	private String awardName;

	public LoyaltyAward(String awardName) {
		this.setAwardName(awardName);
	}

	/**
	 * Updates the name of the award
	 * @param awardName the new award name
	 */
	public void setAwardName(String awardName) {
		this.awardName = awardName;
	}

	/**
	 * Adds the points to the given loyalty user.
	 *
	 * @param points      The points to award to the user
	 * @param loyaltyUser The user that rented the car
	 */

	public void awardPoints(int points, LoyaltyUser loyaltyUser) {
		loyaltyUser.addPoints(points);
	}
}


import java.util.Arrays;
import java.util.List;
import java.util.Map;

public class CarRentalAwards extends LoyaltyAward {

	private Map<Integer, Integer> carBrandToPoints = Map.of(1, 1, 2, 10, 3, 100, 4, 200, 5, 500);
	private List<String> validNames = Arrays.asList("CarRentalAgency1", "CarRentalAgency2");

	public CarRentalAwards(String awardName) {
		super(awardName);
	}

	@Override
	/**
	 * Updates the award name
	 * @param: awardName The name of the award
	 * 
	 * @throws IllegalArgumentException If the award name is not part of the valid
	 *                                  names
	 */
	public void setAwardName(String awardName) {
		if (!validNames.contains(awardName)) {
			throw new IllegalArgumentException("Invalid award name");
		}
		super.setAwardName(awardName);
	}

	/**
	 * Updates the status of the given LoyaltyUser with points based on the map
	 * above. The map means that carBrand 1 will award 1 points, carBrand 2 will
	 * award 10 points etc
	 * 
	 * @param carBrand:    The brand of the car the user has rented. If the brand
	 *                     does not exist 0 points should be awarded
	 * 
	 * @param loyaltyUser: The user that rented the car
	 * 
	 * 
	 */
	public void awardPoints(int carBrand, LoyaltyUser loyaltyUser) {
		Integer points = carBrandToPoints.get(carBrand);
		if (points != null) {
			awardPoints(points, loyaltyUser);
		}
	}

	public static void main(String[] args) {
		LoyaltyUser user = new LoyaltyUser("Name");
		// What goes wrong here
		LoyaltyAward award = new CarRentalAwards("CarRentalAgency1");
		// What goes wrong here
		award.awardPoints(1, user);
		System.out.println(user.getPoints());
	}

}

Ta utgangspunkt i den vedlagte Course-klassem. Denne klassen trengs ikke å endres for oppgaven. Course-klassen har oversikt over:

• Et navn.
• Gjennomsnittskarakter.
• Andre emner som er forkunnskapskrav til dette emnet.

Du skal fylle ut UniversityHandbook -klassen sine metoder for å kunne lese emner fra fil og holde oversikt over disse emenene. Det vil bli gitt poeng etter følgende oppnåelse, så dersom du ikke får til hele oppgaven vil du få uttelling for delvis løsning.

1. Lese inn emners navn og gjennomsnittskarakter fra fil.
2. Støtte å legge til forkunnskapskrav om emner som har vært tidligere i filen.
3. Støtte å legge til forkunnskapskrav om emner som kommer senere i filen.

Følgende metoder skal fullføres/implementeres:

• readFromInputStream(InputStream stream) - Leser inn emner fra en gitt inputStream. (Se eksempelfilen i src/main/resources/del7_og_8/courses.txt for hvordan disse kan se ut.)
• getCourse(String courseName) - Returnerer emnet med det gitte navnet.

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class Course {
	// The name of the course
	private String courseName;
	// A list of course prerequisites for this course. This means that all the courses in this list should be taken before this one. 
	private List<Course> prerequisites = new ArrayList<>();
	// The average grade of the course
	private double averageGrade;

	public Course(String courseName, double averageGrade) {
		this(courseName);
		this.averageGrade = averageGrade;
	}

	public Course(String courseName) {
		this.courseName = courseName;
	}
	
	public String getCourseName() {
		return courseName;
	}

	public void setAverageGrade(double averageGrade) {
		this.averageGrade = averageGrade;
	}
	
	public double getAverageGrade() {
		return averageGrade;
	}
	
	/**
	 * Adds a new prerequisite to this course
	 * @param course The course to add
	 */
	public void addPrequisite(Course course) {
		this.prerequisites.add(course);
	}
	
	/**
	 * 
	 * @return A copy of the list of prerequisites
	 */
	public Collection<Course> getPrerequisites() {
		return new ArrayList<>(prerequisites);
	}
	
	public String toString() {
		return this.courseName;
	}

}


import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class UniversityHandbook {

	private List<Course> courses = new ArrayList<>();

	/**
	 * Reads all the courses from a given input stream. The courses are on this
	 * form: courseName, averageGrade, prerequisite 1, prerequisite 2,
	 * prerequisite 3....
	 * 
	 * See courses.txt in src/main/resources/del7_og_8 for an example file.
	 * 
	 * Calling this method should remove any existing courses from the handbook.
	 * 
	 * A given course can have anything from 0 to unlimited number of prerequisites.
	 * The courses do not necessary come in order. Meaning that a course may appear
	 * in the prerequisite list as a never before seen course. The method should read
	 * in all courses, and set the courseName, averageGrade and prerequisites of all
	 * courses and add the courses to the courses field of this class.
	 * 
	 * A skeleton code to read from file is provided to you but feel free to write
	 * your own code for this.
	 * 
	 * You can assume that all lines from the file will be on the correct format.
	 * 
	 * @param stream InputStream containing the course data
	 */
	public void readFromInputStream(InputStream stream) {
		try (Scanner scanner = new Scanner(stream)) {
			while (scanner.hasNextLine()) {
				String line = scanner.nextLine();
				String[] details = line.split(",");
				// TODO - Continue implementation here
			}
		}
	}

	/**
	 * Gets the course with the courseName
	 * 
	 * @param courseName The name of the course
	 * 
	 * @return The course with the given name
	 */
	public Course getCourse(String courseName) {
		...
	}
}

import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Scanner;

public class UniversityHandbook {

	private Collection<Course> courses = new ArrayList<>();

	/**
	 * Reads all the courses from a given input stream. The courses are on this
	 * form: courseName, averageGrade, prerequisite 1, prerequisite 2,
	 * prerequisite 3....
	 * 
	 * See courses.txt in src/main/resources/del7_og_8 for an example file.
	 * 
	 * Calling this method should remove any existing courses from the handbook.
	 * 
	 * A given course can have anything from 0 to unlimited number of prerequisites.
	 * The courses do not necessary come in order. Meaning that a course may appear
	 * in the prerequisite list as a never before seen course. The method should read
	 * in all courses, and set the courseName, averageGrade and prerequisites of all
	 * courses and add the courses to the courses field of this class.
	 * 
	 * A skeleton code to read from file is provided to you but feel free to write
	 * your own code for this.
	 * 
	 * You can assume that all lines from the file will be on the correct format.
	 * 
	 * @param stream InputStream containing the course data
	 */
	public void readFromInputStream(InputStream stream) {
		this.courses = new ArrayList<>();
		try (Scanner scanner = new Scanner(stream)) {
			while (scanner.hasNextLine()) {
				String line = scanner.nextLine();
				String[] details = line.split(",");
				String courseName = details[0];
				double averageGrade = Double.parseDouble(details[1]);
				Course course = this.findOrCreateCourse(courseName);
				course.setAverageGrade(averageGrade);
				
				for (int i=2;i<details.length; i++) {
					String prequesite = details[i];
					Course coursePrequesite = findOrCreateCourse(prequesite);
					course.addPrequisite(coursePrequesite);
				}
				
			}
		}
	}


	/**
	 * Get's the course with the courseName
	 * 
	 * @param courseName The name of the course
	 * 
	 * @return The course with the given name
	 */
	public Course getCourse(String courseName) {
		for(Course course: courses) {
			if (course.getCourseName().equals(courseName)) {
				return course;
			}
		}
		return null;
	}

	private Course findOrCreateCourse(String name) {
		Course course = getCourse(name);
		if (course != null) {
			return course;
		}
		course = new Course(name);
		this.courses.add(course);
		return course;
	}
}

Fyll ut UniversityHandbookUtils sine metoder for operasjoner på en liste med Course-objekter.

Følgende metoder skal implementeres:

• getCoursesWithPredicate(Collection courses, Predicate p) - Returnerer alle emner i samlingen som tilfredstiller predikatet.
• getNonPrequisiteCourses(Collection courses) - Returnerer alle emner i samlingen som ikke har noen forkunnskapskrav.

• containsImpossibleCourse(Collection courses) - Returnerer hvorvidt samlingen av emner inneholder et emne som er umulig. Et umulig emne er definert som et emne X som har et forkunnskaps krav, som har emnet X som forkunnskapskrav.

  Expand
  title Kodeskjelett del 8
  Code Block language java import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.List; import java.util.function.Predicate; public class UniversityHandbookUtils { /** * Get all courses that matches the given predicate * * @param courses The list of courses to check for * @param p The predicate that should be matched on * * @return A collection of courses that satisfy the predicate. */ public static Collection<Course> getCoursesWithPredicate(Collection<Course> courses, Predicate<Course> p) { ... } /** * Get all courses that does not have any prerequisites * * @param courses The list of courses to check for * @return A collection of course without any prerequisites */ public static Collection<Course> getNonPrequisiteCourses(Collection<Course> courses) { ... } /** * Returns whether the handbook contains an impossible course. A course is * deemed impossible if any of the prerequisite of the course has the current * course as a prerequisite. Only direct dependencies need to be checked. You * do not need to worry about transitive dependencies. That means if TDT4100 has * a dependency on TDT4110 and TDT4110 has a dependency on TDT4100 it is impossible. * * A transitive dependency that does not need to be checked is if TDT4100 has a * dependency on TDT4110, TDT4110 has dependency on TDT4200 and TDT4200 has a * dependency on TDT4100. * * @param courses The list of courses to check for * @return whether the courses contains an impossible course */ public static boolean containsImpossibleCourse(Collection<Course> courses) { ... } }

  
  

  Expand
  title LF
  Code Block language java import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.List; import java.util.function.Predicate; import java.util.stream.Collectors; public class UniversityHandbookUtils { /** * Get all courses that matches the given predicate * * @param courses The list of courses to check for * @param p The predicate that should be matched on * * @return A collection of courses that satisfy the predicate. */ public static Collection<Course> getCoursesWithPredicate(Collection<Course> courses, Predicate<Course> p) { return courses.stream().filter(p).collect(Collectors.toList()); } /** * Get all courses that does not have any prerequisites * * @param courses The list of courses to check for * @return A collection of course without any prerequisites */ public static Collection<Course> getNonPrequisiteCourses(Collection<Course> courses) { return courses.stream().filter(course -> course.getPrerequisites().size() == 0).collect(Collectors.toList()); } /** * Returns whether the handbook contains an impossible course. A course is * deemed impossible if any of the prerequisite of the course has the current * course as a prerequisite. Only direct dependencies need to be checked. You * do not need to worry about transitive dependencies. That means if TDT4100 has * a dependency on TDT4110 and TDT4110 has a dependency on TDT4100 it is impossible. * * A transitive dependency that does not need to be checked is if TDT4100 has a * dependency on TDT4110, TDT4110 has dependency on TDT4200 and TDT4200 has a * dependency on TDT4100. * * @param courses The list of courses to check for * @return whether the courses contains an impossible course */ public static boolean containsImpossibleCourse(Collection<Course> courses) { return courses.stream().anyMatch(course -> course.getPrerequisites().stream().anyMatch(prerequesite -> prerequesite.getPrerequisites().contains(course))); } }