There are many cases, where not only a resource, but also a certain 
quantity of
resources is required for an event. Often a resource should be provided in
a certain amount, or one per attendee:

examples are:
  - number of seats in a car or conference room
  - number of telephone lines for a given phone-number (phone conference)
  - headsets, USB-sticks, ...

In my opinion, resources and resource requests should be given a quantity
and an exclusiveness-flag.

Ideas:
======

  the Kronolith_Request would require two additional attributes:
     1. quantity (lets call it KR.q)
         (UI needs a way to specify this per resource with an option
          be set to the number of attendees)
     2. exclusiveness (lets call it KR.e)
         (only needed for certain resource groups)


  Single Resources:
  =================

  note: (non-)shareable will refer to different requests not attendees

  let q_S be the quantity of a single resource
  let e_S be the exclusiveness-flag of a single resource

  ------------------------------------------------------------------------
  let RS_1 be a single resource with e_S = false
     -> this is a shareable pool of "bundled" anonymous resources
         eg.: incoming telephone lines for a given cable/phone-number

  RS_1.isFree() checks if the sum of KR.q of all scheduled events in the
     requested timeframe is less or equal to q_S - KR.q
     KR.e has no meaning here

  ------------------------------------------------------------------------

  let RS_2 be a single resource with e_S = true
     -> this is a non-shareable pool of anonymous resources
         eg.: the seats in a car or a conference room

  RS_2.isFree() checks if the resource is completely free in the requested
     timeframe and q_S >= KR.q
     KR.e has no meaning here
  ------------------------------------------------------------------------




  Resource Groups:
  ================

  note: (non-)splittable will refer to a single request (could the request be
         splitted over multiple single resources or not).

  let q_G be the quantity of a resource group (could be used as upper boundary
      for requests)
  let e_G be the exclusiveness-flag of a resource group

  ------------------------------------------------------------------------
  let RG_1 be a resource group e_G = false
     -> this is a group of splittable resources
         eg.: a group of cars to transport a given number of people
     q_G could be preset to the sum(q_S) of all included single resources

  RG_1.isFree()
     if KR.e == true: check for KR.q free resource in the requested timeframe
         (like: I need 3 cars for 3 people, no matter how many seats are free)
     else (KR.e == false) return a pool of free resources, so that 
sum(q_S)>=KR.q

  ------------------------------------------------------------------------

  let RG_2 be a resource group with e_G = true
     -> this is a group of non-splittable resources
         eg.: the seats in a conference room
     q_G could be preset to the max(q_S) of all included single resources

  RG_2.isFree() checks if there is exactly one resource completely free in the
     requested timeframe wher q_S >= KR.q
         (like: we need one conf room that has at least 5 seats)
     KR.e has no meaning here
  ------------------------------------------------------------------------

Thanks for reading up to this line. ;-)