Kont 2017

public class Meal implements Iterable<Course> {

	...

	private Collection<Course> courses;

	//
	
	public void addCourse(Course course) {
		this.courses.add(course);
	}
	
	public void removeCourse(Course course) {
		this.courses.remove(course);
	}

	// implement Iterable<Course>

	@Override
	public Iterator<Course> iterator() {
		return courses.iterator();
	}
}

private Map<Course, Double> courses;
private Map<Meal, Double> meals;

public double getPrice(Course course) throws IllegalArgumentException {
   if (! courses.containsKey(course)) {
      throw new IllegalArgumentException("This menu does not include the course " + course.name);
   }
   return courses.get(course);
}
 
public void updatePrice(Course course, double price) {
   courses.put(course, price);
}
 
public double getPrice(Meal meal) throws IllegalArgumentException {
   if (! meals.containsKey(meal)) {
      throw new IllegalArgumentException("This menu does not include the meal " + meal.getName());
   }
   double total = meals.get(meal);
   if (total == 0.0) {
      for (Course course : meal) {
         total += getPrice(course);
      }
   }
   return total;
}
 
public void updatePrice(Meal meal, double price) {
   meals.put(meal, price);
}

private Collection<Course> courses = new ArrayList<>();
private Collection<Meal> meals = new ArrayList<>();
 
public void addCourse(Course course) {
   this.courses.add(course);
}
 
public void addMeal(Meal meal) {
   this.meals.add(meal);
}

private final Menu menu;
 
public Table(Menu menu) {
   this.menu = menu;
}
 
public double getPrice() throws IllegalStateException {
   double total = 0.0;
   for (Course course : courses) {
      try {
         total += menu.getPrice(course);
      } catch (IllegalArgumentException e) {
         throw new IllegalStateException(e);
      }
   }
   for (Meal meal : meals) {
      try {
         total += menu.getPrice(meal);
      } catch (IllegalArgumentException e) {
         throw new IllegalStateException(e);
      }
   }
   return total;
}

public abstract class MenuItem {

	private final String name, description;

	protected MenuItem(String name, String description) {
		this.name = name;
		this.description = description;
	}

	public String getName() {
		return name;
	}

	public String getDescription() {
		return description;
	}
}

public class Course extends MenuItem {
    public Course(String name, String description) {
		super(name, description);
	}
	...
}
 
public class Meal extends MenuItem {
    public Meal(String name, String description) {
		super(name, description);
	}
	...
}

public class Menu {
	private Map<MenuItem, Double> items;

	public double getPrice(Course course) throws IllegalArgumentException {
		if (! items.containsKey(course)) {
			throw new IllegalArgumentException("This menu does not include the course " + course.getName());
		}
		return items.get(course);
	}

	public void updatePrice(MenuItem item, double price) {
		items.put(item, price);
	}

	public double getPrice(Meal meal) throws IllegalArgumentException {
		if (! items.containsKey(meal)) {
			throw new IllegalArgumentException("This menu does not include the meal " + meal.getName());
		}
		double total = items.get(meal);
		if (total == 0.0) {
			for (Course course : meal) {
				total += getPrice(course);
			}
		}
		return total;
	}
}
 
public class Table {

	private Collection<MenuItem> items = new ArrayList<>();


	// har endret fra to add-metoder til én
	public void addItem(MenuItem item) {
		this.items.add(item);
	}

	//

	private final Menu menu;

	public Table(Menu menu) {
		this.menu = menu;
	}

	public double getPrice() throws IllegalStateException {
		double total = 0.0;
		for (MenuItem item : items) {
			try {
				// note: cannot use menu.getPrice(item), since there is no menu.getPrice(MenuItem) method
				if (item instanceof Course) {
					total += menu.getPrice((Course) item);
				} else if (item instanceof Meal) {
					total += menu.getPrice((Meal) item);
				}
			} catch (IllegalArgumentException e) {
				throw new IllegalStateException(e);
			}
		}
		return total;
	}
}

private Kitchen kitchen;


// setter
public void setKitchen(Kitchen kitchen) {
	... her kommer det mere siden ...
	this.kitchen = kitchen;
	... her kommer det mere siden ...
}

// må si fra til kjøkkenet (hvis satt) når noe bestilles
public void addItem(MenuItem item) {
	this.items.add(item);
	if (kitchen != null) {
		kitchen.menuItemAdded(this, item);
	}
}

public class Kitchen {
 
	...
 
	private Collection<KitchenListener> kitchenListeners = new ArrayList<KitchenListener>();

	public void addKitchenListener(KitchenListener listener) {
		kitchenListeners.add(listener);
	}

	public void removeKitchenListener(KitchenListener listener) {
		kitchenListeners.remove(listener);
	}

	private void fireCourseReady(Table table, Course course) {
		for (KitchenListener listener : kitchenListeners) {
			listener.courseReady(table, course);
		}
	}
}

public class Table implements KitchenListener {
 
	...
 
	public void setKitchen(Kitchen kitchen) {
		if (this.kitchen != null) {
			this.kitchen.removeKitchenListener(this);
		}
		this.kitchen = kitchen;
		if (this.kitchen != null) {
			this.kitchen.addKitchenListener(this);
		}		
	}
 
	@Override
	public void courseReady(Table table, Course course) {
		// reaksjon på varslingen
	}
}

private void produceCourse(Table table, Course course) {
	Collection<Course> courses = courseQueue.get(table);
	if (courses == null) {
		courses = new ArrayList<Course>();
		courseQueue.put(table, courses);
	}
	courses.add(course);
}

private void courseProduced(Table table, Course course) {
	Collection<Course> courses = courseQueue.get(table);
	if (courses != null) {
		courses.remove(course);
		fireCourseReady(table, course);
	}
}

public void menuItemAdded(Table table, MenuItem item) {
	if (item instanceof Course) {
		produceCourse(table, (Course) item);
	} else if (item instanceof Meal) {
		for (Course course : (Meal) item) {
			produceCourse(table, course);
		}			
	}
}

public Course findCourse(Predicate<Course> test) {
	for (Course course : courses) {
		if (test.test(course)) {
			return course; 
		}
	}
	return null;
}

protected void setUp() throws Exception {
	c1 = new Course("c1", "c1");
	c2 = new Course("c2", "c2");
	meal = new Meal("test", "test", new Course[]{ c1, c2});
}

 public void testIterator() {
 	Iterator<Course> it = meal.iterator();
 	assertTrue(it.hasNext());
 	assertEquals(c1, it.next());
 	assertTrue(it.hasNext());
 	assertEquals(c2, it.next());
 	assertFalse(it.hasNext());
 }

public void testFindCourse() {
	assertEquals(c1, meal.findCourse(course -> course.name.equals("c1")));
}