OOP2

======

JSugar is a tiny framework, in an attempt to hide away the tons of

useless cruft that you get from working with Java's Swing.

Features

--------

Purely speaking, JSugar does not add anything new compared to when you're using

Swing. It does however, offer some considerable advantages over using Swing

directly:

* Easy creation of windows, that offer a series of convenient methods like

  createButton(), allowing for easy creation of small GUI programs.

* Built-in support for action triggering; Just say which method should be

  triggered where, and you're done.

* Easy learning curve, compared to manually handling Swing. Create a new Window,

  slap some components on it, add the methods it needs to call on trigger, and

  done.

* Relies mainly on primitive types, like integer arrays, and classes that are

  available in every recent OpenJDK version, like Strings.

* Completely [free/libre software](https://www.gnu.org/philosophy/free-sw.html).

* Very lightweight. It's just a bunch of source files that you can directly link

  to. Putting it in a seperate jar will cause more harm than good.

* Only RuntimeExceptions will be thrown, avoiding *exception infection* that

  you'll get from using self-defined exceptions in Java.

* Documentation available through JavaDoc. I do my very best to provide clear

  documentation, so you know how to use this without having to figure it out

  yourself.

* Components you add are returned to the caller, so if you do need some more

  advanced stuff, you can add it yourself.

Limitations

-----------

The convenience causes some limitations, but they're fairly minor, and if you're

using JSugar, it's very unlikely you'd be bothered by them anyway, but here they

are:

* You can't add your own panels to the window, but you'll most likely just want

  to add some components to the window itself.

* The panels default to double buffering (which you should do anyway) and the

  flow layout.

* The window is automatically updated whenever a new component is added. When

  using Swing 'natively', you could postpone updating, but why did you add a

  component then in the first place?

* *Trigger methods* can only have 1 parameter, or none at all. That 1 parameter

  must be of type java.awt.event.ActionEvent. This should be enough for >80% of

  use cases, and if you really need more flexibility, you can add your own

  action handlers manually.

* Pressing the X in the title bar of the window closes it. >95% of use cases do

  this anyway.

* Some silly stuff like adding icons to buttons, checkboxes, ... is not

  possible. You'll have to do that yourself. Yet for most use cases,you might

  just do the sane thing and add text.

* Certain components don't offer the ability to attach a trigger action to them.

  We're talking about components like labels. But then again, these kind of

  components shouldn't get much triggers anyway.

* Some components have deliberately been left out, because they don't offer many

  information/interaction for the user. An example for this, is the

  JProgressBar. Although in some rare cases it's a very useful thing, but it's

  mainly eye candy, and you may just show the data in a JLabel anyway.

  However, if I feel like doing so, and the rest of the library is stable, I may

  add such components.

==============================

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

------

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.