home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / cset21v1.zip / IBMCPP / SAMPLES / ICLCC / PARCEL.C < prev    next >
C/C++ Source or Header  |  1993-05-07  |  7KB  |  160 lines

  1. /******************************************************************************/
  2. /*                                                                            */
  3. /* COPYRIGHT:                                                                 */
  4. /* ----------                                                                 */
  5. /* Copyright (C) International Business Machines Corp., 1991,1992.            */
  6. /*                                                                            */
  7. /* DISCLAIMER OF WARRANTIES:                                                  */
  8. /* -------------------------                                                  */
  9. /* The following [enclosed] code is sample code created by IBM                */
  10. /* Corporation.  This sample code is not part of any standard IBM product     */
  11. /* and is provided to you solely for the purpose of assisting you in the      */
  12. /* development of your applications.  The code is provided "AS IS",           */
  13. /* without warranty of any kind.  IBM shall not be liable for any damages     */
  14. /* arising out of your use of the sample code, even if they have been         */
  15. /* advised of the possibility of such damages.                                */
  16. /*                                                                            */
  17. /******************************************************************************/
  18. /*-------------------------------------------------------------*\
  19. |                                                               |
  20. | parcel.C  -  Parcels are handled using  a  KeySorted Set and  |
  21. |              a Heap.                       """""""""""""      |
  22. |                """"                                           |
  23. | We maintain two collections that keep track of parcels in     |
  24. | circulation and parcels delivered.  The collection for the    |
  25. | parcels in circulation is a KeySorted Set (key, sorted,       |
  26. | unique elements, no element equality).  For the delivered     |
  27. | parcels we do not care about fast or sorted retrieval.        |
  28. | So we select the Heap for this collection (no key, unordered, |
  29. | multiple elements, no element equality).                      |
  30. |                                                               |
  31. | A parcel has as member data two objects of type PlaceTime,    |
  32. | which is a point in space and time: one object for its origin,|
  33. | one for its current place and time. It also has as member     |
  34. | data two objects of type ToyString, for the destination and   |
  35. | for the ID.                                                   |
  36. |                                                               |
  37. | Function updateParcels adds parcels that have arrived at      |
  38. | their destination to the collection for delivered parcels,    |
  39. | and removes them from the collection of circulating parcels.  |
  40. | This demonstrates the use of removeAll().                     |
  41. |                                                               |
  42. \*-------------------------------------------------------------*/
  43. #include <iostream.h>
  44.  
  45. #include "parcel.h"
  46.                           // Let's use the default KeySorted Set:
  47. #include <iksset.h>
  48.                           // Let's use the default Heap:
  49. #include <iheap.h>
  50.  
  51. typedef IKeySortedSet<Parcel, ToyString> ParcelSet;
  52. typedef IHeap        <Parcel>            ParcelHeap;
  53.  
  54. ostream& operator<<(ostream&, ParcelSet const&);
  55. ostream& operator<<(ostream&, ParcelHeap const&);
  56.  
  57. void update(ParcelSet&, ParcelHeap&);
  58.  
  59.  
  60. main()  {
  61.  
  62.   ParcelSet circulating;
  63.   ParcelHeap delivered;
  64.  
  65.   int today = 8;
  66.  
  67.   circulating.add(Parcel("London", "Athens",
  68.      today,      "26LoAt"));
  69.   circulating.add(Parcel("Amsterdam", "Toronto",
  70.      today += 2, "27AmTo"));
  71.   circulating.add(Parcel("Washington", "Stockholm",
  72.      today += 5, "25WaSt"));
  73.   circulating.add(Parcel("Dublin", "Kairo",
  74.      today += 1, "25DuKa"));
  75.   update(circulating, delivered);
  76.   cout << "\nThe situation at start:\n";
  77.   cout << "Parcels in circulation:\n" << circulating;
  78.  
  79.   today ++;
  80.   circulating.elementWithKey("27AmTo").arrivedAt(
  81.      "Atlanta",   today);
  82.   circulating.elementWithKey("25WaSt").arrivedAt(
  83.      "Amsterdam", today);
  84.   circulating.elementWithKey("25DuKa").arrivedAt(
  85.      "Paris",     today);
  86.   update(circulating, delivered);
  87.   cout << "\n\nThe situation at day " << today << ":\n";
  88.   cout << "Parcels in circulation:\n" << circulating;
  89.  
  90.   today ++;          // One day later ...
  91.   circulating.elementWithKey("27AmTo").arrivedAt("Chicago", today);
  92.              // As in real life, one parcel gets lost:
  93.   circulating.removeElementWithKey("26LoAt");
  94.   update(circulating, delivered);
  95.   cout << "\n\nThe situation at day " << today << ":\n";
  96.   cout << "Parcels in circulation:\n" << circulating;
  97.  
  98.   today ++;
  99.   circulating.elementWithKey("25WaSt").arrivedAt("Oslo", today);
  100.   circulating.elementWithKey("25DuKa").arrivedAt("Kairo", today);
  101.              // New parcels are shipped.
  102.   circulating.add(Parcel("Dublin", "Rome", today,   "27DuRo"));
  103.              // Let's try to add one with a key already there.
  104.              // The KeySsorted Set should ignore it:
  105.   circulating.add(Parcel("Nowhere", "Nirvana", today, "25WaSt"));
  106.   update(circulating, delivered);
  107.   cout << "\n\nThe situation at day " << today << ":\n";
  108.   cout << "Parcels in circulation:\n" << circulating;
  109.   cout << "Parcels delivered:\n" << delivered;
  110.  
  111.                    // Now we make all parcels arrive today:
  112.   today ++;
  113.  
  114.   ParcelSet::Cursor circulatingcursor(circulating);
  115.   forCursor(circulatingcursor) {
  116.      circulating.elementAt(circulatingcursor).wasDelivered(today);
  117.   }
  118.   update(circulating, delivered);
  119.   cout << "\n\nThe situation at day " << today << ":\n";
  120.   cout << "Parcels in circulation:\n" << circulating;
  121.   cout << "Parcels delivered:\n" << delivered;
  122.  
  123.   if (circulating.isEmpty())
  124.      cout << "\nAll parcels were delivered.\n";
  125.   else
  126.      cout << "\nSomething very strange happened here.\n";
  127.  
  128.   return  0;
  129. }
  130.  
  131.  
  132. ostream& operator<<(ostream& os, ParcelSet const& parcels)  {
  133.   ParcelSet::Cursor pcursor(parcels);
  134.   forCursor(pcursor) {
  135.      os <<  pcursor.element() << "\n";
  136.   }
  137.   return os;
  138. }
  139.  
  140. ostream& operator<<(ostream& os, ParcelHeap const& parcels)  {
  141.   ParcelHeap::Cursor pcursor(parcels);
  142.   forCursor(pcursor) {
  143.      os <<  pcursor.element() << "\n";
  144.   }
  145.   return os;
  146. }
  147.  
  148. Boolean wasDelivered(Parcel const& p, void* dp) {
  149.    if ( p.lastArrival().city() == p.destination() ) {
  150.       ((ParcelHeap*)dp)->add(p);
  151.       return True;
  152.    }
  153.    else
  154.       return False;
  155. }
  156.  
  157. void update(ParcelSet& p, ParcelHeap& d) {
  158.    p.removeAll(wasDelivered, &d);
  159. }
  160.