OOP2 | Gitar

Major refactor of code + add info about design choices

Author: Vngngdn
Date: Dec. 16, 2016, 2:38 a.m.
Hash: 3c3f7b0921297dda9295fdf1db792c697d92e189
Parent: f68e848416b19091f2f20166cbd19ebec9fa4bc3
Modified files: Challenge 6/Bed.java; Challenge 6/Reservation.java; Challenge 6/ReservationController.java; Challenge 6/ReservationView.java; Challenge 6/Room.java; Challenge 6/RoomController.java; Challenge 6/Window.java; Challenge 6/ontwerpkeuzes2.md

Challenge 6/Bed.java ¶

11 additions and 10 deletions.

View changes Hide changes

import java.util.Map;
import java.util.HashMap;

/**
/**
 * Class representing a bed in the hostel.
 * Even though beds in a hostel could simply be an integer in a Room, these Beds
 * need to remember on what dates they are reserved.
 * @author Maarten Vangeneugden - 1438256
 */
public class Bed {

	/* Rationale:
	 * I know that a mapping is not necessarily the best solution for storing
	 * periods, because it doesn't offer built-in protection yadda yadda.
	 * However, that's Java's fault, as it doesn't provide a Pair<L,R> thing in
	 * the STL.
	 * The best solution is actually a collection of tuples: (Begin, End), but
	 * that doesn't exist in Java, and thus requires a custom implementation.
	 * All things considered, a Map is the least bad choice.
	 */
	private Map<Date, Date> reservedPeriods;

	public Bed() {
		this.reservedPeriods = new HashMap<>();
	}

	/**
	 * Reserves this Bed for the given period.
	 * This method will mark the given period for this Bed as "reserved", which
	 * can then be cancelled or queried later.
	 * @param begin The time where the reservation begins.
	 * @param end The time where the reservation ends.
	 * @pre No parameter may be a null pointer.
	 * @pre The given period mustn't overlap with a period already marked as
	 * reserved.
	 * @pre begin must come before end.
	 * @pre begin and end mustn't be equal.
	 * @post The given period will be marked as "Reserved", and will have to be
	 * manually cancelled/removed in order to reserve again.
	 * @throws NullPointerException if any parameter is a null pointer.
	 * @throws IllegalArgumentException if begin is equal to, or comes after
	 * end.
	 * @throws DateTimeException if the given period overlaps with an already
	 * reserved period.
	 */
	public void reservePeriod(Date begin, Date end) {
		if(!begin.before(end)) {
			throw IllegalArgumentException("The begin date occurs after the end date.");
		}
		}
		if(!this.isFree(begin, end)) {
			throw DateTimeException("This period overlaps with a reserved period.");
		}
		}
		// Contract validated, execute method
		this.reservedPeriods.put(begin, end);
	}

	/**
	 * Remove a previous registration from this Bed.
	 * This method will remove/cancel the given reservation period from the
	 * Bed, opening it up for reservation again.
	 * @param begin The time where the reservation begins.
	 * @param end The time where the reservation ends.
	 * @pre No parameter may be a null pointer.
	 * @pre The given period must already be marked as "Reserved" in this Bed.
	 * @pre begin must come before end.
	 * @pre begin and end mustn't be equal.
	 * @post The given period will lose its "Reserved" mark, allowing the period
	 * to be reserved again.
	 * @throws NullPointerException if any parameter is a null pointer.
	 * @throws IllegalArgumentException if begin is equal to, or comes after
	 * end; or, if the given period is not reserved.
	 */
	public void removeReservationPeriod(Date begin, Date end) {
		if(!begin.before(end)) {
			throw IllegalArgumentException("The begin date occurs after the end date.");
		}
		}
		if(!this.isFree(begin, end)) {
			throw DateTimeException("This period overlaps with a reserved period.");
		}
		}
		// Contract partially validated; further validation occurs while looking
		// for the reservation.
		// XXX: Check if Java correctly handles equality: 2 different Date
		// objects with the same date representation should be equal!
		boolean reservationFound = this.reservedPeriods.remove(begin, end);
		if(!reservationFound) {
			throw IllegalArgumentException("The given period was not marked as reserved.");
		}
		}
	}
		
	/**
	 * Checks whether this Bed can be reserved in the given period.
	 * Use this method whenever you need to inform yourself about any
	 * conflicting reservation period.
	 * @param begin The time where the reservation begins.
	 * @param end The time where the reservation ends.
	 * @pre No parameter must be a null pointer.
	 * @pre begin must come before end.
	 * @pre begin and end mustn't be equal.
	 * @throws NullPointerException if any parameter is a null pointer.
	 * @throws IllegalArgumentException if begin is equal to, or comes after
	 * end.
	 * @return True if the given period does not overlap with any reservation, false otherwise.
	 */
	public boolean isFree(Date begin, Date end) {
		if(!begin.before(end)) {
			throw IllegalArgumentException("The begin date occurs after the end date.");
		}
		}
		if(!this.isFree(begin, end)) {
			throw DateTimeException("This period overlaps with a reserved period.");
		}
		}
		// Contract validated, execute method
		for(Map.Entry<Date, Date> reservedPeriod: this.reservedPeriods.EntrySet()) {
			Date reservedBegin = reservedPeriod.key();
			Date reservedEnd = reservedPeriod.value();
			/* Forbidden possibilities:
			Date reservedBegin = reservedPeriod.getKey();
			Date reservedEnd = reservedPeriod.getValue();
			/* Forbidden possibilities:
			 * (A,B = reserved; X,Y = requested)
			 * X-A-Y-B / A-X-B-Y  -  Begins or ends in a reserved period
			 * X-A-B-Y  -  Complete overlapping of reserved period
			 * Allowed possibilities:
			 * A-B-X-Y / X-Y-A-B  -  No overlapping
			 */
			if((begin.after(reservedBegin) && begin.before(reservedEnd)) ||
			   (end.after(reservedBegin) && end.before(reservedEnd))) {
				// Triggered if any forbidden structure is detected
				return false;
			}
		}
		return true; // No overlapping found
	}

	/**
	 * Checks whether this Bed has open reservation periods.
	 * @return True if this Bed has reserved periods, false otherwise.
	 */
	public boolean hasReservations() {
		return !this.reservedPeriods.isEmpty();
	}
}


Challenge 6/Reservation.java ¶

63 additions and 41 deletions.

View changes Hide changes

import java.util.HashSet;
import java.util.Date;

/**
 * Represents a reservation in a hostel.
 * Reservation is a simple class that allows one to store reservation
 * information, request it when necessary, and so on.
 * Certain methods are provided for interaction, which use contracts to assert
 * proper functioning.
 *
 * Note: There is a form of redundancy in this class.
 * Reservation holds a Set of Beds, and an integer, indicating the amount of
 * people that are in this Reservation.
 * Normally, the amount of people in the Reservation is determined by the amount
 * of reserved Beds, because the amount of Beds implied the amount of people to
 * facilitate.
 * Because of the design of this program, I've weighed the advantages and
 * disadvantages of holding this implication, of using a seperate member
 * explicitely indicating the amount of people.
 *
 * I've chosen the latter option. It scales better in terms of weird
 * afterthoughts ("I also want to make people sleep on the floor"), but being
 * explicit is also a tad easier to manage. It also allows the other classes to
 * be far more decoupled from Reservation (otherwise, they'd have to check for
 * errors every time themselves, hindering cohesiveness).
 *
 * To overcome the possible difference, I've made it so that, every time, the
 * relation between the values is changed (the people in the Reservation
 * changes, for example), the class automatically checks if the values are
 * corresponding. If they're not, a warning is printed to system.out.err,
 * informing about the fact that there's a discrepancy.
 *
 * I think that's the best way to overcome this problem.
 * @author Maarten Vangeneugden - 1438256
 */
public class Reservation {

	// Members
	private String groupName;
	private Date begin;
	private Date end;
	private Set<Bed> reservedBeds;
	private Date endDate;
	private Set<Bed> reservedBeds;
	private int people; // The amount of people in this Reservation
	private int reservationID;
	private String roomType; // Room type requested by group
	private Set<String> roomFacilities; // Requested room facilities
	private Set<Date> breakfastDays; // Set of days the group wants breakfast
	// Controllers
	// Controllers
	private RoomController roomController;
	private ReservationController reservationController;

	/**
	 * Create a new Reservation.
	 * Be aware about the limitations of a Reservation: it's not the
	 * Reservation's duty to check whether the provided Beds are properly
	 * reserved; take care of this accordingly.
	 * 
	 * Some information is implicit. For example: The size of the set of
	 * reserved Beds implies the amount of people in the group; no breakfast
	 * days implies no breakfast, ...
	 * @param groupName The name of the group.
	 * @param people The amount of people that are reserving.
	 * @param begin The date that the Reservation begins.
	 * @param end The date that the Reservation ends.
	 * @param reservedBeds The set of Beds reserved and assigned to this
	 * @param endDate The date that the Reservation ends.
	 * @param reservedBeds The set of Beds reserved and assigned to this
	 * Reservation.
	 * @param roomType The requested room type.
	 * @param roomFacilities The set of all requested room facilities.
	 * @param breakfastDays A set of all days that the group wants breakfast.
	 * @param reservationID An ID for this reservation, to differentiate from
	 * other Reservations.
	 * @pre No parameter must be a null pointer.
	 * @pre people must be a natural number, different from 0.
	 * @pre begin must come before end.
	 * @pre All dates in breakfastDays must fall between begin and end.
	 * @pre No string parameter may be empty.
	 * @pre All dates in breakfastDays must fall between beginDate and endDate.
	 * @pre No string parameter may be empty.
	 * @post The amount of people in the Reservation is determined by the amount
	 * of reserved Beds.
	 * @throws NullPointerException if any parameter is a null pointer.
	 * @throws IllegalArgumentException if any of the other preconditions is not
	 * met.
	 */
	public Reservation(String groupName, int people, Date begin, Date end, Set<Bed> reservedBeds, String roomType, Set<String> roomFacilities, Set<Date> breakfastDays) {
		// Contract validation:
		// Contract validation:
		if(people < 1) {
			throw IllegalArgumentException("The amount of people should be at least 1.");
		}
		}
		if(!begin.before(end)) {
			throw IllegalArgumentException("The begin date occurs after the end date.");
		}
			throw new IllegalArgumentException("The begin date occurs after the end date.");
		}
		if(groupName.isEmpty() || roomType.isEmpty()) {
			throw IllegalArgumentException("groupName and/or roomType were empty strings.");
		}
		}
		for(String roomFacility: roomFacilities) {
			if(roomFacility.isEmpty()) {
				throw IllegalArgumentException("One of the room facilities was an empty string.");
			}
			}
		}
		for(Date breakfastDay : breakfastDays) {
			if(breakfastDay.before(begin) || breakfastDay.after(end)) {
				throw IllegalArgumentException("One of the breakfast days occurs before/after the reservation period.");
			}
				throw new IllegalArgumentException("One of the breakfast days occurs before/after the reservation period.");
			}
		}
		// Contract validated, execute constructor
		this.groupName = groupName;
		this.people = people;
		this.beginDate = begin;
		this.endDate = end;
		this.reservedBeds = reservedBeds;
		this.endDate = endDate;
		this.reservedBeds = reservedBeds;
		this.reservationID = reservationID;
		this.roomType = roomType;
		this.roomFacilities = roomFacilities;
		this.breakfastDays = breakfastDays;
	}
	
	/**
	 * Construct template Reservation.
	 * Use this constructor if you need to create an empty/new Reservation. 
	 * It omits the standard restrictions (for example, the group name will be
	 * empty) to accomodate for the expected usage of this Reservation.
	 */
	public Reservation() {
		this.groupName = "";
		this.people = 1;
		this.beginDate = new Date();
		this.endDate = new Date();
		this.reservedBeds = new HashSet<>();
		this.reservationID = 0;
		this.roomType = "";
		this.roomFacilities = new HashSet<>();
		this.breakfastDays = new HashSet<>();
	}

	/**
	 * Checks whether the amount of people corresponds with the reserved Beds.
	 * Call this method whenever a change in the amount of Beds, or the amount
	 * of people is made, or, whenever you need to assure consistency.
	 *
	 * It also prints a warning to system.out.err to inform about a discrepancy,
	 * should one be found.
	 *
	 * @return True if the counts are consistent, false otherwise.
	 */
	private boolean checkPeopleCountConsistency() {
		int people = this.getPeople();
		int beds = this.getReservedBeds().size();
		if(people != beds) {
			system.out.err("There's a discrepancy in the amount of people in Reservation"+
					this.reservationID +":");
					this.reservationID +":");
			system.out.err("People: "+String.valueOf(people));
			system.out.err("Reserved Beds: "+String.valueOf(beds));
			return false;
			System.err.println("Reserved Beds: "+String.valueOf(beds));
			return false;
		}
		return true;
	}

	/**
	 * Set the group name for this Reservation.
	 * @param groupName The new group name.
	 * @pre groupName mustn't be empty, or a null pointer.
	 * @post The group name is changed to the given name.
	 * @throws NullPointerException if groupName is a null pointer.
	 * @throws IllegalArgumentException if groupName is an empty String.
	 */
	public void setGroupName(String groupName) {
		if(groupName.isEmpty())
			throw IllegalArgumentException("groupName is an empty String.");
		this.groupName = groupName;
		this.groupName = groupName;
	}

	/**
	 * Retrieve the current group name.
	 * @return The group name of this Reservation.
	 */
	public String getGroupName() {
		return this.groupName;
	}

	/**
	 * Get amount of people in this Reservation.
	 * @post A warning will be printed to system.out.err if the amount of people
	 * is inconsistent with the amount of reserved Beds.
	 * @see Reservation.checkPeopleCountConsistency
	 * @return The amount of people in this Reservation.
	 */
	public int getPeople() {
		this.checkPeopleCountConsistency();
		return this.people;
	}

	/**
	 * Set the amount of people for this Reservation.
	 * Note that this method will not notify you if the new amount of people is
	 * equal to the previous amount.
	 * 
	 * This method will print
	 * @param people The new amount of people in this Reservation.
	 * @pre people must be at least 1.
	 * @post A warning will be printed to system.out.err if the amount of people
	 * is inconsistent with the amount of reserved Beds.
	 * @post The amount of people is changed to the given value.
	 * @throws IllegalArgumentException if people is less than 1.
	 */
	public void setPeople(int people) {
		if(people < 1) {
			throw IllegalArgumentException("people must be at least 1.");
		}
		}
		this.people = people;
		this.checkPeopleCountConsistency();
	}
	/**
	/**
	 * Returns a copy of the begin Date of this Reservation.
	 * @return a copy of the begin Date of this Reservation.
	 */
	public Date getBeginDate() {
		return (Date)this.beginDate.clone();
	}

	/**
	 * Set the begin date for this Reservation.
	 * @param begin The new begin date.
	 * @pre begin mustn't be a null pointer.
	 * @pre begin must come strictly before the end date.
	 * @post The begin date is updated accordingly.
	 * @pre beginDate mustn't be a null pointer.
	 * @pre beginDate must come strictly before the end date.
	 * @post The begin date is updated accordingly.
	 * @throws NullPointerException if begin is a null pointer.
	 * @throws IllegalArgumentException if begin comes after the end date.
	 */
	 * @throws IllegalArgumentException if beginDate comes after the end date.
	 */
	public void setBegin(Date begin) {
		if(!begin.before(this.getEnd()))
			throw IllegalArgumentException("begin comes after the end date.");
		this.begin = begin;
	}
		if(!beginDate.before(this.beginDate))
			throw new IllegalArgumentException("beginDate comes after the end date.");
		this.beginDate = beginDate;
	}

	

	 * Returns a copy of the end Date of this Reservation.
	 * @return a copy of the end Date of this Reservation.
	 */
	public Date getEndDate() {
		return (Date)this.endDate.clone();
	}

	/**
	 * Set the end date for this Reservation.
	 * @param end The new end date.
	 * @pre end mustn't be a null pointer.
	 * @pre end must come strictly after the begin date.
	 * @post The end date is updated accordingly.
	 * @pre endDate mustn't be a null pointer.
	 * @pre endDate must come strictly after the begin date.
	 * @post The end date is updated accordingly.
	 * @throws NullPointerException if end is a null pointer.
	 * @throws IllegalArgumentException if end comes after the end date.
	 */
	 * @throws IllegalArgumentException if endDate comes after the begin date.
	 */
	public Date getDate() {
		return date;
	}
		if(!endDate.before(this.endDate))
			throw new IllegalArgumentException("endDate comes before the begin date.");
		this.endDate = endDate;
	}

	public void setReservedBeds(Set<Bed> reservedBeds) {
		this.reservedBeds = reservedBeds;
		this.checkPeopleCountConsistency();
	}

	public Set<Bed> getReservedBeds() {
		return reservedBeds;
		this.checkPeopleCountConsistency();
	}

	// TODO: Write documentation for all of these, even though it's all mostly
	// copy/pasting. pfffff
	public void setReservationID(int reservationID) {
		this.reservationID = reservationID;
	}

	public int getReservationID() {
		return reservationID;
	}

	public void setRoomType(String roomType) {
		this.roomType = roomType;
	}

	public String getRoomType() {
		return roomType;
	}

	public void setRoomFacilities(Set<String> roomFacilities) {
		this.roomFacilities = roomFacilities;
	}

	public Set<String> getRoomFacilities() {
		return roomFacilities;
	}

	/**
	 * Calculates the price of the Reservation, based on its current state.
	 * Price table:
	 * - 20/person/day
	 *   - 5 less in low season, 5 more in high season
	 * - 4/breakfast ordered
	 * - If room is fully booked by the group --> 10% discount
	 * @return The price in euros.
	 */
	public int getPrice() {
		int totalPrice = 0;
		// Jan - Apr: Mid
		// May - Aug: High
		// Sep - Dec: Low
		
		// Calculate bed prices
		int month = this.getDate().getMonth();
		int bedPrice = 20;
		int bedPrice = 20;
		if(month >=8) { // From September:
			bedPrice -= 5;
		} else if(month >=4) { // From May:
			bedPrice += 5;
		}
		totalPrice += (this.getReservedBeds().size() * this.getNights() * bedPrice);
		// Calculate price for breakfasts
		// allows to retrieve the days between them, because the difference is
		// expressed in milliseconds (nights = ΔDate ÷ 1000 ÷ 60 ÷ 60 ÷ 24)
		long deltaDate = this.getEndDate().getTime() - this.getBeginDate().getTime();
		long nights = deltaDate/1000/60/60/24;
		totalPrice += (this.getReservedBeds().size() * nights * bedPrice);
		// Calculate price for breakfasts
		int breakfasts = this.getBreakfastDays().length;
		totalPrice += breakfasts * this.getReservedBeds().size();
		// Check if eligible for discount
		for(Room room: roomController.getRooms()) {
			Set<Bed> roomBeds = room.getBeds();
			if(roomBeds.containsAll(this.reservedBeds)) {
				double discount = (double)totalPrice * 0.1;
				totalPrice -= (int)discount;
			}
		}
		return totalPrice;
	}







	public void setBreakfastDays(int[] breakfastDays) {
		this.breakfastDays = breakfastDays;
	}
	public int[] getBreakfastDays() {
		return this.breakfastDays;
	}

}


Challenge 6/ReservationController.java ¶

10 additions and 8 deletions.

View changes Hide changes

import java.util.HashSet;
import java.util.Date;

/**
 * Controller class for the Reservations of this program.
 * Since this program handles a youth hostel, it's imperative that it holds a
 * number of Reservations.
 * 
 * ReservationController takes the responsibility of handling the addition,
 * cancelling, editing, ... of Reservations, and the related tasks inherent to
 * these responsibilities, such as reserving beds, generating IDs, ...
 * @author Maarten Vangeneugden - 1438256
 */
public class ReservationController {

	/* Rationale:
	 * Normally I'd put this as an interface (Set), but an interface does not
	 * inherit from Object, and thus, does not provide clone(). This is
	 * necessary, because otherwise, there's no point in having private
	 * members.
	 */
	private HashSet<Reservation> reservations; // Holds all Reservations
	private RoomController roomController;

	/**
	 * Creates the ReservationController.
	 * 
	 * WARNING: This program avoids the use of null pointers, but because of
	 * circular dependency issues, this class requires that the developer (which
	 * means YOU) set the RoomController reference member manually.
	 * Be advised that the setRoomController() method will not accept a null
	 * pointer.
	 *
	 * Once again: Set the RoomController reference manually ASAP. Failure to do
	 * so will cause this program to blow up. You've been warned.
	 * @see ReservationController.setRoomController
	 */
	public ReservationController() {
		this.reservations = new HashSet<>();
	}

	/**
	 * Returns a copy of all Reservations.
	 * Emphasis on "copy"; There is no setReservations() for a reason, using
	 * this to edit the pointer variable would omit the use of 'private'.
	 * @return A verbatim copy of all Reservations.
	 */
	@SuppressWarnings("unchecked")
	public Set<Reservation> getReservations() {
		return (HashSet<Reservation>)this.reservations.clone();
	}

	/**
	 * Generates a unique ID for a new Reservation.
	 * This method is to be called when a new Reservation is to be stored.
	 * As every Reservation carries an ID, this method searches for a unique
	 * one, and returns it.
	 * @return An integer, different from all other stored Reservation IDs.
	 */
	public int generateReservationID() {
		/* Small optimization idea:
		 * Instead of starting from 0, and incrementing until it's unique, it
		 * will take the amount of stored Reservations, and test that as an ID.
		 * This may still overlap (by removing an older Reservation), but may be
		 * much faster. Consider implemting and testing for effectiveness if
		 * generating an ID takes too long.
		 */
		int ID = 0;
		boolean isUnique = false;
		do {
			ID++;
			isUnique = true;
			for(Reservation reservation: this.reservations) {
				if(ID == reservation.getReservationID()) {
					isUnique = false;
				}
			}
		} while(!isUnique);
		// Test:
		for(Reservation reservation: this.reservations) {
			assert reservation.getReservationID() != ID : "Duplicate ID generated!";
		}
		return ID;
	}
	
	/** 
	 * Check if Reservation can be made.
	 * Call this method whenever you're planning on adding a new Reservation. It
	 * will check the provided requirements (Room facilities, for example), and
	 * return whether this Reservation can continue.
	 * @param reservation The Reservation to check for possible addition.
	 * @pre reservation mustn't be null.
	 * @throws NullPointerException if reservation is null.
	 * @return True if reservation can be added, False otherwise.
	 */
	public boolean checkReservation(Reservation reservation) {
		if(reservation == null) {
			throw NullPointerException("reservation was a null pointer.");
		}
		}
		if(this.getRoomController().getQualifiedRooms(reservation).size() == 0) {
			return null;
		}
			return false;
		}
	}
		return true;
	}

	/**
	 * Adds and confirms the reservation.
	 * By calling this method, the given reservation will be stored in the
	 * system, and the given room will be filled.
	 * You are to collect the necessary data, and assure yourself that all
	 * preconditions have been met.
	 * 
	 * The best way to accomplish this, is to only send 'sterile' Reservations
	 * as the first parameter. That is: Reservations without reserved Beds,
	 * without prior addition to the active Reservations, etc.
	 * NOTE: You must check for yourself if the Reservation can take place in
	 * this Room! If there are not enough Beds available, an exception will be
	 * thrown.
	 * @param reservation The Reservation to add.
	 * @param room The Room in which the people will reside.
	 * @pre room must have enough empty beds.
	 * @pre room must accomodate the Reservation's requirements.
	 * @pre No parameter must be null.
	 * @pre reservation mustn't already be stored in the active Reservations.
	 * @post reservation is stored in the active Reservations.
	 * @post The Beds in the provided Room are reserved for the Reservation's
	 * period.
	 * @throws IllegalArgumentException if the given Room can't fulfill the
	 * requirements of the Reservation, or occupants is less than 1.
	 * @throws NullPointerException if any parameter is a null pointer.
	 */
	public void addReservation(Reservation reservation, Room room) {
		// Contract validation. Null pointers are implicitely checked by calling
		// methods.
		if(reservation.getPeople() > room.getEmptyBeds(reservation.getBegin(), reservation.getEnd()).size())
			throw IllegalArgumentException("The given Room has not enough empty Beds for the Reservation period.");
		if(!this.getRoomController().getQualifiedRooms(reservation).contains(room))
		if(!this.getRoomController().getQualifiedRooms(reservation).contains(room))
			throw IllegalArgumentException("The given Room cannot meet all requirements of the Reservation.");
		if(this.getReservations().contains(reservation))
		if(this.getReservations().contains(reservation))
			throw IllegalArgumentException("The given Reservation was already included in the active Reservations.");
		// Contract validated
		// Contract validated
		this.reservations.add(reservation);
		Bed[] beds = room.getEmptyBeds(reservation.getBegin(), reservation.getEnd()).toArray(new Bed[1]);
		Set<Bed> reservedBeds = new HashSet<>();
		for(int i=0; i<reservation.getPeople(); i++) {
			beds[i].reservePeriod(reservation.getBegin(), reservation.getEnd());
			reservedBeds.add(beds[i]);
		}
		reservation.setReservedBeds(reservedBeds);
	}

	/**
	 * Cancels and removes the given Reservation.
	 * If you want to remove a Reservation, use this method, and provide the
	 * Reservation up for removal.
	 * This method will take care of related actions, such as releasing Beds.
	 * @param reservation The Reservation to be removed.
	 * @pre reservation mustn't be null.
	 * @pre reservation must be contained in the active Reservations.
	 * @post The Reservation is removed from the active Reservations.
	 * @post The Beds, previously reserved for this Reservation, are now
	 * released, and can be reserved for another Reservation.
	 * @throws NullPointerException if reservation is a null pointer.
	 * @throws IllegalArgumentException if reservation is not contained in the
	 * active Reservations.
	 */
	public void cancelReservation(Reservation reservation) {
		// Contract validation
		if(!this.getReservations().contains(reservation)) {
			throw IllegalArgumentException("The given Reservation was not contained in the active Reservations.");
		}
		}
		if(reservation == null) {
			throw NullPointerException();
		}
		}
		// Contract validated, execute method
		this.reservations.remove(reservation); // Remove from active Reservations
		for(Bed bed: reservation.getReservedBeds()) { // Release reserved Beds
			bed.removeReservationPeriod(reservation.getBegin(), reservation.getEnd());
		}
		// Asserting post conditions are met
		assert !this.getReservation().contains(reservation) : "The reservation is still part of the active Reservations.";
		for(Bed bed: reservation.getReservedBeds()) {
			assert bed.isFree(reservation.getBegin(), reservation.getEnd()) : "One or more of the Beds are still reserved.";
		}
	}

}


Challenge 6/ReservationView.java ¶

7 additions and 5 deletions.

View changes Hide changes

import java.util.Set;
import java.util.HashSet;
import java.util.Date;
/**
/**
 * Creates a view screen that allows interaction with the reservation.
 * This window will place the reservation details in editable fields, so its
 * state can be adapted.
 * It then also adds a couple of buttons; add/update/cancel, with their
 * respective actions. These will then be passed to the ReservationController.
 * It will not allow to add/update a reservation if dates overlap, i.e. beds
 * can't be reserved for that period.
 * @author Maarten Vangeneugden - 1438256
 */
public class ReservationView {

	private Reservation reservation;
	private Window window;

	// Controllers for communication with the rest
	private ReservationController rc;
	private RoomController roc;

	// GUI widgets
	private JTextField nameField;
	private JSpinner amountPeopleField;
	private JTextField dateField;
	private JSpinner durationField;
	private JTextField endDateField;
	private JSpinner durationField;
	private JRadioButton[] typeField;
	private JCheckBox showerField;
	private JCheckBox bathField;
	private JCheckBox minibarField;
	private JCheckBox aircoField;


	/**
	 * Construct a window to edit a Reservation.
	 * This window presents its caller with the necessary tools to edit the
	 * given Reservation, and save it in the system.
	 *
	 * By sending it an empty Reservation, you can add a new Reservation to the
	 * system.
	 * This class is built in a way that allows it to be used for both creating
	 * new Reservations, and updating/changing existing Reservations.
	 * Existing Reservations can also be removed by clicking the appropriate
	 * button.
	 * @param reservation The Reservation that will be updated.
	 * @param rc The ReservationController class.
	 * @param roc The RoomController class.
	 * @pre No parameter may be a null pointer.
	 * @post A window is displayed with GUI widgets, which are filled in
	 * according to the state of reservation.
	 * @throws NullPointerException if any parameter is a null pointer.
	 */
	public ReservationView(Reservation reservation, ReservationController rc, RoomController roc) {
		// Contract validation
		if(rc == null || roc == null || reservation == null)
			throw NullPointerException("One or more of the given parameters is a null pointer.");
		// Contract validated
		// Contract validated
		this.rc = rc;
		this.roc = roc;

		this.reservation = reservation;
		this.window = new Window("Reservation screen");
		this.addFields();
	}

	public void setReservation(Reservation reservation) {
		this.reservation = reservation;
	}

	public Reservation getReservation() {
		return reservation;
	}

	/**
	 * Add the necessary fields to the window.
	 * This method inspects the Reservation, and copies the included information
	 * to the widget's content.
	 */
	private void addFields() {
		this.window.createLabel("Group name");
		this.nameField = window.createTextField(this.reservation.getGroupName());
		this.window.createLabel("Amount of people");
		this.amountPeopleField = window.createSpinner(1, 20, this.reservation.getPeople(), 1);
		// Formatting date for the date field:
		this.window.createLabel("Begin date");
		this.beginDateField = window.createTextField(this.reservation.getBegin().toString());
		this.window.createLabel("End date");
		this.endDateField = window.createTextField(this.reservation.getEnd().toString());
		String[] types = {"Male", "Female", "Mixed"};
		this.typeField = this.window.createRadioButtons(types);
		// TODO: Add a test to see if the Reservation has indicated which type
		// it is, and then already check the corresponding radio button.
		this.showerField = this.window.createCheckbox("Shower");
		this.bathField = this.window.createCheckbox("Bath");
		this.minibarField = this.window.createCheckbox("Minibar");
		this.aircoField = this.window.createCheckbox("Airco");
		// TODO: Idem for the facilities, test if already in Reservation, and
		// check accordingly.
		this.window.createButton("Add/Update reservation", "", "addReservation", this);
		this.window.createButton("Remove reservation", "", "removeReservation", this);
	}

	/**
	 * Start the addition of this Reservation to the system.
	 * This method will check the current fields, and update the Reservation
	 * with those values. In doing so, the validity of the values is checked
	 * (formatting, begin date before end date, ...).
	 * If everything is okay, the method will check if these changes are
	 * possible in the current system; are there enough empty beds?
	 *
	 * If everything is okay, the changes will be propagated to the
	 * Reservation's state, and (if it's a new Reservation) will be added to the
	 * system's active Reservations.
	 */
	public void addReservation() {
		// Collect all data from the fields
		String name = this.nameField.getText();
		Date beginDate = null, endDate = null;
		try {
			beginDate = DataFormat.parse(this.beginDateField.getText());
			endDate = DataFormat.parse(this.endDateField.getText());
		}
		endDate = new Date(this.endDateField.getText());
		}
		catch(ParseException e) {
			this.window.messageDialog("Not all date fields were properly formatted.");
			this.window.messageDialog("Not all date fields were properly formatted.");
			return;
		}
		int people = (Integer)this.amountPeopleField.getValue();
		String type = "";
		for(int i=0; i<this.typeField.length; i++) {
			if(this.typeField[i].isSelected()) {
				type = this.typeField[i].getText();
				break;
			}
		}
		Set<String> facilities = new HashSet<>();
		if(this.showerField.isSelected()) {
			facilities.add("Shower");
		}
		if(this.bathField.isSelected()) {
			facilities.add("Bath");
		}
		if(this.minibarField.isSelected()) {
			facilities.add("Minibar");
		}
		if(this.aircoField.isSelected()) {
			facilities.add("Airco");
		}

		// TODO breakfast days handling

		//Set<Room> possibleRooms = this.roc.getQualifiedRooms(actualDate, duration, type, facilities);
		// TODO: Refactor upper method to work with the Reservation.
		// TODO: Implement all checks of valid data above this line!
		
		// Data validated; Try finding appropriate beds
		if(possibleRooms.size() == 0) {
			boolean tryAgain = this.window.confirmDialog("No rooms met the requirements! Would you like to continue and change the parameters?");
			if(!tryAgain) {
				// TODO close window
			}
		}
		else {
			Room pickedRoom = null;
			for(Room room: possibleRooms) {
				if(room.getEmptyBeds(actualDate, actualEndDate).size() < room.getBeds().size()) {
					// First, fill the rooms that are partially filled.
					pickedRoom = room;
					break;
				}
			}
			if(pickedRoom == null) { // If still no room, pick an empty room
				for(Room room: possibleRooms) {
					if(room.getEmptyBeds(actualDate, actualEndDate).size() >= amount) {
						pickedRoom = room;
						break;
					}
				}
			}
			assert pickedRoom != null;
			// TODO: Set reservation fields here!
			this.rc.addReservation(reservation, pickedRoom);

			// Confirm and show price:
			int price = this.reservation.getPrice();
			this.window.confirmDialog("Reservation confirmed! Price: " +String.valueOf(price));
		}
		
	}

	/**
	 * Remove Reservation and the GUI.
	 * Calling this method will remove the Reservation, followed by closing this
	 * window.
	 * If the Reservation is active (i.e. saved in the ReservationController),
	 * it will be removed.
	 * Any changes will be cancelled.
	 */
	public void removeReservation() {
		if(this.rc.getReservations().contains(this.reservation)) {
			this.rc.cancelReservation(this.reservation);
		}
		this.window.close();
	}
}


Challenge 6/Room.java ¶

7 additions and 7 deletions.

View changes Hide changes

import java.util.HashSet;
import java.util.Date;

/**
 * A room in a hostel.
 * Room represents just that: A room.
 * A room contains a set of Beds, facilities that can be used, etc.
 * It's highly decoupled: Apart from holding a set of Beds, the only members
 * types consist of those that are available in every OpenJDK implementation.
 * @author Maarten Vangeneugden - 1438256
 */
public class Room {

	private HashSet<Bed> beds;
	private String type;
	private HashSet<String> facilities;

	/**
	 * Create a new Room.
	 * @param beds The amount of Beds that will be placed in this Room.
	 * @param type The type of this Room. (for example: Male, Female, Mixed,
	 * ...)
	 * @param facilities A Set of facilities this Room provides ("Shower",
	 * "Radio", "Overpriced WiFi", ...)
	 * @pre No parameter must be a null pointer.
	 * @pre beds must be at least 1.
	 * @pre Type mustn't be an empty String.
	 * @pre No facility may be an empty String.
	 * @post The Room will receive the provided amount of Beds, which are all
	 * completely released.
	 * @throws IllegalArgumentException if the amount of Beds is less than 1, or
	 * one of the facilities is an empty String.
	 * @throws NullPointerException if one of the parameters is a null pointer.
	 */
	public Room(int beds, String type, Set<String> facilities) {
		// Contract validation happens in the setter methods
		this.setFacilities(facilities);
		this.setType(type);
		if(beds < 1) {
			throw IllegalArgumentException("Beds was less than 1.");
		}
		}
		// Contract validated, execute constructor
		this.beds = new HashSet<>();
		for(int i=0; i<beds; i++) {
			this.beds.add(new Bed());
		}
	}

	/**
	 * Remove a Bed from this Room.
	 * This method will remove the given Bed from this Room.
	 * However, make sure that this Bed is free of any reservations, as you
	 * can't delete a Bed with a reserved period.
	 * @see Bed
	 * @param bed The Bed to be removed.
	 * @pre bed mustn't be null.
	 * @pre bed mustn't be the last Bed in this Room.
	 * @pre bed must be in this Room.
	 * @pre bed mustn't have any reserved periods.
	 * @post The amount of Beds in this Room is decremented by 1.
	 * @throws IllegalArgumentException if bed is not in this Room, or has
	 * reserved periods, or this is the last Bed in the Room.
	 * @throws NullPointerException if bed is a null pointer.
	 */
	public void removeBed(Bed bed) {
		// Contract validation
		if(!this.getBeds().contains(bed)) {
			throw IllegalArgumentException("The given Bed is not in this Room.");
		}
		}
		if(bed.hasReservations()) {
			throw IllegalArgumentException("The given Bed still has reserved periods.");
		}
		}
		if(this.getBeds().size() == 1) {
			throw IllegalArgumentException("Deleting this Bed would empty the Room.");
		}
		}
		// Contract validated, execute method
		this.beds.remove(bed);
		// Assert post conditions
		assert !this.getBeds().contains(bed) : "The given Bed was not removed from this Room.";
	}

	/**
	 * Add a Bed to this Room.
	 * @post The amount of Beds in this Room increments with 1.
	 */
	public void addBed() {
		this.beds.add(new Bed());
	}

	/**
	 * Returns a copy of all Beds.
	 * @return A verbatim copy of all Beds.
	 */
	@SuppressWarnings("unchecked")
	public Set<Bed> getBeds() {
		return (HashSet<Bed>) this.beds.clone();
	}

	/**
	 * Set the type of this Room.
	 * @param type The new type of the Room.
	 * @pre type mustn't be an empty String, or a null pointer.
	 * @post The Room's type is changed to the given type.
	 * @throws IllegalArgumentException if type is an empty String.
	 * @throws NullPointerException if type is a null pointer.
	 */
	public void setType(String type) {
		if(type.isEmpty()) {
			throw IllegalArgumentException("type is an empty String.");
		}
		}
		this.type = type;
	}

	/**
	 * Returns the type of this Room.
	 * @return The secret launch codes of the USS Nimitz, granting access to
	 * nuclear warheads so big, you'll lose faith in humanity.
	 */
	public String getType() {
		return type;
	}

	/**
	 * Set the facilities available in this Room.
	 * @param facilities The set of facilities in this Room.
	 * @pre No facility must be an empty String or a null pointer.
	 * @post The Room will have the newly provided facilities.
	 * @throws IllegalArgumentException if one of the facilities is an empty String.
	 * @throws NullPointerException if any given variable is a null pointer.
	 */
	public void setFacilities(Set<String> facilities) {
		for(String facility : facilities) {
			if(facility.isEmpty()) {
				throw IllegalArgumentException("A facility was an empty String.");
			}
			}
		}
		this.facilities = facilities;
	}

	/**
	 * Returns a copy of all facilities.
	 * @return A verbatim copy of all facilities.
	 */
	@SuppressWarnings("unchecked")
	public Set<String> getFacilities() {
		return (HashSet<String>)this.facilities.clone();
	}

	/**
	 * Search for Beds that can be reserved.
	 * This method will look through all Beds, and check whether they can be
	 * reserved in the given period. You will receive all Beds that can be
	 * reserved.
	 * @param begin The begin date.
	 * @param end The end date.
	 * @pre No parameter must be null.
	 * @pre begin must strictly come before end.
	 * @throws IllegalArgumentException if begin comes after end, or both are
	 * equal.
	 * @throws NullPointerException if any given parameter is a null pointer.
	 * @return A Set of all Beds that can be reserved, or an empty Set if no Bed
	 * can be reserved in the given period.
	 */
	public Set<Bed> getEmptyBeds(Date begin, Date end) {
		// Contract validation
		if(!begin.before(end)) {
			throw IllegalArgumentException("begin does not come strictly before end");
		}
		}
		// Validated
		Set<Bed> emptyBeds = new HashSet<>();
		for(Bed bed: this.getBeds()) {
			if(bed.isFree(begin, end)) {
				emptyBeds.add(bed);
			}
		}
		return emptyBeds;
	}

}


Challenge 6/RoomController.java ¶

2 additions and 2 deletions.

View changes Hide changes

import java.util.Date;
import java.util.HashSet;

/**
 * Holds all Rooms in the hostel.
 * The hostel contains a set of Rooms, with facilities and stuff.
 * This class takes care of storing all those Rooms, and provides methods to
 * manage this, like removing Rooms, adding Rooms, ...
 * @author Maarten Vangeneugden - 1438256
 */
public class RoomController {

	private Set<Room> rooms;

	public RoomController() {
		this.rooms = new HashSet<>();
	}


	public Set<Room> getRooms() {
		return rooms;
	}

	/**
	 * Returns all rooms that meet the given requirements.
	 * This method will search through all rooms, and check which rooms qualify.
	 * Currently, this method checks for the following things:
	 * - Is the requested type available?
	 * - Does the Set of requested facilities form a subset of the Room's
	 *   facilities?
	 * - Are there any Beds in the Room that can be reserved in the given
	 *   period?
	 * @param reservation The Reservation for which to find eligible rooms.
	 * @pre reservation mustn't be null.
	 * @throws NullPointerException if reservation is a null pointer.
	 * @return A set of all rooms that meet the requirements, or an empty set if
	 * none were found.
	 */
	public Set<Room> getQualifiedRooms(Reservation reservation) {
		Set<Room> qualifiedRooms = new HashSet<>();
		for(Room room : this.getRooms()) {
			if(room.getType().equals(reservation.getType()))
				continue;
				continue;
			if(!room.getFacilities().containsAll(reservation.getFacilities()))
				continue;
				continue;
			if(room.getEmptyBeds(reservation.getBegin(), reservation.getEnd()).isEmpty())
				continue;
			// The Room fulfills all requirements at this point, so add it to
			// the set
			qualifiedRooms.add(room);
		}
		return qualifiedRooms;
	}
}


Challenge 6/Window.java ¶

1 addition and 1 deletion.

View changes Hide changes

 * Window.java - Module to create a new window with JSugar.
 * Copyright © 2016 Maarten "Vngngdn" Vangeneugden
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

/*
 * TODO list:
 * - JSlider (It's the same as the JSpinner, only longer. So an extra.)
 * - JTable (And a JScrollBar to accompany it) (extra, because of JList)
 * - JFileChooser (?)
 * DONE list:
 * - JLabel
 * - JText
 * - JButton
 * - JDialogBoxes (you know, everything dialog related)
 * - JCheckbox
 * - JRadioButton (properly grouping them has been taken care of as well)
 * - JSpinner
 * - JComboBox
 * - JList
 */

import javax.swing.*; // FIXME: Maybe namespacing it to "javax.swing;" is a better idea.
import java.util.NoSuchElementException;
import java.lang.reflect.Method;
import java.io.File;
import java.awt.event.WindowEvent; // For programatically closing the window

/**
 * Window class for the program.
 *
 * Window contains the necessary data and methods to present the user with what
 * he's familiar with as being a "window". To make it functional, the developer
 * can make use of a series of methods to add components to said window, remove
 * components, and so on.
 * Currently, Window also contains methods to show dialogs. This will be cleaned
 * in the near future.
 * @author Maarten Vangeneugden
 */
public class Window { // Must be public, in order to generate Javadoc.
	private JPanel panel; // The panel that contains all the components.
	private JFrame frame; // The "window" being presented to the user.

	/**
	 * Constructor of Window.
	 * By creating a new Window instance, this constructor will automatically
	 * start the initialization of the GUI. After doing so, the caller can
	 * start adding components to the window as pleased.
	 * @param title The title to be shown in the window's title bar.
	 */
	public Window(String title) {
		// Setting the UI style to the platform's UI style. Fuck Swing's,
		// really.
		try {
		UIManager.setLookAndFeel(
				UIManager.getSystemLookAndFeelClassName());
		} catch(Exception e) {
			e.printStackTrace();
		}

		if(title == null || title.equals("")) { // If the title was omitted:
			title = "JSugar";
		}
		this.panel = new JPanel();
		// TODO: The current title is "Hello world!" but that will become caller
		// defined soon.
		JFrame frame = new JFrame(title);
		// Makes it so that if the user clicks the X in the titlebar, the window
		// closes:
		frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // XXX: Closes
		//ALL open windows!
		//frame.getContentPane().add(lblHelloWorld); // So you use a get() in order to set() data? #JavaWTF
		frame.setContentPane(this.panel); // Connecting the component panel to the window.
		// Makes the window fit to the necessary width and height, so it can show all "subcomponents".
		frame.pack(); 	
		frame.setVisible(true); // Makes the window visible to the user.
		this.frame = frame;
	}

	/**
	 * Resizes the window to fit all components.
	 * By calling this method, the window will evaluate the currently visible
	 * components, and resize itself so that all components become properly
	 * visible.
	 */
	private void updateWindow() {
		this.frame.pack();
	}

	/**
	 * A series of tests for method and class handling.
	 * When a caller presents certain methods with data concerning reflection,
	 * the Java classes you need to use for that are quite opaque, and don't
	 * offer much safety in any way.
	 * The solution therefore, is run some validation checks, but these take up
	 * a decent amount of space in terms of LoC.
	 * This method takes care of all that. Call this function whenever data
	 * needs to be validated.
	 * @param methodName The name of the method, as it is declared in object.
	 * @param object The class instance in where this method will be called.
	 * @return The method that could be derived from the supplied data, or null
	 * if that wasn't possible.
	 * @throws NullPointerException if either methodName or object are null
	 * pointers.
	 * @throws IllegalArgumentException if methodName is empty, or the method
	 * does not appear to be declared in the given object, or object is not a
	 * class.
	 */
	// All unchecked typecasts are safe, and the use of raw types is taken care
	// of.
	@SuppressWarnings({"unchecked","rawtypes"})
	private Method handleReflectionData(String methodName, Object object) {
		// Null pointer checking:
		if (methodName == null || object == null) {
			throw new NullPointerException("One or more of the given parameters are null pointers.");
		}

		// XXX: Some might say the next line should be in an else{} block. But
		// Scoping rules require that I'd then have to wrap the rest of the
		// method in the same else to use it.
		Class methodClass = object.getClass(); 
		if (methodName.equals("")) {
			throw new IllegalArgumentException("The given methodName was empty.");
		}
		Method method;
		try { // First: Look if there's a method without parameters.
			method = methodClass.getMethod(methodName, null);
		}
		catch (NoSuchMethodException exception) {
			try {
				// It's possible that the method requires an event parameter, so
				// check for that as well:
				Class<?>[] parameters = {java.awt.event.ActionEvent.class};
				method = methodClass.getMethod(methodName, parameters);
			}
			catch (NoSuchMethodException e) {
				throw new IllegalArgumentException("The given method does not appear in the given class. Be aware that the given method mustn't have any parameters, or only 1 parameter, which has to be of type java.awt.event.ActionEvent.");
			}
		}
		// At this stage, the given data has been validated, and we've been able
		// to retrieve the method itself.
		return method;
	}

	/**
	 * Creates a button in the GUI for interaction.
	 * This function offers a convenient way to create a button, that can be
	 * directly interacted with by the user. After creation, the button itself
	 * is returned to the caller, if he wishes to do something else with it.
	 * @param text The text that will be displayed in the button.
	 * @param action The action that will be returned to the action listener.
	 * @param methodName The name of the method that will be called when an
	 * action is triggered.
	 * @param triggerObject The object instance that contains the given method.
	 * This may only be a null pointer if triggerMethod is not an instance
	 * method.
	 * performed. This method may accept an ActionEvent parameter as its only
	 * parameter, or no parameters at all.
	 * @throws NullPointerException if triggerMethod is a null pointer, or
	 * the empty String was given.
	 * @throws IllegalArgumentException if triggerMethod has more than 1
	 * parameter, or the 1 required parameter is not of type ActionEvent.
	 * @return The button that was created.
	 * @see java.awt.event.ActionEvent
	 * @see java.lang.reflect.Method#invoke
	 */
	public JButton createButton(String text, String action, String methodName, Object triggerObject) {
		Method triggerMethod = this.handleReflectionData(methodName, triggerObject);

		// For starters, we first assert that the given parameters are valid:
		if (text == null) {
			text = "";
		}
		if (action == null) {
			action = "";
		}
		
		// When the method gets here, everything's been validated correctly.
		JButton button = new JButton(text);
		button.setActionCommand(action);
		button.addActionListener(
				new java.awt.event.ActionListener() {
					public void actionPerformed(java.awt.event.ActionEvent event) {
						try {
							triggerMethod.setAccessible(true);
							if (triggerMethod.getParameterTypes().length == 0) {
								// FIXME: Next line throws a warning?
								triggerMethod.invoke(triggerObject, null);
							}
							else {
								triggerMethod.invoke(triggerObject, new Object[]{event});
							}
						}
						catch (Exception useless) {
							/*
							 * XXX: Some info on why I don't just throw said
							 * Exception to the caller:
							 * Java has this awful language constraint, which
							 * forces every damn exception that isn't a subclass
							 * of RuntimeException, to be declared in the method
							 * declaration. This tends to infect all underlying
							 * methods as well, and all that for reasons I can't
							 * comprehend. In order to keep JSugar a simple and
							 * clean library, I'll rather just handle it here,
							 * and throw a RuntimeException with appropriate
							 * details.
							 */
							throw new IllegalArgumentException("triggerMethod is not accessible from this context.");
						}
					}
				});
		this.addComponent(button);
		return button;
	}

	/**
	 * Ask the user for input through a dialog box.
	 * This method presents the user with an input field, that can accept
	 * textual input. The method will return the given input after the user's
	 * clicked a button to send.
	 * @param text The text/question to be asked to the user.
	 * @return A String, equal to what the user entered.
	 * @throws NullPointerException if text is a null pointer.
	 */
	public String inputDialog(String text) {
		if (text == null) {
			throw new NullPointerException("The given text/question was a null pointer.");
		}
		return JOptionPane.showInputDialog(text);
	}

	/**
	 * Give the user a dialog box.
	 * This method can be used to provide a simple dialog to the user.
	 * This will show the user the given question, after which a boolean value
	 * is returned, holding the choice.
	 * @param text The text/question to be asked to the user.
	 * @return True if the user confirms, False if he denies.
	 * @throws NullPointerException if text is a null pointer.
	 */
	public boolean confirmDialog(String text) {
		if (text == null) {
			throw new NullPointerException("The given text/question was a null pointer.");
		}
		final int ACCEPTED = 0;
		//final int DENIED = 1; // Not used in the current context.
		int result = this.choiceDialog(text, new String[]{"Confirm", "Deny"});
		if (result == ACCEPTED) {
			return true;
		}
		else {
			return false;
		}
	}

	/**
	 * Give the user a choice dialog box.
	 * This method gives the user a simple dialog with predefined choices.
	 * These choices are to be provided by the caller in a simple array.
	 *
	 * Tip: This method works extremely well with arbitrary created choices.
	 * That is: if the outcome of the dialog is trivial (e.g. Only 1 choice),
	 * then that value is immediately returned.
	 * @param text The text/question to be asked to the user.
	 * @param choices An array of Strings, containing the choices the user can
	 * pick.
	 * @return The index value of the picked choice, or -1 if no choices were
	 * given.
	 * @throws NullPointerException if text is a null pointer.
	 */
	public int choiceDialog(String text, String[] choices) {
		if (text == null) {
			throw new NullPointerException("The given text/question was a null pointer.");
		}
		// First: handling the trivial cases:
		if (choices.length == 0) {
			return -1;
		}
		else if (choices.length == 1) {
			return 0;
		}
		int answer = JOptionPane.CLOSED_OPTION;
		// The dialog needs to be shown again until the user has made a possible
		// choice, i.e. Chickening out using the close button is not possible
		// (Because that returns CLOSED_OPTION).
		while (answer == JOptionPane.CLOSED_OPTION) {
				JOptionPane.showOptionDialog(
					null, // The parent component. May become the panel?
					text, // The text/question to describe the goal
					"Dialog", // The text in the title bar
					JOptionPane.DEFAULT_OPTION, // The kind of available options
					JOptionPane.QUESTION_MESSAGE, // The type of message
					null, // The icon to show
					choices, // The possible choices
					choices[0] // The standard choice
					);
		}
		return answer;
	}
		

	/**
	 * Creates a label in the GUI for interaction.
	 * This function offers a convenient way to create a label, that can be
	 * directly interacted with by the user. After creation, the label itself
	 * is returned to the caller, if he wishes to do something else with it.
	 * @param text The text that will be displayed in the label.
	 * @return The label that was created.
	 */
	public JLabel createLabel(String text) {
		JLabel label = new JLabel(text);
		this.addComponent(label);
		return label;
	}

	/**
	 * Adds a checkbox to the window.
	 * By providing a String, you can use this method to easily
	 * create a checkbox, and add it to the window. 
	 * @param text The text to put next to the checkbox.
	 * @return The checkbox that was created and added to the GUI.
	 */
	public JCheckBox createCheckbox(String text) {
		JCheckBox checkbox = new JCheckBox(text);
		this.addComponent(checkbox);
		return checkbox;
	}

	/**
	 * Adds radio buttons to the window.
	 * Given a list of Strings, this method will create the same amount of radio
	 * buttons.
	 *
	 * The radio buttons will silently be grouped in a ButtonGroup object,
	 * making them automatically disable each other, so only 1 radio button can
	 * be enabled. This ButtonGroup is immutable.
	 *
	 * If you need a mutable ButtonGroup, create your own, and use the 
	 * {@link #addComponent} method to add the radio buttons manually.
	 * @param text An array of Strings. The length of the array will determine
	 * the amount of radio buttons that will be created.
	 * @return An array of radio buttons, in the same order as text.
	 */
	public JRadioButton[] createRadioButtons(String text[]) {
		JRadioButton[] radioButtons = new JRadioButton[text.length];
		ButtonGroup buttonGroup = new ButtonGroup();
		for (int i=0; i<radioButtons.length; i++) {
			radioButtons[i] = new JRadioButton(text[i]);
			//radioButtons[i].setText(text[i]);
			buttonGroup.add(radioButtons[i]);
			this.addComponent(radioButtons[i]);
		}

		assert radioButtons.length == buttonGroup.getButtonCount() : "The amount of radio buttons ("+ radioButtons.length +") differs from the amount of buttons in buttonGroup ("+ buttonGroup.getButtonCount() +").";
		return radioButtons;
	}

	public JTextField createTextField(String text) {
		JTextField textField = new JTextField(text);
		this.addComponent(textField);
		return textField;
	}

	/**
	 * Adds a number spinner component to the GUI.
	 * This method allows the caller to create a so-called "spinner component"
	 * to the window. This spinner is an input box, in which only integers can
	 * be put.
	 *
	 * The caller can set a range, a start value, and a step size.
	 *
	 * The spinner created with this method may modify itself based on the
	 * parameters.
	 * For example: If the minimum and maximum value are equal, the spinner will
	 * be disabled.
	 *
	 * @param minimum The minimum value that can be selected.
	 * @param maximum The maximum value that can be selected.
	 * @param start The value that will initially be shown in the component.
	 * @param stepSize The step size when the user increases/decreases the
	 * value.
	 * @throws IllegalArgumentException if minimum is larger than maximum, 
	 * start is not in the range of the selectable values, or stepsize is not a
	 * natural number.
	 * @return The JSpinner that was added to the window.
	 */
	public JSpinner createSpinner(int minimum, int maximum, int start, int stepSize) {
		// As usual, we begin with checking the contract:
		if(minimum > maximum) {
			throw new IllegalArgumentException("The minimum value ("+ minimum +") was larger than the maximum value ("+ maximum +")");
		}
		// The "start ∉ [minimum, maximum]" is done by the SpinnerNumberModel
		// constructor, which will be constructed later.
		if(stepSize <= 0) { // stepSize ∉ ℕ¹ (In Belgium: ℕ₀)
			throw new IllegalArgumentException("The stepSize ("+ stepSize +") is not a natural number (excluding 0).");
		}
		// If the contract is valid, we can begin:
		/*
		 * I'd like to interject here, because this is a nice example of why
		 * JSugar was a good idea:
		 * If you want a spinner, you'll typically want an integer spinner. But
		 * in Swing, when you create a JSpinner, it creates a JSpinner, with a
		 * predefined 'SpinnerNumberModel' attached to it.
		 * It's this model you then have to extract from the created spinner, on
		 * which you need to apply the configuration.
		 * What you actually have to do, is create a SpinnerNumberModel
		 * yourself, put your settings on that, and then, create a JSpinner to
		 * which you give that SpinnerNumberModel.
		 * In essence: The entire Java framework is shit.
		 */
		SpinnerNumberModel spinnerSettings = new SpinnerNumberModel(
				start,
				minimum,
				maximum,
				stepSize
				);
		JSpinner spinner = new JSpinner(spinnerSettings);
		if(minimum == maximum) { // Trivial value is set already, --> disable.
			spinner.setEnabled(false);
		}
		this.addComponent(spinner);
		return spinner;
	}

	/**
	 * Adds a number spinner component to the GUI.
	 * This method allows the caller to create a so-called "spinner component"
	 * to the window. This spinner is an input box, in which only integers can
	 * be put.
	 * 
	 * Tip: This method is a convenience method, and works extremely well with
	 * arbitrary data.
	 * For example: The start value is automatically set to the minimal possible
	 * value, and the step size defaults to 1.
	 * If the minimum and maximum are equal, the component will be disabled, and
	 * thus, be locked on the only (trivially) possible value.
	 * If minimum is larger than maximum, the method will notify you of this,
	 * but also swap the values. So you can rest assured that the spinner will
	 * handle errors, but also, inform you about it.
	 * @param minimum The minimum value that can be selected.
	 * @param maximum The maximum value that can be selected.
	 * @return The JSpinner component that was added to the window.
	 */
	public JSpinner createSpinner(int minimum, int maximum) {
		// The disabling of equal values is done in the full createSpinner(), so
		// this is merely switching values if they need to be swapped.
		if(minimum > maximum) {
			System.err.println("minimum ("+ minimum +") was larger than maximum ("+ maximum +").");
			// FIXME: Consider whether it's appropriate to print a stacktrace
			// here, which may be convenient for debugging.
			
			// XXX: I know you don't need the help variable when swapping
			// integers, because you can also do basic arithmetics. Change it if
			// it causes too much eye burn for you.
			int swapValue = minimum;
			minimum = maximum;
			maximum = swapValue;
		}

		// Yeah, these 2 variables make you cringe huh, performance addicts?
		// Drown me in the tears of your useless performance-related opinions.
		int startValue = minimum;
		int stepSize = 1;
		return this.createSpinner(minimum, maximum, startValue, stepSize);
	}

	/**
	 * Adds a combobox to the GUI.
	 * Allows the caller to create a combobox by providing the values that
	 * should be put in it.
	 *
	 * This method can only be used for String values. If that is not what you
	 * need, consider creating your own combobox and adding it manually. Or, if
	 * you need a combobox for integers, consider {@link #createSpinner}.
	 *
	 * WARNING: {@link JComboBox#getSelectedItem} returns an object, not a
	 * String. You need to manually typecast this. This is a constraint of the
	 * Swing framework.
	 * @param items An array of Strings that will be put in the combobox.
	 * @throws NullPointerException if one of the values in items is a null
	 * pointer.
	 * @throws IllegalArgumentException if items is empty.
	 * @return The JCombobox that was added to the window.
	 */
	public JComboBox<String> addComboBox(String[] items) {
		// Contract validation:
		if(items.length == 0) {
			throw new IllegalArgumentException("The given array of items was empty.");
		}
		for(String item : items) {
			if(item == null) {
				throw new NullPointerException("One of the given Strings is a null pointer.");
			}
		}
		// Contract validated, create the component:
		JComboBox<String> comboBox = new JComboBox<String>(items);
		comboBox.setSelectedIndex(0);
		if(comboBox.getItemCount() == 1) { // Trivial selection
			comboBox.setEnabled(false);
		}
		this.addComponent(comboBox);
		return comboBox;
	}

	/**
	 * Creates a list of the given data, and adds it to the GUI.
	 * This will create a JList component, containing the given data. 
	 * To jar up your memory: A list in this context, is a component in which
	 * data of the same type is printed out. The user of said list, can then
	 * select a subset of these items.
	 *
	 * @see JList for a collection of possible operations.
	 * @param items The String items that will be put in the list.
	 * @throws NullPointerException if one of the values in items is a null
	 * pointer.
	 * @throws IllegalArgumentException if items is empty.
	 * @return A JList component, that was a added to the GUI.
	 */
	public JList createList(String[] items) {
		// Contract validation:
		if(items.length == 0) {
			throw new IllegalArgumentException("The given array of items was empty.");
		}
		for(String item : items) {
			if(item == null) {
				throw new NullPointerException("One of the given Strings is a null pointer.");
			}
		}
		// Contract validated, create the component:
		JList list = new JList(items);
		this.addComponent(list);
		return list;
	}

	/**
	 * Creates a table of the given data, and adds it to the GUI.
	 * This method allows you to create a table with sorting functionality in
	 * the GUI.
	 * This method relies on implications, deducted from the given data. That
	 * is, the length of the rows and columns is calculated by the longest
	 * length it can find in the nested array.
	 * To change the data, take a look at the JTable documentation.
	 *
	 * @see JTable for a collection of possible operations.
	 * @param items The String items that will be put in the list.
	 * @throws NullPointerException if one of the values in items is a null
	 * pointer.
	 * @throws IllegalArgumentException if items is empty, or the amount of
	 * column names does not correspond with the given amount of items.
	 * @return A JTable component, that was a added to the GUI.
	 */
	public JTable createTable(String[] columns, String[][] items) {
		// Contract validation:
		if(items.length == 0) {
			throw new IllegalArgumentException("The given array of items was empty.");
		}
		if(columns.length != items[0].length) {
			throw new IllegalArgumentException("The amount of columns does not correspond to the given amount of items.");
		}
		for(int i=0; i<items.length; i++) {
			if(items[i] == null) {
				throw new NullPointerException("One of the given Strings is a null pointer.");
			}
		}
		// Contract validated, create the component:
		// Deducting max length:
		int columnCount = columns.length;
		int rowCount = items.length;
		
		JTable table = new JTable(items, columns);
		this.addComponent(table);
		return table;
	}

	/**
	 * Adds the given component to the GUI.
	 * This method allows its caller to give a pre-made component, so that it
	 * can be added to the GUI. Even though its main use is for the Window class
	 * itself, the user of JSugar can also use it to create components himself,
	 * and then add them. As such, this method doesn't provide parameters for
	 * reflection/action triggering purposes.
	 * @param component The component to be added to the window.
	 * @throws NullPointerException if the given component is a null pointer.
	 */
	public void addComponent(JComponent component) {
		int originalSize = this.panel.getComponentCount();
		this.panel.add(component); // Throws the exception if null.
		this.updateWindow();

		assert originalSize == this.panel.getComponentCount()-1 : "A component was supposed to be added to the window, but the total amount of components was unchanged after the addition.";
	}

	/**
	 * Removes the given component from the GUI.
	 * This method allows its caller to remove a component from the GUI.
	 * @param component The component to be removed.
	 * @throws NoSuchElementException if the given component does not exist in
	 * the GUI.
	 * @throws NullPointerException if the given component is a null pointer.
	 */
	public void removeComponent(JComponent component) {
		int originalSize = this.panel.getComponentCount();
		this.panel.remove(component);
		int newSize = this.panel.getComponentCount();
		if (originalSize != newSize+1) {
			throw new NoSuchElementException("The given component does not exist in the GUI.");
		}
		this.updateWindow();
	}
	/**
	 * Prompts the user with a file chooser dialog.
	 * By calling this method, the user will be presented with a file chooser
	 * dialog, out of which a single file can be selected. If the selected file
	 * exists, a File object is returned, a null pointer if the user cancelled.
	 * @return A File object representing the file the user selected, or null
	 * otherwise.
	 */
	public File openFileChooserDialog() {
		JFileChooser fileDialog = new JFileChooser();
		fileDialog.setFileSelectionMode(JFileChooser.FILES_ONLY);

		int userResponse = fileDialog.showOpenDialog(this.panel);
		if(userResponse == JFileChooser.APPROVE_OPTION) {
			return fileDialog.getSelectedFile();
		}
		else {
			return null;
		}
	}

	/** Prompts the user with a message dialog.
	 * This method creates a dialog that is purely informative. As such, it
	 * only presents the user with the option to confirm it.
	 * @param text The text to be presented in the dialog box.
	 * @pre text mustn't be null or an empty string.
	 * @throws NullPointerException if text is a null pointer.
	 * @throws IllegalArgumentException if text is an empty string.
	 */
	public void messageDialog(String text) {
		if(text.isEmpty())
			throw IllegalArgumentException("text mustn't be an empty string.");
		JOptionPane.showMessageDialog(this.frame, text);
		JOptionPane.showMessageDialog(this.frame, text);
	}

	/**
	 * Closes this window.
	 * This method tells this Window's JFrame that a closing event has been
	 * fired.
	 * Use this method when you need to programatically close this window.
	 */
	public void close() {
		this.frame.dispatchEvent(new WindowEvent(this.frame, WindowEvent.WINDOW_CLOSING));
	}
}


Challenge 6/ontwerpkeuzes2.md ¶

9 additions and 0 deletions.

View changes Hide changes


## GRASP
Om zoveel mogelijk tegemoet te komen aan de GRASP-richtlijnen, heb ik volgende
ontwerpkeuzes toegepast voor de verschillende richtlijnen.

### High cohesion & Low coupling
- Veel classes zijn totaal van elkaar losgekoppeld. Een goed voorbeeld hiervan
  is Bed; Bed weet niet over dat er Reservaties bestaan, zelfs niet in welke
  Room het 'staat'.
- Als er toch gekoppeld moet worden, dan blijft dit tot een minimum beperkt; Een
  Room weet wel welke Bedden het heeft, maar niet hoe deze gebruikt worden, een
  Reservation weet wel welke Bedden voor hem gereserveerd zijn, maar heeft geen
  weet van welke kamer dat deze staat.
- Uitzondering op deze regel vormen de Controller-classes; omwille van hun taken
  zijn deze vaak verplicht om van veel verschillende classes op de hoogte te
  zijn.

### Indirectie
- In plaats van functionaliteit toe te wijzen aan class X om met class Y te
  interageren, wordt er vaak gebruik gemaakt van een class Z, die deze
  verantwoordelijkheid op zich neemt.
- Dit wordt toegepast d.m.v. een MVC-structuur, waarin de \*Controller-classes
  als 'tussenpersoon' werken.
- Dit komt ook tegemoet aan de eigenschappen van Information Expertise.

### Creator
- Controllers staan ook in als zgn. Creators van de models die ze beheren. Ze
  voldoen dan ook aan de eigenschappen zoals
  [hier](https://en.wikipedia.org/wiki/GRASP_(object-oriented_design)#Creator)
  opgesomd wordt.


## SOLID

### Single Responsibility

## Algemene keuzes ter bevordering codekwaliteit

## Strings, integers, ... i.p.v. Enums/Eigen classes
In het programma zijn er sommige members die doen vermoeden dat ze beter als
Enums aangeduid kunnen worden; Het type van een kamer, faciliteiten, ...

In plaats van een speciale class hiervoor te maken, heb ik gekozen om deze
gewoon te behandelen als simpele Strings in lijsten.

Het voordeel aan deze werkwijze, is dat Strings in Java SE quasi universeel
voorkomen; data kunnen geconverteerd worden naar Strings (en vice versa), veel
gebruikte GUI-libraries (waaronder Swing, JavaFX, ...) gebruiken Strings voor
tekst voor te stellen in de GUI-widgets, ...
Daarnaast weet iedereen die ook maar een beetje geschoold is in Java, direct hoe
deze members behandeld kunnen worden. Had ik een class gemaakt die bv.
RoomFacilities heette, dan is die parate kennis over de taal zelf nutteloos.

Strings zijn ook voorzien van extreem veel methods, en zijn dus zeer flexibele
classes om te gebruiken. Het feit dat ze zo makkelijk doorheen het programma te
gebruiken zijn is dus een groot pluspunt.

Als dat nog niet genoeg is: Het gebruiken van de hulpmiddelen uit de _standard
library_ is niet enkel waarvoor libraries überhaupt bestaan, het beperkt ook
het benodigde aantal classes in de eigen software, waardoor het geheel
uiteindelijk veel overzichtelijker blijft, en bijgevolg, makkelijk uit te
breiden, te testen, te begrijpen, ...

Al deze voordelen graan grotendeels verloren als ik beslis om zelf
gespecialiseerde classes op te stellen.
Men kan misschien stellen dat "de voordelen die het schrijven van eigen
classes veel beter tegemoet komt aan de essentie van object-georiënteerd
programmeren, dan zich _beperken_ tot slechts een handvol generieke classes, die
misschien niet volledig aan de benodigdheden beantwoorden".

Toch laat ik mijn afweging overslaan in het voordeel van minder classes, en meer
uniformiteit. _Sometimes, less is more._ Meer classes betekent ook:
- Meer onderhoud
- Meer kans op bugs
- Groter programma

En al die problemen resulteren op lange termijn in:
- Slechtere uitbreidbaarheid
- Slechtere onderhoudbaarheid
- Slechtere schaalbaarheid

Zijn al die problemen de moeite van een (zogezegd) "beter object-georiënteerd
design" wel waard?
Veel mensen stellen juist dat OOP net voordelig is als men op zoek is naar
- Uitbreidbaarheid
- Onderhoudbaarheid
- Modulariteit
- Schaalbaarheid

Als de voordelen van het paradigma verdwijnen als ik dat "beter design" volg,
is dat design dan wel echt beter?


**Conclusie: Uniforme classes zijn volgens mij soms beter dan een stel
gespecialiseerde classes. Daarom dat ik mij soms behelp met Strings, intergers,
... i.p.v. zelf een oplossing te schrijven.**


### Null pointers
Het valt misschien op dat ik doorheen mijn programma in veel contracten eis dat
geen enkele parameter een zgn. *null pointer* is.

Het gebruik van null pointers staat garant voor een overvloed aan moeilijk te
vinden bugs die (door het design van objectgeörienteerd programmeren) enorm diep
kunnen doorpropageren.

Ik maak er een kerntaak van dat, als er aan mijn programma gewerkt wordt, de
programmeur zichzelf steeds kan garanderen dat **alle** data die hij
ontvangt, valide data is.
Op deze manier valt er een hele last van de schouders van de programmeur; een
reeks fouten worden voorkomen, simpelweg door een strikt schema aan te houden.

Het controleren op null pointers wordt op 2 manieren gedaan:
- Gebruik van *methods* aanwezig in het gegeven type. Als de gegeven variabele
  een null pointer is, zal het programma direct crashen, en een
  NullPointerException geven.
- Expliciet testen of *var == null*. Wordt toegepast op parameters die direct
  als members opgeslagen dienen te worden.

Deze (contractuele) controle laat toe dat, mocht er een null pointer gebruikt
worden, het programma de programmeur hiervan direct op de hoogte stelt, en dit
op het laagst mogelijke niveau (namelijk de eerste method waar deze waarde
gebruikt wordt).

### Cloning
members 'private' maken (encapsuleren) is volledig nutteloos als men getters en
setters op deze members toepast; In Java worden references doorgegeven (m.u.v.
primitives), die de hele notie van encapsulatie voorbijgaan (bij sommige types).
Een voorbeeld hiervan is het privatiseren van een Set<T>-member: men kan daar
een 'getSet()'-method op plaatsen, en dan toch de inhoud van deze 'private'
aanpassen.

Ik heb geopteerd om, waar van toepassing, deze variabelen te 'clonen', om zo
exacte kopieën terug te geven.
Deze manier van werken brengt enkele voordelen teweeg:
- Zeer defensief programmeren; De ontwikkelaar kan geen members aanpassen als
  dat niet de bedoeling was
- Duidelijkheid code: getSet().clear() zal de member niet meer leegmaken. Om dat
  te doen, moet men gebruikmaken van de method die daarvoor bedoeld is:
  setSet(clearedSet)

### Inheritance
Overerving is een goed concept over het algemeen, maar **niet** in OOP.
De problemen omtrent impliciet gedrag en onnodige *state* zijn al te vaak
beschreven met OOP-inheritance.

Ik heb in mijn programma geen gebruik gemaakt van inheritance, exact omwille van
de problemen die het voortbrengt, zeker in termen van herbruikbaarheid en
robuustheid, wat toch zware vereisten waren voor deze opdracht.

Ik heb al mijn problemen makkelijk kunnen oplossen d.m.v. compositie.

### Benaming variabelen
Doorheen mijn programma maak ik heel veel gebruik van dezelfde benamingen.
Bijvoorbeeld: Een variabele van het type Reservation zal haast altijd
'reservation' heten, een Set van een bepaald type zal de naam van datzelfde type
dragen, in het meervoud, ...

Sommige programmeurs gebruiken liever afkortingen (bv. 'reservation' -->
'resv'), omdat dit sneller schrijft.

Naar mijn mening moet men bij deze werkwijze inleveren aan leesbaarheid, vooral
wanneer iemand die nog nooit met de code gewerkt heeft, dit programma moet
overnemen.

Daarnaast zorgt de consistentie van woordgebruik ervoor dat een andere
programmeur, doorheen het hele programma dezelfde context in zijn/haar gedachten
kan gebruiken.




------------------------------------------------------------ TODO
## Toepassing types/classes
Doorheen het programma heb ik getracht zoveel mogelijk gebruik te maken van
types/classes die
- Veelvoorkomend zijn in de Java STL (Zoals String, Set, List, ...)
- primitief zijn (ints, ...), omdat deze operatoren hebben en de code
  leesbaarder maken

Een goed voorbeeld hiervan zijn bv. de faciliteiten:
I.p.v. een aparte "Facility"-class te maken, heb ik de verschillende
faciliteiten voorgesteld door een simpele String. De voordelen van deze aanpak
zijn ook direct duidelijk:
- Betekenis is direct duidelijk; de faciliteit letterlijk in de code vernoemd
- Makkelijke interactie met GUI, die sowieso Strings vraagt voor bv. JLabel
- Uitbreidbaarheid wordt bekomen door simpelweg een nieuwe String te
  introduceren

## View en GUI
Werken met GUI's is vaak tijdrovend en veroorzaakt snel errors, zeker met bv.
anonieme methods, exceptions, ...
Alhoewel mijn programma grotendeels in een MVC-stijl is geschreven, maken de
view-classes (RegistrationView, SearchView, ...) achterliggend gebruik van een
zelfgemaakt framework om makkelijk vensters te maken.
Dit kleine framework is een persoonlijk hobbyproject dat ik JSugar noem.
Het biedt een heleboel voordelen, vergeleken met elk GUI-venster zelf opstellen:
- Vaak gebruikte GUI-widgets (zoals een label, textfield) worden aangemaakt en
  toegevoegd door slechts 1 method op te roepen
- JSugar maakt gebruik van reflectie om op een leesbare en uitbreidbare manier
  knoppen te activeren:
  public JButton createButton(String text, String action, String methodName, Object triggerObject)
  'methodName' is een simpele String, en 'triggerObject' is het object waar deze
  method moet worden opgeroepen.
- Automatische uitlijning van widgets
Voor meer informatie kunt u JSugar-readme.md raadplegen.

## java.util.Date

Doorheen het programma maak ik vaak gebruik van de Date-class uit de Java STL,
om de volgende redenen:
- Uitbreidbaarheid: Door overal eenzelfde type te gebruiken, is het gemakkelijk
  om nieuwe modules toe te voegen, zonder dat daarvoor abstractielagen etc.
  nodig zijn.
- Uniformiteit: Eenzelfde type uit de STL laat de ontwikkelaar toe om door het
  hele programma heen hetzelfde denkpatroon aan te houden; een
  Stringvoorstelling hier, een integer daar, ... veroorzaken problemen en bugs,
  die met deze class voorkomen worden.

## Bedden

Het moeilijkste om te implementeren waren de data voor ontbijt.
Er wordt voor de reservaties steeds een set bijgehouden van de data waarop
ontbijt besteld is.
Op zich is dit niet zo moeilijk. Het moeilijke hieraan, is de gebruiker van het
programma op een begrijpelijke manier deze data te laten invoeren.
Data worden ingevoerd via tekstvelden, omdat Swing geen zgn. "DatePicker" heeft.

## Bedden

Ik heb voor bedden een aparte class aangemaakt, omdat deze een bepaalde state
bijhouden, nml. wanneer ze gereserveerd zijn.


## Reservation
Voor de reservaties heb ik besloten om enkel die data bij te houden die inherent
gerelateerd is aan die reservatie:
- Enkel gereserveerde bedden i.p.v. gereserveerde kamers. Qua uitbreidbaarheid
  heeft dit tot gevolg dat men gemakkelijk kan uitbreiden naar reservaties,
  gespreid over verschillende kamers.


## ReservationView
Merk op hoe in ReservationView de data van de Reservation direct in de GUI wordt
geplaatst.
Dit staat toe om zeer gemakkelijk deze class te hergebruiken voor zowel het
**aanmaken** als het **updaten** van de reservatie.


1	1	import java.util.Map;
2	2	import java.util.HashMap;
3	3
4	4	/**
+	5	/**
5	6	* Class representing a bed in the hostel.
6	7	* Even though beds in a hostel could simply be an integer in a Room, these Beds
7	8	* need to remember on what dates they are reserved.
8	9	* @author Maarten Vangeneugden - 1438256
9	10	*/
10	11	public class Bed {
11	12
12	13	/* Rationale:
13	14	* I know that a mapping is not necessarily the best solution for storing
14	15	* periods, because it doesn't offer built-in protection yadda yadda.
15	16	* However, that's Java's fault, as it doesn't provide a Pair<L,R> thing in
16	17	* the STL.
17	18	* The best solution is actually a collection of tuples: (Begin, End), but
18	19	* that doesn't exist in Java, and thus requires a custom implementation.
19	20	* All things considered, a Map is the least bad choice.
20	21	*/
21	22	private Map<Date, Date> reservedPeriods;
22	23
23	24	public Bed() {
24	25	this.reservedPeriods = new HashMap<>();
25	26	}
26	27
27	28	/**
28	29	* Reserves this Bed for the given period.
29	30	* This method will mark the given period for this Bed as "reserved", which
30	31	* can then be cancelled or queried later.
31	32	* @param begin The time where the reservation begins.
32	33	* @param end The time where the reservation ends.
33	34	* @pre No parameter may be a null pointer.
34	35	* @pre The given period mustn't overlap with a period already marked as
35	36	* reserved.
36	37	* @pre begin must come before end.
37	38	* @pre begin and end mustn't be equal.
38	39	* @post The given period will be marked as "Reserved", and will have to be
39	40	* manually cancelled/removed in order to reserve again.
40	41	* @throws NullPointerException if any parameter is a null pointer.
41	42	* @throws IllegalArgumentException if begin is equal to, or comes after
42	43	* end.
43	44	* @throws DateTimeException if the given period overlaps with an already
44	45	* reserved period.
45	46	*/
46	47	public void reservePeriod(Date begin, Date end) {
47	48	if(!begin.before(end)) {
48	49	throw IllegalArgumentException("The begin date occurs after the end date.");
49	-	}
+	50	}
50	51	if(!this.isFree(begin, end)) {
51	52	throw DateTimeException("This period overlaps with a reserved period.");
52	-	}
+	53	}
53	54	// Contract validated, execute method
54	55	this.reservedPeriods.put(begin, end);
55	56	}
56	57
57	58	/**
58	59	* Remove a previous registration from this Bed.
59	60	* This method will remove/cancel the given reservation period from the
60	61	* Bed, opening it up for reservation again.
61	62	* @param begin The time where the reservation begins.
62	63	* @param end The time where the reservation ends.
63	64	* @pre No parameter may be a null pointer.
64	65	* @pre The given period must already be marked as "Reserved" in this Bed.
65	66	* @pre begin must come before end.
66	67	* @pre begin and end mustn't be equal.
67	68	* @post The given period will lose its "Reserved" mark, allowing the period
68	69	* to be reserved again.
69	70	* @throws NullPointerException if any parameter is a null pointer.
70	71	* @throws IllegalArgumentException if begin is equal to, or comes after
71	72	* end; or, if the given period is not reserved.
72	73	*/
73	74	public void removeReservationPeriod(Date begin, Date end) {
74	75	if(!begin.before(end)) {
75	76	throw IllegalArgumentException("The begin date occurs after the end date.");
76	-	}
+	77	}
77	78	if(!this.isFree(begin, end)) {
78	79	throw DateTimeException("This period overlaps with a reserved period.");
79	-	}
+	80	}
80	81	// Contract partially validated; further validation occurs while looking
81	82	// for the reservation.
82	83	// XXX: Check if Java correctly handles equality: 2 different Date
83	84	// objects with the same date representation should be equal!
84	85	boolean reservationFound = this.reservedPeriods.remove(begin, end);
85	86	if(!reservationFound) {
86	87	throw IllegalArgumentException("The given period was not marked as reserved.");
87	-	}
+	88	}
88	89	}
89	90
90	91	/**
91	92	* Checks whether this Bed can be reserved in the given period.
92	93	* Use this method whenever you need to inform yourself about any
93	94	* conflicting reservation period.
94	95	* @param begin The time where the reservation begins.
95	96	* @param end The time where the reservation ends.
96	97	* @pre No parameter must be a null pointer.
97	98	* @pre begin must come before end.
98	99	* @pre begin and end mustn't be equal.
99	100	* @throws NullPointerException if any parameter is a null pointer.
100	101	* @throws IllegalArgumentException if begin is equal to, or comes after
101	102	* end.
102	103	* @return True if the given period does not overlap with any reservation, false otherwise.
103	104	*/
104	105	public boolean isFree(Date begin, Date end) {
105	106	if(!begin.before(end)) {
106	107	throw IllegalArgumentException("The begin date occurs after the end date.");
107	-	}
+	108	}
108	109	if(!this.isFree(begin, end)) {
109	110	throw DateTimeException("This period overlaps with a reserved period.");
110	-	}
+	111	}
111	112	// Contract validated, execute method
112	113	for(Map.Entry<Date, Date> reservedPeriod: this.reservedPeriods.EntrySet()) {
113	-	Date reservedBegin = reservedPeriod.key();
114	-	Date reservedEnd = reservedPeriod.value();
115	-	/* Forbidden possibilities:
+	114	Date reservedBegin = reservedPeriod.getKey();
+	115	Date reservedEnd = reservedPeriod.getValue();
+	116	/* Forbidden possibilities:
116	117	* (A,B = reserved; X,Y = requested)
117	118	* X-A-Y-B / A-X-B-Y - Begins or ends in a reserved period
118	119	* X-A-B-Y - Complete overlapping of reserved period
119	120	* Allowed possibilities:
120	121	* A-B-X-Y / X-Y-A-B - No overlapping
121	122	*/
122	123	if((begin.after(reservedBegin) && begin.before(reservedEnd)) \|\|
123	124	(end.after(reservedBegin) && end.before(reservedEnd))) {
124	125	// Triggered if any forbidden structure is detected
125	126	return false;
126	127	}
127	128	}
128	129	return true; // No overlapping found
129	130	}
130	131
131	132	/**
132	133	* Checks whether this Bed has open reservation periods.
133	134	* @return True if this Bed has reserved periods, false otherwise.
134	135	*/
135	136	public boolean hasReservations() {
136	137	return !this.reservedPeriods.isEmpty();
137	138	}
138	139	}
139	140

1	1	import java.util.HashSet;
2	2	import java.util.Date;
3	3
4	4	/**
5	5	* Controller class for the Reservations of this program.
6	6	* Since this program handles a youth hostel, it's imperative that it holds a
7	7	* number of Reservations.
8	8	*
9	9	* ReservationController takes the responsibility of handling the addition,
10	10	* cancelling, editing, ... of Reservations, and the related tasks inherent to
11	11	* these responsibilities, such as reserving beds, generating IDs, ...
12	12	* @author Maarten Vangeneugden - 1438256
13	13	*/
14	14	public class ReservationController {
15	15
16	16	/* Rationale:
17	17	* Normally I'd put this as an interface (Set), but an interface does not
18	18	* inherit from Object, and thus, does not provide clone(). This is
19	19	* necessary, because otherwise, there's no point in having private
20	20	* members.
21	21	*/
22	22	private HashSet<Reservation> reservations; // Holds all Reservations
23	23	private RoomController roomController;
24	24
25	25	/**
26	26	* Creates the ReservationController.
27	27	*
28	28	* WARNING: This program avoids the use of null pointers, but because of
29	29	* circular dependency issues, this class requires that the developer (which
30	30	* means YOU) set the RoomController reference member manually.
31	31	* Be advised that the setRoomController() method will not accept a null
32	32	* pointer.
33	33	*
34	34	* Once again: Set the RoomController reference manually ASAP. Failure to do
35	35	* so will cause this program to blow up. You've been warned.
36	36	* @see ReservationController.setRoomController
37	37	*/
38	38	public ReservationController() {
39	39	this.reservations = new HashSet<>();
40	40	}
41	41
42	42	/**
43	43	* Returns a copy of all Reservations.
44	44	* Emphasis on "copy"; There is no setReservations() for a reason, using
45	45	* this to edit the pointer variable would omit the use of 'private'.
46	46	* @return A verbatim copy of all Reservations.
47	47	*/
48	48	@SuppressWarnings("unchecked")
49	49	public Set<Reservation> getReservations() {
50	50	return (HashSet<Reservation>)this.reservations.clone();
51	51	}
52	52
53	53	/**
54	54	* Generates a unique ID for a new Reservation.
55	55	* This method is to be called when a new Reservation is to be stored.
56	56	* As every Reservation carries an ID, this method searches for a unique
57	57	* one, and returns it.
58	58	* @return An integer, different from all other stored Reservation IDs.
59	59	*/
60	60	public int generateReservationID() {
61	61	/* Small optimization idea:
62	62	* Instead of starting from 0, and incrementing until it's unique, it
63	63	* will take the amount of stored Reservations, and test that as an ID.
64	64	* This may still overlap (by removing an older Reservation), but may be
65	65	* much faster. Consider implemting and testing for effectiveness if
66	66	* generating an ID takes too long.
67	67	*/
68	68	int ID = 0;
69	69	boolean isUnique = false;
70	70	do {
71	71	ID++;
72	72	isUnique = true;
73	73	for(Reservation reservation: this.reservations) {
74	74	if(ID == reservation.getReservationID()) {
75	75	isUnique = false;
76	76	}
77	77	}
78	78	} while(!isUnique);
79	79	// Test:
80	80	for(Reservation reservation: this.reservations) {
81	81	assert reservation.getReservationID() != ID : "Duplicate ID generated!";
82	82	}
83	83	return ID;
84	84	}
85	85
86	86	/**
87	87	* Check if Reservation can be made.
88	88	* Call this method whenever you're planning on adding a new Reservation. It
89	89	* will check the provided requirements (Room facilities, for example), and
90	90	* return whether this Reservation can continue.
91	91	* @param reservation The Reservation to check for possible addition.
92	92	* @pre reservation mustn't be null.
93	93	* @throws NullPointerException if reservation is null.
94	94	* @return True if reservation can be added, False otherwise.
95	95	*/
96	96	public boolean checkReservation(Reservation reservation) {
97	97	if(reservation == null) {
98	98	throw NullPointerException("reservation was a null pointer.");
99	-	}
+	99	}
100	100	if(this.getRoomController().getQualifiedRooms(reservation).size() == 0) {
101	-	return null;
102	-	}
+	101	return false;
+	102	}
103	103	}
+	104	return true;
+	105	}
104	106
105	107	/**
106	108	* Adds and confirms the reservation.
107	109	* By calling this method, the given reservation will be stored in the
108	110	* system, and the given room will be filled.
109	111	* You are to collect the necessary data, and assure yourself that all
110	112	* preconditions have been met.
111	113	*
112	114	* The best way to accomplish this, is to only send 'sterile' Reservations
113	115	* as the first parameter. That is: Reservations without reserved Beds,
114	116	* without prior addition to the active Reservations, etc.
115	117	* NOTE: You must check for yourself if the Reservation can take place in
116	118	* this Room! If there are not enough Beds available, an exception will be
117	119	* thrown.
118	120	* @param reservation The Reservation to add.
119	121	* @param room The Room in which the people will reside.
120	122	* @pre room must have enough empty beds.
121	123	* @pre room must accomodate the Reservation's requirements.
122	124	* @pre No parameter must be null.
123	125	* @pre reservation mustn't already be stored in the active Reservations.
124	126	* @post reservation is stored in the active Reservations.
125	127	* @post The Beds in the provided Room are reserved for the Reservation's
126	128	* period.
127	129	* @throws IllegalArgumentException if the given Room can't fulfill the
128	130	* requirements of the Reservation, or occupants is less than 1.
129	131	* @throws NullPointerException if any parameter is a null pointer.
130	132	*/
131	133	public void addReservation(Reservation reservation, Room room) {
132	134	// Contract validation. Null pointers are implicitely checked by calling
133	135	// methods.
134	136	if(reservation.getPeople() > room.getEmptyBeds(reservation.getBegin(), reservation.getEnd()).size())
135	137	throw IllegalArgumentException("The given Room has not enough empty Beds for the Reservation period.");
136	-	if(!this.getRoomController().getQualifiedRooms(reservation).contains(room))
+	138	if(!this.getRoomController().getQualifiedRooms(reservation).contains(room))
137	139	throw IllegalArgumentException("The given Room cannot meet all requirements of the Reservation.");
138	-	if(this.getReservations().contains(reservation))
+	140	if(this.getReservations().contains(reservation))
139	141	throw IllegalArgumentException("The given Reservation was already included in the active Reservations.");
140	-	// Contract validated
+	142	// Contract validated
141	143	this.reservations.add(reservation);
142	144	Bed[] beds = room.getEmptyBeds(reservation.getBegin(), reservation.getEnd()).toArray(new Bed[1]);
143	145	Set<Bed> reservedBeds = new HashSet<>();
144	146	for(int i=0; i<reservation.getPeople(); i++) {
145	147	beds[i].reservePeriod(reservation.getBegin(), reservation.getEnd());
146	148	reservedBeds.add(beds[i]);
147	149	}
148	150	reservation.setReservedBeds(reservedBeds);
149	151	}
150	152
151	153	/**
152	154	* Cancels and removes the given Reservation.
153	155	* If you want to remove a Reservation, use this method, and provide the
154	156	* Reservation up for removal.
155	157	* This method will take care of related actions, such as releasing Beds.
156	158	* @param reservation The Reservation to be removed.
157	159	* @pre reservation mustn't be null.
158	160	* @pre reservation must be contained in the active Reservations.
159	161	* @post The Reservation is removed from the active Reservations.
160	162	* @post The Beds, previously reserved for this Reservation, are now
161	163	* released, and can be reserved for another Reservation.
162	164	* @throws NullPointerException if reservation is a null pointer.
163	165	* @throws IllegalArgumentException if reservation is not contained in the
164	166	* active Reservations.
165	167	*/
166	168	public void cancelReservation(Reservation reservation) {
167	169	// Contract validation
168	170	if(!this.getReservations().contains(reservation)) {
169	171	throw IllegalArgumentException("The given Reservation was not contained in the active Reservations.");
170	-	}
+	172	}
171	173	if(reservation == null) {
172	174	throw NullPointerException();
173	-	}
+	175	}
174	176	// Contract validated, execute method
175	177	this.reservations.remove(reservation); // Remove from active Reservations
176	178	for(Bed bed: reservation.getReservedBeds()) { // Release reserved Beds
177	179	bed.removeReservationPeriod(reservation.getBegin(), reservation.getEnd());
178	180	}
179	181	// Asserting post conditions are met
180	182	assert !this.getReservation().contains(reservation) : "The reservation is still part of the active Reservations.";
181	183	for(Bed bed: reservation.getReservedBeds()) {
182	184	assert bed.isFree(reservation.getBegin(), reservation.getEnd()) : "One or more of the Beds are still reserved.";
183	185	}
184	186	}
185	187
186	188	}
187	189

1	1	import java.util.HashSet;
2	2	import java.util.Date;
3	3
4	4	/**
5	5	* A room in a hostel.
6	6	* Room represents just that: A room.
7	7	* A room contains a set of Beds, facilities that can be used, etc.
8	8	* It's highly decoupled: Apart from holding a set of Beds, the only members
9	9	* types consist of those that are available in every OpenJDK implementation.
10	10	* @author Maarten Vangeneugden - 1438256
11	11	*/
12	12	public class Room {
13	13
14	14	private HashSet<Bed> beds;
15	15	private String type;
16	16	private HashSet<String> facilities;
17	17
18	18	/**
19	19	* Create a new Room.
20	20	* @param beds The amount of Beds that will be placed in this Room.
21	21	* @param type The type of this Room. (for example: Male, Female, Mixed,
22	22	* ...)
23	23	* @param facilities A Set of facilities this Room provides ("Shower",
24	24	* "Radio", "Overpriced WiFi", ...)
25	25	* @pre No parameter must be a null pointer.
26	26	* @pre beds must be at least 1.
27	27	* @pre Type mustn't be an empty String.
28	28	* @pre No facility may be an empty String.
29	29	* @post The Room will receive the provided amount of Beds, which are all
30	30	* completely released.
31	31	* @throws IllegalArgumentException if the amount of Beds is less than 1, or
32	32	* one of the facilities is an empty String.
33	33	* @throws NullPointerException if one of the parameters is a null pointer.
34	34	*/
35	35	public Room(int beds, String type, Set<String> facilities) {
36	36	// Contract validation happens in the setter methods
37	37	this.setFacilities(facilities);
38	38	this.setType(type);
39	39	if(beds < 1) {
40	40	throw IllegalArgumentException("Beds was less than 1.");
41	-	}
+	41	}
42	42	// Contract validated, execute constructor
43	43	this.beds = new HashSet<>();
44	44	for(int i=0; i<beds; i++) {
45	45	this.beds.add(new Bed());
46	46	}
47	47	}
48	48
49	49	/**
50	50	* Remove a Bed from this Room.
51	51	* This method will remove the given Bed from this Room.
52	52	* However, make sure that this Bed is free of any reservations, as you
53	53	* can't delete a Bed with a reserved period.
54	54	* @see Bed
55	55	* @param bed The Bed to be removed.
56	56	* @pre bed mustn't be null.
57	57	* @pre bed mustn't be the last Bed in this Room.
58	58	* @pre bed must be in this Room.
59	59	* @pre bed mustn't have any reserved periods.
60	60	* @post The amount of Beds in this Room is decremented by 1.
61	61	* @throws IllegalArgumentException if bed is not in this Room, or has
62	62	* reserved periods, or this is the last Bed in the Room.
63	63	* @throws NullPointerException if bed is a null pointer.
64	64	*/
65	65	public void removeBed(Bed bed) {
66	66	// Contract validation
67	67	if(!this.getBeds().contains(bed)) {
68	68	throw IllegalArgumentException("The given Bed is not in this Room.");
69	-	}
+	69	}
70	70	if(bed.hasReservations()) {
71	71	throw IllegalArgumentException("The given Bed still has reserved periods.");
72	-	}
+	72	}
73	73	if(this.getBeds().size() == 1) {
74	74	throw IllegalArgumentException("Deleting this Bed would empty the Room.");
75	-	}
+	75	}
76	76	// Contract validated, execute method
77	77	this.beds.remove(bed);
78	78	// Assert post conditions
79	79	assert !this.getBeds().contains(bed) : "The given Bed was not removed from this Room.";
80	80	}
81	81
82	82	/**
83	83	* Add a Bed to this Room.
84	84	* @post The amount of Beds in this Room increments with 1.
85	85	*/
86	86	public void addBed() {
87	87	this.beds.add(new Bed());
88	88	}
89	89
90	90	/**
91	91	* Returns a copy of all Beds.
92	92	* @return A verbatim copy of all Beds.
93	93	*/
94	94	@SuppressWarnings("unchecked")
95	95	public Set<Bed> getBeds() {
96	96	return (HashSet<Bed>) this.beds.clone();
97	97	}
98	98
99	99	/**
100	100	* Set the type of this Room.
101	101	* @param type The new type of the Room.
102	102	* @pre type mustn't be an empty String, or a null pointer.
103	103	* @post The Room's type is changed to the given type.
104	104	* @throws IllegalArgumentException if type is an empty String.
105	105	* @throws NullPointerException if type is a null pointer.
106	106	*/
107	107	public void setType(String type) {
108	108	if(type.isEmpty()) {
109	109	throw IllegalArgumentException("type is an empty String.");
110	-	}
+	110	}
111	111	this.type = type;
112	112	}
113	113
114	114	/**
115	115	* Returns the type of this Room.
116	116	* @return The secret launch codes of the USS Nimitz, granting access to
117	117	* nuclear warheads so big, you'll lose faith in humanity.
118	118	*/
119	119	public String getType() {
120	120	return type;
121	121	}
122	122
123	123	/**
124	124	* Set the facilities available in this Room.
125	125	* @param facilities The set of facilities in this Room.
126	126	* @pre No facility must be an empty String or a null pointer.
127	127	* @post The Room will have the newly provided facilities.
128	128	* @throws IllegalArgumentException if one of the facilities is an empty String.
129	129	* @throws NullPointerException if any given variable is a null pointer.
130	130	*/
131	131	public void setFacilities(Set<String> facilities) {
132	132	for(String facility : facilities) {
133	133	if(facility.isEmpty()) {
134	134	throw IllegalArgumentException("A facility was an empty String.");
135	-	}
+	135	}
136	136	}
137	137	this.facilities = facilities;
138	138	}
139	139
140	140	/**
141	141	* Returns a copy of all facilities.
142	142	* @return A verbatim copy of all facilities.
143	143	*/
144	144	@SuppressWarnings("unchecked")
145	145	public Set<String> getFacilities() {
146	146	return (HashSet<String>)this.facilities.clone();
147	147	}
148	148
149	149	/**
150	150	* Search for Beds that can be reserved.
151	151	* This method will look through all Beds, and check whether they can be
152	152	* reserved in the given period. You will receive all Beds that can be
153	153	* reserved.
154	154	* @param begin The begin date.
155	155	* @param end The end date.
156	156	* @pre No parameter must be null.
157	157	* @pre begin must strictly come before end.
158	158	* @throws IllegalArgumentException if begin comes after end, or both are
159	159	* equal.
160	160	* @throws NullPointerException if any given parameter is a null pointer.
161	161	* @return A Set of all Beds that can be reserved, or an empty Set if no Bed
162	162	* can be reserved in the given period.
163	163	*/
164	164	public Set<Bed> getEmptyBeds(Date begin, Date end) {
165	165	// Contract validation
166	166	if(!begin.before(end)) {
167	167	throw IllegalArgumentException("begin does not come strictly before end");
168	-	}
+	168	}
169	169	// Validated
170	170	Set<Bed> emptyBeds = new HashSet<>();
171	171	for(Bed bed: this.getBeds()) {
172	172	if(bed.isFree(begin, end)) {
173	173	emptyBeds.add(bed);
174	174	}
175	175	}
176	176	return emptyBeds;
177	177	}
178	178
179	179	}
180	180

1	1	import java.util.HashSet;
2	2	import java.util.Date;
3	3
4	4	/**
5	5	* Represents a reservation in a hostel.
6	6	* Reservation is a simple class that allows one to store reservation
7	7	* information, request it when necessary, and so on.
8	8	* Certain methods are provided for interaction, which use contracts to assert
9	9	* proper functioning.
10	10	*
11	11	* Note: There is a form of redundancy in this class.
12	12	* Reservation holds a Set of Beds, and an integer, indicating the amount of
13	13	* people that are in this Reservation.
14	14	* Normally, the amount of people in the Reservation is determined by the amount
15	15	* of reserved Beds, because the amount of Beds implied the amount of people to
16	16	* facilitate.
17	17	* Because of the design of this program, I've weighed the advantages and
18	18	* disadvantages of holding this implication, of using a seperate member
19	19	* explicitely indicating the amount of people.
20	20	*
21	21	* I've chosen the latter option. It scales better in terms of weird
22	22	* afterthoughts ("I also want to make people sleep on the floor"), but being
23	23	* explicit is also a tad easier to manage. It also allows the other classes to
24	24	* be far more decoupled from Reservation (otherwise, they'd have to check for
25	25	* errors every time themselves, hindering cohesiveness).
26	26	*
27	27	* To overcome the possible difference, I've made it so that, every time, the
28	28	* relation between the values is changed (the people in the Reservation
29	29	* changes, for example), the class automatically checks if the values are
30	30	* corresponding. If they're not, a warning is printed to system.out.err,
31	31	* informing about the fact that there's a discrepancy.
32	32	*
33	33	* I think that's the best way to overcome this problem.
34	34	* @author Maarten Vangeneugden - 1438256
35	35	*/
36	36	public class Reservation {
37	37
38	38	// Members
39	39	private String groupName;
40	40	private Date begin;
41	-	private Date end;
42	-	private Set<Bed> reservedBeds;
+	41	private Date endDate;
+	42	private Set<Bed> reservedBeds;
43	43	private int people; // The amount of people in this Reservation
44	44	private int reservationID;
45	45	private String roomType; // Room type requested by group
46	46	private Set<String> roomFacilities; // Requested room facilities
47	47	private Set<Date> breakfastDays; // Set of days the group wants breakfast
48	-	// Controllers
+	48	// Controllers
49	49	private RoomController roomController;
50	50	private ReservationController reservationController;
51	51
52	52	/**
53	53	* Create a new Reservation.
54	54	* Be aware about the limitations of a Reservation: it's not the
55	55	* Reservation's duty to check whether the provided Beds are properly
56	56	* reserved; take care of this accordingly.
57	57	*
58	58	* Some information is implicit. For example: The size of the set of
59	59	* reserved Beds implies the amount of people in the group; no breakfast
60	60	* days implies no breakfast, ...
61	61	* @param groupName The name of the group.
62	62	* @param people The amount of people that are reserving.
63	63	* @param begin The date that the Reservation begins.
64	-	* @param end The date that the Reservation ends.
65	-	* @param reservedBeds The set of Beds reserved and assigned to this
+	64	* @param endDate The date that the Reservation ends.
+	65	* @param reservedBeds The set of Beds reserved and assigned to this
66	66	* Reservation.
67	67	* @param roomType The requested room type.
68	68	* @param roomFacilities The set of all requested room facilities.
69	69	* @param breakfastDays A set of all days that the group wants breakfast.
70	70	* @param reservationID An ID for this reservation, to differentiate from
71	71	* other Reservations.
72	72	* @pre No parameter must be a null pointer.
73	73	* @pre people must be a natural number, different from 0.
74	74	* @pre begin must come before end.
75	-	* @pre All dates in breakfastDays must fall between begin and end.
76	-	* @pre No string parameter may be empty.
+	75	* @pre All dates in breakfastDays must fall between beginDate and endDate.
+	76	* @pre No string parameter may be empty.
77	77	* @post The amount of people in the Reservation is determined by the amount
78	78	* of reserved Beds.
79	79	* @throws NullPointerException if any parameter is a null pointer.
80	80	* @throws IllegalArgumentException if any of the other preconditions is not
81	81	* met.
82	82	*/
83	83	public Reservation(String groupName, int people, Date begin, Date end, Set<Bed> reservedBeds, String roomType, Set<String> roomFacilities, Set<Date> breakfastDays) {
84	-	// Contract validation:
+	84	// Contract validation:
85	85	if(people < 1) {
86	86	throw IllegalArgumentException("The amount of people should be at least 1.");
87	-	}
+	87	}
88	88	if(!begin.before(end)) {
89	-	throw IllegalArgumentException("The begin date occurs after the end date.");
90	-	}
+	89	throw new IllegalArgumentException("The begin date occurs after the end date.");
+	90	}
91	91	if(groupName.isEmpty() \|\| roomType.isEmpty()) {
92	92	throw IllegalArgumentException("groupName and/or roomType were empty strings.");
93	-	}
+	93	}
94	94	for(String roomFacility: roomFacilities) {
95	95	if(roomFacility.isEmpty()) {
96	96	throw IllegalArgumentException("One of the room facilities was an empty string.");
97	-	}
+	97	}
98	98	}
99	99	for(Date breakfastDay : breakfastDays) {
100	100	if(breakfastDay.before(begin) \|\| breakfastDay.after(end)) {
101	-	throw IllegalArgumentException("One of the breakfast days occurs before/after the reservation period.");
102	-	}
+	101	throw new IllegalArgumentException("One of the breakfast days occurs before/after the reservation period.");
+	102	}
103	103	}
104	104	// Contract validated, execute constructor
105	105	this.groupName = groupName;
106	106	this.people = people;
107	107	this.beginDate = begin;
108	-	this.endDate = end;
109	-	this.reservedBeds = reservedBeds;
+	108	this.endDate = endDate;
+	109	this.reservedBeds = reservedBeds;
110	110	this.reservationID = reservationID;
111	111	this.roomType = roomType;
112	112	this.roomFacilities = roomFacilities;
113	113	this.breakfastDays = breakfastDays;
114	114	}
115	115
116	116	/**
117	117	* Construct template Reservation.
118	118	* Use this constructor if you need to create an empty/new Reservation.
119	119	* It omits the standard restrictions (for example, the group name will be
120	120	* empty) to accomodate for the expected usage of this Reservation.
121	121	*/
122	122	public Reservation() {
123	123	this.groupName = "";
124	124	this.people = 1;
125	125	this.beginDate = new Date();
126	126	this.endDate = new Date();
127	127	this.reservedBeds = new HashSet<>();
128	128	this.reservationID = 0;
129	129	this.roomType = "";
130	130	this.roomFacilities = new HashSet<>();
131	131	this.breakfastDays = new HashSet<>();
132	132	}
133	133
134	134	/**
135	135	* Checks whether the amount of people corresponds with the reserved Beds.
136	136	* Call this method whenever a change in the amount of Beds, or the amount
137	137	* of people is made, or, whenever you need to assure consistency.
138	138	*
139	139	* It also prints a warning to system.out.err to inform about a discrepancy,
140	140	* should one be found.
141	141	*
142	142	* @return True if the counts are consistent, false otherwise.
143	143	*/
144	144	private boolean checkPeopleCountConsistency() {
145	145	int people = this.getPeople();
146	146	int beds = this.getReservedBeds().size();
147	147	if(people != beds) {
148	148	system.out.err("There's a discrepancy in the amount of people in Reservation"+
149	-	this.reservationID +":");
+	149	this.reservationID +":");
150	150	system.out.err("People: "+String.valueOf(people));
151	-	system.out.err("Reserved Beds: "+String.valueOf(beds));
152	-	return false;
+	151	System.err.println("Reserved Beds: "+String.valueOf(beds));
+	152	return false;
153	153	}
154	154	return true;
155	155	}
156	156
157	157	/**
158	158	* Set the group name for this Reservation.
159	159	* @param groupName The new group name.
160	160	* @pre groupName mustn't be empty, or a null pointer.
161	161	* @post The group name is changed to the given name.
162	162	* @throws NullPointerException if groupName is a null pointer.
163	163	* @throws IllegalArgumentException if groupName is an empty String.
164	164	*/
165	165	public void setGroupName(String groupName) {
166	166	if(groupName.isEmpty())
167	167	throw IllegalArgumentException("groupName is an empty String.");
168	-	this.groupName = groupName;
+	168	this.groupName = groupName;
169	169	}
170	170
171	171	/**
172	172	* Retrieve the current group name.
173	173	* @return The group name of this Reservation.
174	174	*/
175	175	public String getGroupName() {
176	176	return this.groupName;
177	177	}
178	178
179	179	/**
180	180	* Get amount of people in this Reservation.
181	181	* @post A warning will be printed to system.out.err if the amount of people
182	182	* is inconsistent with the amount of reserved Beds.
183	183	* @see Reservation.checkPeopleCountConsistency
184	184	* @return The amount of people in this Reservation.
185	185	*/
186	186	public int getPeople() {
187	187	this.checkPeopleCountConsistency();
188	188	return this.people;
189	189	}
190	190
191	191	/**
192	192	* Set the amount of people for this Reservation.
193	193	* Note that this method will not notify you if the new amount of people is
194	194	* equal to the previous amount.
195	195	*
196	196	* This method will print
197	197	* @param people The new amount of people in this Reservation.
198	198	* @pre people must be at least 1.
199	199	* @post A warning will be printed to system.out.err if the amount of people
200	200	* is inconsistent with the amount of reserved Beds.
201	201	* @post The amount of people is changed to the given value.
202	202	* @throws IllegalArgumentException if people is less than 1.
203	203	*/
204	204	public void setPeople(int people) {
205	205	if(people < 1) {
206	206	throw IllegalArgumentException("people must be at least 1.");
207	-	}
+	207	}
208	208	this.people = people;
209	209	this.checkPeopleCountConsistency();
210	210	}
211	211	/**
+	212	/**
+	213	* Returns a copy of the begin Date of this Reservation.
+	214	* @return a copy of the begin Date of this Reservation.
+	215	*/
+	216	public Date getBeginDate() {
+	217	return (Date)this.beginDate.clone();
+	218	}
+	219
+	220	/**
212	221	* Set the begin date for this Reservation.
213	222	* @param begin The new begin date.
214	-	* @pre begin mustn't be a null pointer.
215	-	* @pre begin must come strictly before the end date.
216	-	* @post The begin date is updated accordingly.
+	223	* @pre beginDate mustn't be a null pointer.
+	224	* @pre beginDate must come strictly before the end date.
+	225	* @post The begin date is updated accordingly.
217	226	* @throws NullPointerException if begin is a null pointer.
218	-	* @throws IllegalArgumentException if begin comes after the end date.
219	-	*/
+	227	* @throws IllegalArgumentException if beginDate comes after the end date.
+	228	*/
220	229	public void setBegin(Date begin) {
221	-	if(!begin.before(this.getEnd()))
222	-	throw IllegalArgumentException("begin comes after the end date.");
223	-	this.begin = begin;
224	-	}
+	230	if(!beginDate.before(this.beginDate))
+	231	throw new IllegalArgumentException("beginDate comes after the end date.");
+	232	this.beginDate = beginDate;
+	233	}
225	234
226	235
227	-
+	236	* Returns a copy of the end Date of this Reservation.
+	237	* @return a copy of the end Date of this Reservation.
+	238	*/
+	239	public Date getEndDate() {
+	240	return (Date)this.endDate.clone();
+	241	}
+	242
228	243	/**
229	244	* Set the end date for this Reservation.
230	245	* @param end The new end date.
231	-	* @pre end mustn't be a null pointer.
232	-	* @pre end must come strictly after the begin date.
233	-	* @post The end date is updated accordingly.
+	246	* @pre endDate mustn't be a null pointer.
+	247	* @pre endDate must come strictly after the begin date.
+	248	* @post The end date is updated accordingly.
234	249	* @throws NullPointerException if end is a null pointer.
235	-	* @throws IllegalArgumentException if end comes after the end date.
236	-	*/
+	250	* @throws IllegalArgumentException if endDate comes after the begin date.
+	251	*/
237	252	public Date getDate() {
238	-	return date;
239	-	}
+	253	if(!endDate.before(this.endDate))
+	254	throw new IllegalArgumentException("endDate comes before the begin date.");
+	255	this.endDate = endDate;
+	256	}
240	257
241	258	public void setReservedBeds(Set<Bed> reservedBeds) {
242	259	this.reservedBeds = reservedBeds;
243	260	this.checkPeopleCountConsistency();
244	261	}
245	262
246	263	public Set<Bed> getReservedBeds() {
247	264	return reservedBeds;
248	265	this.checkPeopleCountConsistency();
249	266	}
250	267
251	268	// TODO: Write documentation for all of these, even though it's all mostly
252	269	// copy/pasting. pfffff
253	270	public void setReservationID(int reservationID) {
254	271	this.reservationID = reservationID;
255	272	}
256	273
257	274	public int getReservationID() {
258	275	return reservationID;
259	276	}
260	277
261	278	public void setRoomType(String roomType) {
262	279	this.roomType = roomType;
263	280	}
264	281
265	282	public String getRoomType() {
266	283	return roomType;
267	284	}
268	285
269	286	public void setRoomFacilities(Set<String> roomFacilities) {
270	287	this.roomFacilities = roomFacilities;
271	288	}
272	289
273	290	public Set<String> getRoomFacilities() {
274	291	return roomFacilities;
275	292	}
276	293
277	294	/**
278	295	* Calculates the price of the Reservation, based on its current state.
279	296	* Price table:
280	297	* - 20/person/day
281	298	* - 5 less in low season, 5 more in high season
282	299	* - 4/breakfast ordered
283	300	* - If room is fully booked by the group --> 10% discount
284	301	* @return The price in euros.
285	302	*/
286	303	public int getPrice() {
287	304	int totalPrice = 0;
288	305	// Jan - Apr: Mid
289	306	// May - Aug: High
290	307	// Sep - Dec: Low
291	308
292	309	// Calculate bed prices
293	310	int month = this.getDate().getMonth();
294	-	int bedPrice = 20;
+	311	int bedPrice = 20;
295	312	if(month >=8) { // From September:
296	313	bedPrice -= 5;
297	314	} else if(month >=4) { // From May:
298	315	bedPrice += 5;
299	316	}
300	317	totalPrice += (this.getReservedBeds().size() * this.getNights() * bedPrice);
301	-	// Calculate price for breakfasts
+	318	// allows to retrieve the days between them, because the difference is
+	319	// expressed in milliseconds (nights = ΔDate ÷ 1000 ÷ 60 ÷ 60 ÷ 24)
+	320	long deltaDate = this.getEndDate().getTime() - this.getBeginDate().getTime();
+	321	long nights = deltaDate/1000/60/60/24;
+	322	totalPrice += (this.getReservedBeds().size() * nights * bedPrice);
+	323	// Calculate price for breakfasts
302	324	int breakfasts = this.getBreakfastDays().length;
303	325	totalPrice += breakfasts * this.getReservedBeds().size();
304	326	// Check if eligible for discount
305	327	for(Room room: roomController.getRooms()) {
306	328	Set<Bed> roomBeds = room.getBeds();
307	329	if(roomBeds.containsAll(this.reservedBeds)) {
308	330	double discount = (double)totalPrice * 0.1;
309	331	totalPrice -= (int)discount;
310	332	}
311	333	}
312	334	return totalPrice;
313	335	}
314	336
315	337
316	338
317	339
318	340
319	341
320	342
321	343	public void setBreakfastDays(int[] breakfastDays) {
322	344	this.breakfastDays = breakfastDays;
323	345	}
324	346	public int[] getBreakfastDays() {
325	347	return this.breakfastDays;
326	348	}
327	349
328	350	}
329	351

1	1	import java.util.Set;
2	2	import java.util.HashSet;
3	3	import java.util.Date;
4	4	/**
+	5	/**
5	6	* Creates a view screen that allows interaction with the reservation.
6	7	* This window will place the reservation details in editable fields, so its
7	8	* state can be adapted.
8	9	* It then also adds a couple of buttons; add/update/cancel, with their
9	10	* respective actions. These will then be passed to the ReservationController.
10	11	* It will not allow to add/update a reservation if dates overlap, i.e. beds
11	12	* can't be reserved for that period.
12	13	* @author Maarten Vangeneugden - 1438256
13	14	*/
14	15	public class ReservationView {
15	16
16	17	private Reservation reservation;
17	18	private Window window;
18	19
19	20	// Controllers for communication with the rest
20	21	private ReservationController rc;
21	22	private RoomController roc;
22	23
23	24	// GUI widgets
24	25	private JTextField nameField;
25	26	private JSpinner amountPeopleField;
26	27	private JTextField dateField;
27	-	private JSpinner durationField;
+	28	private JTextField endDateField;
+	29	private JSpinner durationField;
28	30	private JRadioButton[] typeField;
29	31	private JCheckBox showerField;
30	32	private JCheckBox bathField;
31	33	private JCheckBox minibarField;
32	34	private JCheckBox aircoField;
33	35
34	36
35	37	/**
36	38	* Construct a window to edit a Reservation.
37	39	* This window presents its caller with the necessary tools to edit the
38	40	* given Reservation, and save it in the system.
39	41	*
40	42	* By sending it an empty Reservation, you can add a new Reservation to the
41	43	* system.
42	44	* This class is built in a way that allows it to be used for both creating
43	45	* new Reservations, and updating/changing existing Reservations.
44	46	* Existing Reservations can also be removed by clicking the appropriate
45	47	* button.
46	48	* @param reservation The Reservation that will be updated.
47	49	* @param rc The ReservationController class.
48	50	* @param roc The RoomController class.
49	51	* @pre No parameter may be a null pointer.
50	52	* @post A window is displayed with GUI widgets, which are filled in
51	53	* according to the state of reservation.
52	54	* @throws NullPointerException if any parameter is a null pointer.
53	55	*/
54	56	public ReservationView(Reservation reservation, ReservationController rc, RoomController roc) {
55	57	// Contract validation
56	58	if(rc == null \|\| roc == null \|\| reservation == null)
57	59	throw NullPointerException("One or more of the given parameters is a null pointer.");
58	-	// Contract validated
+	60	// Contract validated
59	61	this.rc = rc;
60	62	this.roc = roc;
61	63
62	64	this.reservation = reservation;
63	65	this.window = new Window("Reservation screen");
64	66	this.addFields();
65	67	}
66	68
67	69	public void setReservation(Reservation reservation) {
68	70	this.reservation = reservation;
69	71	}
70	72
71	73	public Reservation getReservation() {
72	74	return reservation;
73	75	}
74	76
75	77	/**
76	78	* Add the necessary fields to the window.
77	79	* This method inspects the Reservation, and copies the included information
78	80	* to the widget's content.
79	81	*/
80	82	private void addFields() {
81	83	this.window.createLabel("Group name");
82	84	this.nameField = window.createTextField(this.reservation.getGroupName());
83	85	this.window.createLabel("Amount of people");
84	86	this.amountPeopleField = window.createSpinner(1, 20, this.reservation.getPeople(), 1);
85	87	// Formatting date for the date field:
86	88	this.window.createLabel("Begin date");
87	89	this.beginDateField = window.createTextField(this.reservation.getBegin().toString());
88	90	this.window.createLabel("End date");
89	91	this.endDateField = window.createTextField(this.reservation.getEnd().toString());
90	92	String[] types = {"Male", "Female", "Mixed"};
91	93	this.typeField = this.window.createRadioButtons(types);
92	94	// TODO: Add a test to see if the Reservation has indicated which type
93	95	// it is, and then already check the corresponding radio button.
94	96	this.showerField = this.window.createCheckbox("Shower");
95	97	this.bathField = this.window.createCheckbox("Bath");
96	98	this.minibarField = this.window.createCheckbox("Minibar");
97	99	this.aircoField = this.window.createCheckbox("Airco");
98	100	// TODO: Idem for the facilities, test if already in Reservation, and
99	101	// check accordingly.
100	102	this.window.createButton("Add/Update reservation", "", "addReservation", this);
101	103	this.window.createButton("Remove reservation", "", "removeReservation", this);
102	104	}
103	105
104	106	/**
105	107	* Start the addition of this Reservation to the system.
106	108	* This method will check the current fields, and update the Reservation
107	109	* with those values. In doing so, the validity of the values is checked
108	110	* (formatting, begin date before end date, ...).
109	111	* If everything is okay, the method will check if these changes are
110	112	* possible in the current system; are there enough empty beds?
111	113	*
112	114	* If everything is okay, the changes will be propagated to the
113	115	* Reservation's state, and (if it's a new Reservation) will be added to the
114	116	* system's active Reservations.
115	117	*/
116	118	public void addReservation() {
117	119	// Collect all data from the fields
118	120	String name = this.nameField.getText();
119	121	Date beginDate = null, endDate = null;
120	122	try {
121	123	beginDate = DataFormat.parse(this.beginDateField.getText());
122	-	endDate = DataFormat.parse(this.endDateField.getText());
123	-	}
+	124	endDate = new Date(this.endDateField.getText());
+	125	}
124	126	catch(ParseException e) {
125	-	this.window.messageDialog("Not all date fields were properly formatted.");
+	127	this.window.messageDialog("Not all date fields were properly formatted.");
126	128	return;
127	129	}
128	130	int people = (Integer)this.amountPeopleField.getValue();
129	131	String type = "";
130	132	for(int i=0; i<this.typeField.length; i++) {
131	133	if(this.typeField[i].isSelected()) {
132	134	type = this.typeField[i].getText();
133	135	break;
134	136	}
135	137	}
136	138	Set<String> facilities = new HashSet<>();
137	139	if(this.showerField.isSelected()) {
138	140	facilities.add("Shower");
139	141	}
140	142	if(this.bathField.isSelected()) {
141	143	facilities.add("Bath");
142	144	}
143	145	if(this.minibarField.isSelected()) {
144	146	facilities.add("Minibar");
145	147	}
146	148	if(this.aircoField.isSelected()) {
147	149	facilities.add("Airco");
148	150	}
149	151
150	152	// TODO breakfast days handling
151	153
152	154	//Set<Room> possibleRooms = this.roc.getQualifiedRooms(actualDate, duration, type, facilities);
153	155	// TODO: Refactor upper method to work with the Reservation.
154	156	// TODO: Implement all checks of valid data above this line!
155	157
156	158	// Data validated; Try finding appropriate beds
157	159	if(possibleRooms.size() == 0) {
158	160	boolean tryAgain = this.window.confirmDialog("No rooms met the requirements! Would you like to continue and change the parameters?");
159	161	if(!tryAgain) {
160	162	// TODO close window
161	163	}
162	164	}
163	165	else {
164	166	Room pickedRoom = null;
165	167	for(Room room: possibleRooms) {
166	168	if(room.getEmptyBeds(actualDate, actualEndDate).size() < room.getBeds().size()) {
167	169	// First, fill the rooms that are partially filled.
168	170	pickedRoom = room;
169	171	break;
170	172	}
171	173	}
172	174	if(pickedRoom == null) { // If still no room, pick an empty room
173	175	for(Room room: possibleRooms) {
174	176	if(room.getEmptyBeds(actualDate, actualEndDate).size() >= amount) {
175	177	pickedRoom = room;
176	178	break;
177	179	}
178	180	}
179	181	}
180	182	assert pickedRoom != null;
181	183	// TODO: Set reservation fields here!
182	184	this.rc.addReservation(reservation, pickedRoom);
183	185
184	186	// Confirm and show price:
185	187	int price = this.reservation.getPrice();
186	188	this.window.confirmDialog("Reservation confirmed! Price: " +String.valueOf(price));
187	189	}
188	190
189	191	}
190	192
191	193	/**
192	194	* Remove Reservation and the GUI.
193	195	* Calling this method will remove the Reservation, followed by closing this
194	196	* window.
195	197	* If the Reservation is active (i.e. saved in the ReservationController),
196	198	* it will be removed.
197	199	* Any changes will be cancelled.
198	200	*/
199	201	public void removeReservation() {
200	202	if(this.rc.getReservations().contains(this.reservation)) {
201	203	this.rc.cancelReservation(this.reservation);
202	204	}
203	205	this.window.close();
204	206	}
205	207	}
206	208

1	1	import java.util.Date;
2	2	import java.util.HashSet;
3	3
4	4	/**
5	5	* Holds all Rooms in the hostel.
6	6	* The hostel contains a set of Rooms, with facilities and stuff.
7	7	* This class takes care of storing all those Rooms, and provides methods to
8	8	* manage this, like removing Rooms, adding Rooms, ...
9	9	* @author Maarten Vangeneugden - 1438256
10	10	*/
11	11	public class RoomController {
12	12
13	13	private Set<Room> rooms;
14	14
15	15	public RoomController() {
16	16	this.rooms = new HashSet<>();
17	17	}
18	18
19	19
20	20	public Set<Room> getRooms() {
21	21	return rooms;
22	22	}
23	23
24	24	/**
25	25	* Returns all rooms that meet the given requirements.
26	26	* This method will search through all rooms, and check which rooms qualify.
27	27	* Currently, this method checks for the following things:
28	28	* - Is the requested type available?
29	29	* - Does the Set of requested facilities form a subset of the Room's
30	30	* facilities?
31	31	* - Are there any Beds in the Room that can be reserved in the given
32	32	* period?
33	33	* @param reservation The Reservation for which to find eligible rooms.
34	34	* @pre reservation mustn't be null.
35	35	* @throws NullPointerException if reservation is a null pointer.
36	36	* @return A set of all rooms that meet the requirements, or an empty set if
37	37	* none were found.
38	38	*/
39	39	public Set<Room> getQualifiedRooms(Reservation reservation) {
40	40	Set<Room> qualifiedRooms = new HashSet<>();
41	41	for(Room room : this.getRooms()) {
42	42	if(room.getType().equals(reservation.getType()))
43	-	continue;
+	43	continue;
44	44	if(!room.getFacilities().containsAll(reservation.getFacilities()))
45	-	continue;
+	45	continue;
46	46	if(room.getEmptyBeds(reservation.getBegin(), reservation.getEnd()).isEmpty())
47	47	continue;
48	48	// The Room fulfills all requirements at this point, so add it to
49	49	// the set
50	50	qualifiedRooms.add(room);
51	51	}
52	52	return qualifiedRooms;
53	53	}
54	54	}
55	55

1	1
2	2	## GRASP
3	3	Om zoveel mogelijk tegemoet te komen aan de GRASP-richtlijnen, heb ik volgende
4	4	ontwerpkeuzes toegepast voor de verschillende richtlijnen.
5	5
6	6	### High cohesion & Low coupling
7	7	- Veel classes zijn totaal van elkaar losgekoppeld. Een goed voorbeeld hiervan
8	8	is Bed; Bed weet niet over dat er Reservaties bestaan, zelfs niet in welke
9	9	Room het 'staat'.
10	10	- Als er toch gekoppeld moet worden, dan blijft dit tot een minimum beperkt; Een
11	11	Room weet wel welke Bedden het heeft, maar niet hoe deze gebruikt worden, een
12	12	Reservation weet wel welke Bedden voor hem gereserveerd zijn, maar heeft geen
13	13	weet van welke kamer dat deze staat.
14	14	- Uitzondering op deze regel vormen de Controller-classes; omwille van hun taken
15	15	zijn deze vaak verplicht om van veel verschillende classes op de hoogte te
16	16	zijn.
17	17
18	18	### Indirectie
19	19	- In plaats van functionaliteit toe te wijzen aan class X om met class Y te
20	20	interageren, wordt er vaak gebruik gemaakt van een class Z, die deze
21	21	verantwoordelijkheid op zich neemt.
22	22	- Dit wordt toegepast d.m.v. een MVC-structuur, waarin de \*Controller-classes
23	23	als 'tussenpersoon' werken.
24	24	- Dit komt ook tegemoet aan de eigenschappen van Information Expertise.
25	25
26	26	### Creator
27	27	- Controllers staan ook in als zgn. Creators van de models die ze beheren. Ze
28	28	voldoen dan ook aan de eigenschappen zoals
29	29	[hier](https://en.wikipedia.org/wiki/GRASP_(object-oriented_design)#Creator)
30	30	opgesomd wordt.
31	31
32	32
33	33	## SOLID
34	34
35	35	### Single Responsibility
36	36
37	37	## Algemene keuzes ter bevordering codekwaliteit
38	38
39	39	## Strings, integers, ... i.p.v. Enums/Eigen classes
40	40	In het programma zijn er sommige members die doen vermoeden dat ze beter als
41	41	Enums aangeduid kunnen worden; Het type van een kamer, faciliteiten, ...
42	42
43	43	In plaats van een speciale class hiervoor te maken, heb ik gekozen om deze
44	44	gewoon te behandelen als simpele Strings in lijsten.
45	45
46	46	Het voordeel aan deze werkwijze, is dat Strings in Java SE quasi universeel
47	47	voorkomen; data kunnen geconverteerd worden naar Strings (en vice versa), veel
48	48	gebruikte GUI-libraries (waaronder Swing, JavaFX, ...) gebruiken Strings voor
49	49	tekst voor te stellen in de GUI-widgets, ...
50	50	Daarnaast weet iedereen die ook maar een beetje geschoold is in Java, direct hoe
51	51	deze members behandeld kunnen worden. Had ik een class gemaakt die bv.
52	52	RoomFacilities heette, dan is die parate kennis over de taal zelf nutteloos.
53	53
54	54	Strings zijn ook voorzien van extreem veel methods, en zijn dus zeer flexibele
55	55	classes om te gebruiken. Het feit dat ze zo makkelijk doorheen het programma te
56	56	gebruiken zijn is dus een groot pluspunt.
57	57
58	58	Als dat nog niet genoeg is: Het gebruiken van de hulpmiddelen uit de _standard
59	59	library_ is niet enkel waarvoor libraries überhaupt bestaan, het beperkt ook
60	60	het benodigde aantal classes in de eigen software, waardoor het geheel
61	61	uiteindelijk veel overzichtelijker blijft, en bijgevolg, makkelijk uit te
62	62	breiden, te testen, te begrijpen, ...
63	63
64	64	Al deze voordelen graan grotendeels verloren als ik beslis om zelf
65	65	gespecialiseerde classes op te stellen.
66	66	Men kan misschien stellen dat "de voordelen die het schrijven van eigen
67	67	classes veel beter tegemoet komt aan de essentie van object-georiënteerd
68	68	programmeren, dan zich _beperken_ tot slechts een handvol generieke classes, die
69	69	misschien niet volledig aan de benodigdheden beantwoorden".
70	70
71	71	Toch laat ik mijn afweging overslaan in het voordeel van minder classes, en meer
72	72	uniformiteit. _Sometimes, less is more._ Meer classes betekent ook:
73	73	- Meer onderhoud
74	74	- Meer kans op bugs
75	75	- Groter programma
76	76
77	77	En al die problemen resulteren op lange termijn in:
78	78	- Slechtere uitbreidbaarheid
79	79	- Slechtere onderhoudbaarheid
80	80	- Slechtere schaalbaarheid
81	81
82	82	Zijn al die problemen de moeite van een (zogezegd) "beter object-georiënteerd
83	83	design" wel waard?
84	84	Veel mensen stellen juist dat OOP net voordelig is als men op zoek is naar
85	85	- Uitbreidbaarheid
86	86	- Onderhoudbaarheid
87	87	- Modulariteit
88	88	- Schaalbaarheid
89	89
90	90	Als de voordelen van het paradigma verdwijnen als ik dat "beter design" volg,
91	91	is dat design dan wel echt beter?
92	92
93	93
94	94	**Conclusie: Uniforme classes zijn volgens mij soms beter dan een stel
95	95	gespecialiseerde classes. Daarom dat ik mij soms behelp met Strings, intergers,
96	96	... i.p.v. zelf een oplossing te schrijven.**
97	97
98	98
99	99	### Null pointers
100	100	Het valt misschien op dat ik doorheen mijn programma in veel contracten eis dat
101	101	geen enkele parameter een zgn. null pointer is.
102	102
103	103	Het gebruik van null pointers staat garant voor een overvloed aan moeilijk te
104	104	vinden bugs die (door het design van objectgeörienteerd programmeren) enorm diep
105	105	kunnen doorpropageren.
106	106
107	107	Ik maak er een kerntaak van dat, als er aan mijn programma gewerkt wordt, de
108	108	programmeur zichzelf steeds kan garanderen dat alle data die hij
109	109	ontvangt, valide data is.
110	110	Op deze manier valt er een hele last van de schouders van de programmeur; een
111	111	reeks fouten worden voorkomen, simpelweg door een strikt schema aan te houden.
112	112
113	113	Het controleren op null pointers wordt op 2 manieren gedaan:
114	114	- Gebruik van methods aanwezig in het gegeven type. Als de gegeven variabele
115	115	een null pointer is, zal het programma direct crashen, en een
116	116	NullPointerException geven.
117	117	- Expliciet testen of var == null. Wordt toegepast op parameters die direct
118	118	als members opgeslagen dienen te worden.
119	119
120	120	Deze (contractuele) controle laat toe dat, mocht er een null pointer gebruikt
121	121	worden, het programma de programmeur hiervan direct op de hoogte stelt, en dit
122	122	op het laagst mogelijke niveau (namelijk de eerste method waar deze waarde
123	123	gebruikt wordt).
124	124
125	125	### Cloning
126	126	members 'private' maken (encapsuleren) is volledig nutteloos als men getters en
127	127	setters op deze members toepast; In Java worden references doorgegeven (m.u.v.
128	128	primitives), die de hele notie van encapsulatie voorbijgaan (bij sommige types).
129	129	Een voorbeeld hiervan is het privatiseren van een Set<T>-member: men kan daar
130	130	een 'getSet()'-method op plaatsen, en dan toch de inhoud van deze 'private'
131	131	aanpassen.
132	132
133	133	Ik heb geopteerd om, waar van toepassing, deze variabelen te 'clonen', om zo
134	134	exacte kopieën terug te geven.
135	135	Deze manier van werken brengt enkele voordelen teweeg:
136	136	- Zeer defensief programmeren; De ontwikkelaar kan geen members aanpassen als
137	137	dat niet de bedoeling was
138	138	- Duidelijkheid code: getSet().clear() zal de member niet meer leegmaken. Om dat
139	139	te doen, moet men gebruikmaken van de method die daarvoor bedoeld is:
140	140	setSet(clearedSet)
141	141
142	142	### Inheritance
143	143	Overerving is een goed concept over het algemeen, maar niet in OOP.
144	144	De problemen omtrent impliciet gedrag en onnodige state zijn al te vaak
145	145	beschreven met OOP-inheritance.
146	146
147	147	Ik heb in mijn programma geen gebruik gemaakt van inheritance, exact omwille van
148	148	de problemen die het voortbrengt, zeker in termen van herbruikbaarheid en
149	149	robuustheid, wat toch zware vereisten waren voor deze opdracht.
150	150
151	151	Ik heb al mijn problemen makkelijk kunnen oplossen d.m.v. compositie.
152	152
153	153	### Benaming variabelen
154	154	Doorheen mijn programma maak ik heel veel gebruik van dezelfde benamingen.
155	155	Bijvoorbeeld: Een variabele van het type Reservation zal haast altijd
156	156	'reservation' heten, een Set van een bepaald type zal de naam van datzelfde type
157	157	dragen, in het meervoud, ...
158	158
159	159	Sommige programmeurs gebruiken liever afkortingen (bv. 'reservation' -->
160	160	'resv'), omdat dit sneller schrijft.
161	161
162	162	Naar mijn mening moet men bij deze werkwijze inleveren aan leesbaarheid, vooral
163	163	wanneer iemand die nog nooit met de code gewerkt heeft, dit programma moet
164	164	overnemen.
165	165
166	166	Daarnaast zorgt de consistentie van woordgebruik ervoor dat een andere
167	167	programmeur, doorheen het hele programma dezelfde context in zijn/haar gedachten
168	168	kan gebruiken.
169	169
170	170
171	171
172	172
173	173	------------------------------------------------------------ TODO
174	174	## Toepassing types/classes
175	175	Doorheen het programma heb ik getracht zoveel mogelijk gebruik te maken van
176	176	types/classes die
177	177	- Veelvoorkomend zijn in de Java STL (Zoals String, Set, List, ...)
178	178	- primitief zijn (ints, ...), omdat deze operatoren hebben en de code
179	179	leesbaarder maken
180	180
181	181	Een goed voorbeeld hiervan zijn bv. de faciliteiten:
182	182	I.p.v. een aparte "Facility"-class te maken, heb ik de verschillende
183	183	faciliteiten voorgesteld door een simpele String. De voordelen van deze aanpak
184	184	zijn ook direct duidelijk:
185	185	- Betekenis is direct duidelijk; de faciliteit letterlijk in de code vernoemd
186	186	- Makkelijke interactie met GUI, die sowieso Strings vraagt voor bv. JLabel
187	187	- Uitbreidbaarheid wordt bekomen door simpelweg een nieuwe String te
188	188	introduceren
189	189
190	190	## View en GUI
191	191	Werken met GUI's is vaak tijdrovend en veroorzaakt snel errors, zeker met bv.
192	192	anonieme methods, exceptions, ...
193	193	Alhoewel mijn programma grotendeels in een MVC-stijl is geschreven, maken de
194	194	view-classes (RegistrationView, SearchView, ...) achterliggend gebruik van een
195	195	zelfgemaakt framework om makkelijk vensters te maken.
196	196	Dit kleine framework is een persoonlijk hobbyproject dat ik JSugar noem.
197	197	Het biedt een heleboel voordelen, vergeleken met elk GUI-venster zelf opstellen:
198	198	- Vaak gebruikte GUI-widgets (zoals een label, textfield) worden aangemaakt en
199	199	toegevoegd door slechts 1 method op te roepen
200	200	- JSugar maakt gebruik van reflectie om op een leesbare en uitbreidbare manier
201	201	knoppen te activeren:
202	202	public JButton createButton(String text, String action, String methodName, Object triggerObject)
203	203	'methodName' is een simpele String, en 'triggerObject' is het object waar deze
204	204	method moet worden opgeroepen.
205	205	- Automatische uitlijning van widgets
206	206	Voor meer informatie kunt u JSugar-readme.md raadplegen.
207	207
208	208	## java.util.Date
209	209
210	210	Doorheen het programma maak ik vaak gebruik van de Date-class uit de Java STL,
211	211	om de volgende redenen:
212	212	- Uitbreidbaarheid: Door overal eenzelfde type te gebruiken, is het gemakkelijk
213	213	om nieuwe modules toe te voegen, zonder dat daarvoor abstractielagen etc.
214	214	nodig zijn.
215	215	- Uniformiteit: Eenzelfde type uit de STL laat de ontwikkelaar toe om door het
216	216	hele programma heen hetzelfde denkpatroon aan te houden; een
217	217	Stringvoorstelling hier, een integer daar, ... veroorzaken problemen en bugs,
218	218	die met deze class voorkomen worden.
219	219
220	220	## Bedden
+	221
+	222	Het moeilijkste om te implementeren waren de data voor ontbijt.
+	223	Er wordt voor de reservaties steeds een set bijgehouden van de data waarop
+	224	ontbijt besteld is.
+	225	Op zich is dit niet zo moeilijk. Het moeilijke hieraan, is de gebruiker van het
+	226	programma op een begrijpelijke manier deze data te laten invoeren.
+	227	Data worden ingevoerd via tekstvelden, omdat Swing geen zgn. "DatePicker" heeft.
+	228
+	229	## Bedden
221	230
222	231	Ik heb voor bedden een aparte class aangemaakt, omdat deze een bepaalde state
223	232	bijhouden, nml. wanneer ze gereserveerd zijn.
224	233
225	234
226	235	## Reservation
227	236	Voor de reservaties heb ik besloten om enkel die data bij te houden die inherent
228	237	gerelateerd is aan die reservatie:
229	238	- Enkel gereserveerde bedden i.p.v. gereserveerde kamers. Qua uitbreidbaarheid
230	239	heeft dit tot gevolg dat men gemakkelijk kan uitbreiden naar reservaties,
231	240	gespreid over verschillende kamers.
232	241
233	242
234	243	## ReservationView
235	244	Merk op hoe in ReservationView de data van de Reservation direct in de GUI wordt
236	245	geplaatst.
237	246	Dit staat toe om zeer gemakkelijk deze class te hergebruiken voor zowel het
238	247	aanmaken als het updaten van de reservatie.
239	248