home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 August: Tool Chest / Dev.CD Aug 94.toast / New System Software Extensions / OpenDoc A6 / OpenDoc Parts Framework / OPF / Found / BCCollec / Structs / Sets / BCSet.cpp next >
Encoding:
Text File  |  1994-04-21  |  6.5 KB  |  288 lines  |  [TEXT/MPS ]
  1. //  The C++ Booch Components (Version 2.1)
  2. //  (C) Copyright 1990-1993 Grady Booch. All Rights Reserved.
  3. //
  4. //  Restricted Rights Legend
  5. //  Use, duplication, or disclosure is subject to restrictions as set forth 
  6. //  in subdivision (c)(1)(ii) of the Rights in Technical Data and Computer 
  7. //  Software clause at DFARS 252.227-7013. 
  8. //
  9. //  BCSet.cpp
  10. //
  11. //  This file contains the definitions for the set abstract base class
  12. //  and its iterators.
  13.  
  14. #include "BCSet.h"
  15.  
  16. template<class Item>
  17. BC_TSet<Item>::BC_TSet() {}
  18.  
  19. template<class Item>
  20. BC_TSet<Item>::BC_TSet(const BC_TSet<Item>&) {}
  21.  
  22. template<class Item>
  23. BC_TSet<Item>::~BC_TSet() {}
  24.  
  25. template<class Item>
  26. BC_TSet<Item>& BC_TSet<Item>::operator=(const BC_TSet<Item>& s)
  27. {
  28.   if (this == &s)
  29.     return *this;
  30.   ((BC_TSet<Item>&)s).Lock();
  31.   Purge();
  32.   BC_TSetActiveIterator<Item> iter(s);
  33.   while (!iter.IsDone()) {
  34.     Attach(*iter.CurrentItem());
  35.     iter.Next();
  36.   }
  37.   ((BC_TSet<Item>&)s).Unlock();
  38.   return *this;
  39. } 
  40.  
  41. template<class Item>
  42. BC_Boolean BC_TSet<Item>::operator==(const BC_TSet<Item>& s) const
  43. {
  44.   if (this == &s)
  45.     return 1;
  46.   ((BC_TSet<Item>&)s).Lock();
  47.   if (Cardinality() != s.Cardinality()) {
  48.     ((BC_TSet<Item>&)s).Unlock();
  49.     return 0;
  50.   }
  51.   BC_TSetActiveIterator<Item> iter(*this);
  52.   while (!iter.IsDone()) {
  53.     if (!s.Exists(*iter.CurrentItem())) {
  54.       ((BC_TSet<Item>&)s).Unlock();
  55.       return 0;
  56.     }
  57.     iter.Next();
  58.   }
  59.   ((BC_TSet<Item>&)s).Unlock();
  60.   return 1;
  61. } 
  62.  
  63. template<class Item>
  64. BC_Boolean BC_TSet<Item>::operator!=(const BC_TSet<Item>& s) const
  65. {
  66.   return !operator==(s);
  67. }
  68.  
  69. template<class Item>
  70. void BC_TSet<Item>::Union(const BC_TSet<Item>& s)
  71. {
  72.   if (this != &s) {
  73.     ((BC_TSet<Item>&)s).Lock();
  74.     BC_TSetActiveIterator<Item> iter(s);
  75.     while (!iter.IsDone()) {
  76.       Attach(*iter.CurrentItem());
  77.       iter.Next();
  78.     }
  79.     ((BC_TSet<Item>&)s).Unlock();
  80.   }
  81. }
  82.  
  83. template<class Item>
  84. void BC_TSet<Item>::Intersection(const BC_TSet<Item>& s)
  85. {
  86.   if (this != &s) {
  87.     ((BC_TSet<Item>&)s).Lock();
  88.     BC_TSetActiveIterator<Item> iter(*this);
  89.     while (!iter.IsDone()) {
  90.       if (!s.Exists(*iter.CurrentItem()))
  91.         Detach(*iter.CurrentItem());
  92.       else
  93.         iter.Next();
  94.     }
  95.     ((BC_TSet<Item>&)s).Unlock();
  96.   }
  97. }
  98.  
  99. template<class Item>
  100. void BC_TSet<Item>::Difference(const BC_TSet<Item>& s)
  101. {
  102.   if (this == &s)
  103.     Purge();
  104.   else {
  105.     ((BC_TSet<Item>&)s).Lock();
  106.     BC_TSetActiveIterator<Item> iter(s);
  107.     while (!iter.IsDone()) {
  108.       Detach(*iter.CurrentItem());
  109.       iter.Next();
  110.     }
  111.     ((BC_TSet<Item>&)s).Unlock();
  112.   }
  113. }
  114.  
  115. template<class Item>
  116. BC_Boolean BC_TSet<Item>::IsSubset(const BC_TSet<Item>& s) const
  117. {
  118.   if (this == &s)
  119.     return 1;
  120.   ((BC_TSet<Item>&)s).Lock();
  121.   if (Cardinality() > s.Cardinality()) {
  122.     ((BC_TSet<Item>&)s).Unlock();
  123.     return 0;
  124.   }
  125.   BC_TSetActiveIterator<Item> iter(*this);
  126.   while (!iter.IsDone()) {
  127.     if (!s.Exists(*iter.CurrentItem())) {
  128.       ((BC_TSet<Item>&)s).Unlock();
  129.       return 0;
  130.     }
  131.     iter.Next();
  132.   }
  133.   ((BC_TSet<Item>&)s).Unlock();
  134.   return 1;
  135. }
  136.  
  137. template<class Item>
  138. BC_Boolean BC_TSet<Item>::IsProperSubset(const BC_TSet<Item>& s) const
  139. {
  140.   if (this == &s)
  141.     return 0;
  142.   ((BC_TSet<Item>&)s).Lock();
  143.   if (Cardinality() >= s.Cardinality()) {
  144.     ((BC_TSet<Item>&)s).Unlock();
  145.     return 0;
  146.   }
  147.   BC_TSetActiveIterator<Item> iter(*this);
  148.   while (!iter.IsDone()) {
  149.     if (!s.Exists(*iter.CurrentItem())) {
  150.       ((BC_TSet<Item>&)s).Unlock();
  151.       return 0;
  152.     }
  153.     iter.Next();
  154.   }
  155.   ((BC_TSet<Item>&)s).Unlock();
  156.   return 1;
  157. }
  158.  
  159. template<class Item>
  160. BC_Boolean BC_TSet<Item>::Attach(const Item& item, const BC_Boolean&)
  161. {
  162.   return Attach(item);
  163. }
  164.  
  165. template<class Item>
  166. void BC_TSet<Item>::Lock() {}
  167.  
  168. template<class Item>
  169. void BC_TSet<Item>::Unlock() {}
  170.  
  171. template<class Item>
  172. BC_TSetActiveIterator<Item>::BC_TSetActiveIterator(const BC_TSet<Item>& s)
  173.   : fSet(s),
  174.     fBucketIndex(s.Cardinality() ? 0 : -1),
  175.     fIndex(-1)
  176. {
  177.   if (fBucketIndex == 0) {
  178.     for (; (fBucketIndex < fSet.NumberOfBuckets()); fBucketIndex++) {
  179.       fIndex = fSet.Length(fBucketIndex) ? 0 : -1;
  180.       if (fIndex != -1)
  181.         return;
  182.     }
  183.   }
  184. }
  185.   
  186. template<class Item>
  187. BC_TSetActiveIterator<Item>::~BC_TSetActiveIterator() {}
  188.   
  189. template<class Item>
  190. void BC_TSetActiveIterator<Item>::Reset()
  191. {
  192.   fBucketIndex = fSet.Cardinality() ? 0 : -1;
  193.   fIndex = -1;
  194.   if (fBucketIndex == 0) {
  195.     for (; (fBucketIndex < fSet.NumberOfBuckets()); fBucketIndex++) {
  196.       fIndex = fSet.Length(fBucketIndex) ? 0 : -1;
  197.       if (fIndex != -1)
  198.         return;
  199.     }
  200.   }
  201. }
  202.  
  203. template<class Item>
  204. BC_Boolean BC_TSetActiveIterator<Item>::Next()
  205. {
  206.   if (fBucketIndex < fSet.NumberOfBuckets()) {
  207.     fIndex++;
  208.     if (fIndex >= fSet.Length(fBucketIndex)) {
  209.       fBucketIndex++;
  210.       fIndex = -1;
  211.       for (; (fBucketIndex < fSet.NumberOfBuckets()); fBucketIndex++) {
  212.         fIndex = fSet.Length(fBucketIndex) ? 0 : -1;
  213.         if (fIndex != -1)
  214.           break;
  215.       }
  216.     }
  217.     return !IsDone();
  218.   } else
  219.     return 0;
  220. }
  221.  
  222. template<class Item>
  223. BC_Boolean BC_TSetActiveIterator<Item>::IsDone() const
  224. {
  225.   if ((fBucketIndex < 0) || (fBucketIndex >= fSet.NumberOfBuckets()))
  226.     return 1;
  227.   else {
  228.     if (fIndex >= fSet.Length(fBucketIndex)) {
  229.       ((BC_TSetActiveIterator<Item>&)(*this)).fBucketIndex++;
  230.       ((BC_TSetActiveIterator<Item>&)(*this)).fIndex = -1;
  231.       for (; (fBucketIndex < fSet.NumberOfBuckets());
  232.            ((BC_TSetActiveIterator<Item>&)(*this)).fBucketIndex++) {
  233.         ((BC_TSetActiveIterator<Item>&)(*this)).fIndex =
  234.           fSet.Length(fBucketIndex) ? 0 : - 1;
  235.         if (fIndex != -1)
  236.           return 0;
  237.       }
  238.       return 1;
  239.     }
  240.     return 0;
  241.   }
  242. }
  243.  
  244. template<class Item>
  245. const Item* BC_TSetActiveIterator<Item>::CurrentItem() const
  246. {
  247.   return IsDone() ? 0 : &fSet.ItemAt(fBucketIndex, fIndex);
  248. }
  249.  
  250. template<class Item>
  251. Item* BC_TSetActiveIterator<Item>::CurrentItem()
  252. {
  253.   return IsDone() ? 0 : &((Item&)(fSet.ItemAt(fBucketIndex, fIndex)));
  254. }
  255.  
  256. template<class Item>
  257. BC_TSetPassiveIterator<Item>::BC_TSetPassiveIterator(const BC_TSet<Item>& s)
  258.   : fSet(s) {}
  259.   
  260. template<class Item>
  261. BC_TSetPassiveIterator<Item>::~BC_TSetPassiveIterator() {}
  262.   
  263. template<class Item>
  264. BC_Boolean BC_TSetPassiveIterator<Item>::Apply(BC_Boolean (*f)(const Item&))
  265. {
  266.   BC_TSetActiveIterator<Item> iter(fSet);
  267.   while (!iter.IsDone()) {
  268.     if (!f(*iter.CurrentItem()))
  269.       return 0;
  270.     else
  271.       iter.Next();
  272.   }
  273.   return 1;
  274. }  
  275.   
  276. template<class Item>
  277. BC_Boolean BC_TSetPassiveIterator<Item>::Apply(BC_Boolean (*f)(Item&))
  278. {
  279.   BC_TSetActiveIterator<Item> iter(fSet);
  280.   while (!iter.IsDone()) {
  281.     if (!f(*iter.CurrentItem()))
  282.       return 0;
  283.     else
  284.       iter.Next();
  285.   }
  286.   return 1;
  287. }  
  288.