Page History

I denne oppgaven skal du implementere klasser og metoder for å håndtere en dagsplan med tidsrom, f.eks. avtaler. Klassen oppgitt i oppgave 1 a) kan brukes som en del av implementasjonen din. Husk at alle metoder kan brukes i implementasjonen av andre.

Oppgave a)

Du skal implementere en klasse TimeSlot for å representere et tidsrom innenfor en dag, f.eks. en avtale. Et TimeSlot-objekt har en beskrivelse (tekst), et start- og sluttidspunkt (time og minutt) og en varighet (minutter). Ingen av disse dataene skal kunne endres etter at TimeSlot-objektet er opprettet. Du velger selv hvordan disse dataene skal representeres og hvilke hjelpemetoder som evt. trengs. Merk at varighet kan beregnes fra starttidspunkt og sluttidspunkt, evt. at sluttidspunkt kan beregnes fra starttidspunkt og varighet.

Implementer følgende metoder inkl. nødvendige deklarasjoner av felt og hjelpemetoder:

- boolean containsWord(String word): returnerer om word finnes i denne ordlista.

- Collection<String> getWordsStartingWith(String prefix): returnerer en samling av alle ordene i denne ordlista som begynner med bokstavene i prefix. Dersom prefix selv finnes i ordlista, så skal den også være med. Denne metoden er nyttig for å kunne foreslå ord som passer til det en har begynt å skrive. F.eks. kan den kalle metoden med ordet ”program” og få tilbake en liste som bl.a. inneholder ordene ”program”, ”programmer”, ”programmerer” og ”programmering” (forutsatt at disse faktisk er lagt inn i denne ordlista på forhånd).

- boolean addWord(String word): Legger word til denne ordlista, dersom word ikke finnes i ordlista fra før. Mellomrom foran og bak skal fjernes og tomme ord skal ikke legges inn. Returverdien skal angi om ordlista faktisk ble endret.

- boolean removeWord(String word): Fjerner word fra denne ordlista. Returverdien skal angi om ordlista faktisk ble endret.

- boolean removeWordsStartingWith(String prefix): Fjerner alle ord som begynner på prefix fra denne ordlista. Dersom den kalles med med ordet ”program” så skal bl.a. ordene ”program”, ”programmer”, ”programmerer” og ”programmering” fjernes fra denne ordlista. Som for removeWord skal returverdien angi om noen ord i ordlista faktisk ble fjernet.

private Collection<String> wordList = new ArrayList<String>();

public boolean containsWord(String s) {
      return wordList.contains(s);
}
public Collection<String> getWordsStartingWith(String s) {
      Collection<String> matchingWords = new ArrayList<String>();
      for (String word : wordList) {
            if (word.startsWith(s)) {
                  matchingWords.add(word);           }
     }
     return matchingWords;
}

public boolean addWord(String s) {
      s = s.trim();
      return (s.length() > 0 && (! wordList.contains(s)) ? wordList.add(s) : false);
}

public boolean removeWord(String s) {
      return wordList.remove(s);
}

public boolean removeWordStartingWith(String s) {
      return wordList.removeAll(getWordsStartingWith(s));
}

Oppgave b)

Det er noen ganger nyttig å kunne finne alle ord som har et gitt sett med endelser. Implementer følgende metoder, som er til hjelp for dette.

- String getPrefix(String word, String suffix): Dersom word ender på suffix så skal prefikset frem til suffix-endelsen returneres. Ellers skal null returneres. F.eks. skal getPrefix(”java-program”, ”program”) returnere ”java-”, mens getPrefix(”java-program”, ”programmering”) skal returnere null.

- boolean hasSuffixes(String prefix, List<String> suffixes): Returnerer true dersom prefix finnes i denne ordlista med alle endelsene i suffixes-lista. Dersom du legger ”tjue-en” og ”tjue-to” inn i ordlista og kaller metoden med argumentene ”tjue-” og en liste med ordene ”en” og ”to”, så skal metoden altså returnere true.

konstruktører og metoder:

• TimeSlot(String description, int hours, int minutes, int duration): initialiserer med oppgitt beskrivelse og starttidspunkt (timer og minutter) og varighet (minutter). F.eks. vil new TimeSlot(”TDT4100-forelesning”, 10, 15, 105) representere en TDT4100-forelesning i tidsrommet 10:15-12:00.
• String toString(): returnerer en String på formen beskrivelse@start-slutt hvor start og slutt er på formen tt:mm (altså to siffer pr. tall). Dersom toString()-metoden kalles på TimeSlot-objektet fra forrige punkt skal det gi ”TDT4100-forelesning@10:15-12:00”.
• DayTime getStartTime(): returnerer starttidspunktet som et DayTime-objekt (se oppgave 1).
• DayTime getEndTime(): returnerer sluttidspunktet som et DayTime-objekt (se oppgave 1).
• int getDuration(): returnerer varighet i minutter

private static int asHours  (int minutes) { return minutes / 60;}
private static int asMinutes(int minutes) { return minutes % 60;}

private String description;
private int startTime, endTime;

public TimeSlot(String description, int hours, int minutes, int duration) {
   this.description = description;
   this.startTime = hours * 60 + minutes;
   this.endTime = this.startTime + duration;
}

private String twoDigits(int i) {
   return (i < 10 ? "0" : "") + i;
}

public String toString() {
   return description + "@" + twoDigits(asHours(startTime)) + ":" + twoDigits(asMinutes(startTime)) + "-" + twoDigits(asHours(endTime)) + ":" + twoDigits(asMinutes(endTime));
}

public DayTime getStartTime() {
   return new DayTime(asHours(startTime), asMinutes(startTime));
}


public DayTime getEndTime() {
   return new DayTime(asHours(endTime), asMinutes(endTime));
}


public int getDuration() {
   return endTime - startTime;
}


public String getDescription() {
   return description;
}

Oppgave b)

Implementer følgende metoder:

• boolean contains(int hours, int minutes): returnerer om dette TimeSlot-objektet inneholder tidspunktet angitt med hours og minutes. Merk at sluttidspunktet regnes ikke som å være inneholdt i tidsrommet. Dette betyr at new TimeSlot(”…”, 8, 0, 30).contains(8, 0) skal gi true, mens new TimeSlot(”…”, 8, 0, 30).contains(8, 30) skal gi false.
• boolean overlaps(TimeSlot timeSlot): returnerer om dette TimeSlot-objektet overlapper med det angitte TimeSlot-objektet, dvs. om det finnes et tidspunkt som begge inneholder.

public Stringboolean getPrefixcontains(Stringint wordhours, Stringint suffixminutes) {
             if (word.endsWith(suffix)) {
                  return word.substring(0, word.length() - suffix.length());
            }
            return null;
      }

      public boolean hasSuffixes(String prefix, List<String> suffixes) {
            for (String suffix : suffixes) {
                  if (! containsWord(prefix + suffix)) {
                        return false;
                  }
            }
            return true;
      }

      public List<String> findPrefixes(List<String> suffixes) {
            List<String> prefixes = new ArrayList<String>();
            for (String word : wordList) {
                  String prefix = getPrefix(word, suffixes.get(0));
                  if (prefix != null && hasSuffixes(prefix, suffixes)) {
                        prefixes.add(prefix);
                  }
            }
            return prefixes;
      }

Oppgave c)

 Hvilke(n) av de tre metodene i deloppgave b) kunne vært deklarert som static og hvorfor?

 minutes = hours * 60 + minutes;
   return startTime <= minutes && endTime > minutes;
}

public boolean overlaps(TimeSlot other) {
   return startTime < other.endTime && endTime > other.startTime;
}

Oppgave c)

  TimeSlot-klassen skal støtte sortering. TimeSlot-objektet med tidligst starttidspunkt sorteres først, og dersom starttidspunktene er like, så skal det med tidligst sluttidspunkt sorteres først. Forklar og implementer nødvendig kode.

public class TimeSlot implements Comparable<TimeSlot> {
 
       ...
 
       public int compareTo(TimeSlot other) {
               // negativ diff betyr mindre enn
              int diff = startTime - other.startTime;
              if (diff == 0) {
                      diff = endTime - other.endTime;
              }
              return diff;
       }
}

Oppgave d)

Du skal implementere en klasse DayPlan, for å holde oversikt over alle avtalene (altså TimeSlot-objekter) for en dag, bl.a. gi muligheten til å legge til og fjerne TimeSlot-objekter. Velg selv hvilke felt og evt. hjelpemetoder som trengs.

Implementer følgende metoder:

• void addTimeSlot(TimeSlot timeSlot): legger det angitte tidsrommet til denne dagsplanen
• void removeTimeSlot(TimeSlot timeSlot): fjerner det angitte tidsrommet fra denne dagsplanen
• TimeSlot getTimeSlotAt(int hours, int minutes): returnerer det tidligste tidsrommet som inneholder tidspunktet angitt med hours og minutes, ellers null.

private List<TimeSlot> timeSlots = new ArrayList<TimeSlot>();

public void addTimeSlot(TimeSlot timeSlot) {
   timeSlots.add(timeSlot);
   Collections.sort(timeSlots);
}

public void removeTimeSlot(TimeSlot timeSlot) {
   timeSlots.remove(timeSlot);
}


public TimeSlot getTimeSlotAt(int hours, int minutes) {
   for (TimeSlot timeSlot : timeSlots) {
      if (timeSlot.contains(hours, minutes)) {
         return timeSlot;
      }
   }
   return null;
}

Oppgave e)

Implementer følgende to metoder for tidsplanlegging:

• boolean containsOverlapping(): returnerer om det finnes overlappende tidsrom i denne dagsplanen.
• Collection<TimeSlot> getFreeTime(): returnerer en samling TimeSlot-objekter som representerer fritiden en har i løpet av en dag, dvs. tidsrommene som denne dagsplanen ikke dekker.

For begge disse metodene kan det være lurt å definere hjelpemetoder for å gjøre løsningen ryddigere.

public boolean containsOverlapping() {
   for (int i = 0; i < timeSlots.size(); i++) {
      TimeSlot timeSlot = timeSlots.get(i);
      for (int j = i + 1; j < timeSlots.size(); j++) {
         TimeSlot otherTimeSlot = timeSlots.get(j);
         if (timeSlot != otherTimeSlot) {
            return timeSlot.overlaps(otherTimeSlot);
         }
         // alternativt, dersom lista ikke er sortert
         if (timeSlot != otherTimeSlot && timeSlot.overlaps(otherTimeSlot)) {
            return true;
         }
      }
   }
   return false;
}

private static void addTimeSlotIfNonEmpty(Collection<TimeSlot> timeSlots, DayTime startTime, DayTime endTime) {
   int duration = (endTime.hours * 60 + endTime.minutes) - (startTime.hours * 60 + startTime.minutes);
   if (duration > 0) {
      timeSlots.add(new TimeSlot(null, startTime.hours, startTime.minutes, duration));
   }
}


public Collection<TimeSlot> getFreeTime() {
   Collection<TimeSlot> freeTime = new ArrayList<TimeSlot>();
   TimeSlot previous = new TimeSlot(null, 0, 0, 0);
   for (TimeSlot timeSlot : getAllTimeSlots()) {
      DayTime startTime = timeSlot.getStartTime();
      addTimeSlotIfNonEmpty(freeTime, previous.getEndTime(), startTime);
      DayTime endTime = timeSlot.getEndTime();
      if (! previous.contains(endTime.hours, endTime.minutes)) {
         previous = timeSlot;
      }
   }
   addTimeSlotIfNonEmpty(freeTime, previous.getEndTime(), new DayTime(24, 0));
   return freeTime;
}