home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 July: Mac OS SDK / Dev.CD Jul 96 SDK / Dev.CD Jul 96 SDK1.toast / Development Kits (Disc 1) / OpenDoc / OpenDoc Development / Debugging Support / OpenDoc Source Code / Utilities / OrdColl.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-22  |  12.5 KB  |  428 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        OrdColl.cpp
  3.  
  4.     Contains:    Implementation of OrderedCollection and OrderedCollectionIterator
  5.  
  6.     Owned by:    Richard Rodseth
  7.  
  8.     Copyright:    © 1993 - 1995 by Apple Computer, Inc., all rights reserved.
  9.  
  10.     
  11. */
  12.  
  13. #ifndef _ORDCOLL_
  14. #include "OrdColl.h"
  15. #endif
  16.  
  17. #ifndef _ODNEW_
  18. #include "ODNew.h"
  19. #endif
  20.  
  21. #pragma segment ODCollections
  22.  
  23. //======================================================================================
  24. // Class ValueLink - Implementation
  25. //======================================================================================
  26.  
  27. ValueLink::ValueLink(ElementType value)
  28. {
  29.     fValue = value;
  30. }
  31.  
  32. ValueLink::~ValueLink()
  33. {
  34. }
  35.  
  36. //======================================================================================
  37. // Class OrderedCollection
  38. //======================================================================================
  39.  
  40. //------------------------------------------------------------------------------
  41. // OrderedCollection::OrderedCollection
  42. //------------------------------------------------------------------------------
  43.  
  44. OrderedCollection::OrderedCollection()
  45. {
  46.     fHeap = kODNULL;
  47. }
  48.  
  49. //------------------------------------------------------------------------------
  50. // OrderedCollection::OrderedCollection
  51. //------------------------------------------------------------------------------
  52.  
  53. OrderedCollection::OrderedCollection(ODMemoryHeapID where)
  54. {
  55.     fHeap = where;
  56. }
  57.  
  58. // OrderedCollection::~OrderedCollection
  59. //------------------------------------------------------------------------------
  60.  
  61. OrderedCollection::~OrderedCollection()
  62. {
  63.     this->RemoveAll();
  64. }
  65.  
  66. //------------------------------------------------------------------------------
  67. // OrderedCollection::AddFirst
  68. //------------------------------------------------------------------------------
  69.  
  70. void OrderedCollection::AddFirst(ElementType element)
  71. {
  72.     ValueLink* newLink = this->CreateNewLink(element);
  73.     fImplementation.AddFirst(newLink);
  74. }
  75.  
  76. //------------------------------------------------------------------------------
  77. // OrderedCollection::AddLast
  78. //------------------------------------------------------------------------------
  79.  
  80. void OrderedCollection::AddLast(ElementType element)
  81. {
  82.     ValueLink* newLink = CreateNewLink(element);
  83.     fImplementation.AddLast(newLink);
  84. }
  85.  
  86.  
  87. //------------------------------------------------------------------------------
  88. // OrderedCollection::AddBefore
  89. //------------------------------------------------------------------------------
  90.  
  91. void OrderedCollection::AddBefore(ElementType existing, ElementType tobeadded)
  92. {
  93.     LinkedList* impl = (LinkedList*) &fImplementation; // cast away const
  94.     LinkedListIterator iter(impl);
  95.     ValueLink* aLink = (ValueLink*) iter.First();
  96.     while (aLink != kODNULL)
  97.     {
  98.         ElementType v = ((ValueLink*) aLink)->GetValue();
  99.  
  100.         if (this->ElementsMatch(v,existing))    
  101.         {
  102.             ValueLink* newLink = CreateNewLink(tobeadded);
  103.             fImplementation.AddBefore(*aLink, newLink);
  104.             aLink = kODNULL;
  105.         }
  106.         else
  107.             aLink = (ValueLink*) iter.Next();
  108.     }
  109. }
  110.  
  111. //------------------------------------------------------------------------------
  112. // OrderedCollection::AddAfter
  113. //------------------------------------------------------------------------------
  114.  
  115. void OrderedCollection::AddAfter(ElementType existing, ElementType tobeadded)
  116. {
  117.     LinkedList* impl = (LinkedList*) &fImplementation; // cast away const
  118.     LinkedListIterator iter(impl);
  119.     ValueLink* aLink = (ValueLink*) iter.First();
  120.     while (aLink != kODNULL)
  121.     {
  122.         ElementType v = ((ValueLink*) aLink)->GetValue();
  123.  
  124.         if (this->ElementsMatch(v,existing))    
  125.         {
  126.             ValueLink* newLink = CreateNewLink(tobeadded);
  127.             fImplementation.AddAfter(*aLink, newLink);
  128.             aLink = kODNULL;
  129.         }
  130.         else
  131.             aLink = (ValueLink*) iter.Next();
  132.     }
  133. }
  134.  
  135. //------------------------------------------------------------------------------
  136. // OrderedCollection::After
  137. //------------------------------------------------------------------------------
  138.  
  139. ElementType OrderedCollection::After(ElementType existing) const
  140. {
  141.     ValueLink* linkAfter = kODNULL;
  142.  
  143.     LinkedList* impl = (LinkedList*) &fImplementation; // cast away const
  144.     LinkedListIterator iter(impl);
  145.  
  146.     for (ValueLink* link = (ValueLink*) iter.First(); iter.IsNotComplete(); link = (ValueLink*) iter.Next())
  147.     {
  148.         ElementType v = ((ValueLink*) link)->GetValue();
  149.  
  150.         if (this->ElementsMatch(v,existing))    
  151.         {
  152.             linkAfter = (ValueLink*) fImplementation.After(*link);
  153.             break;
  154.         }
  155.     }
  156.     
  157.     return linkAfter ? linkAfter->GetValue() : (ElementType)kODNULL;
  158. }
  159.  
  160. //------------------------------------------------------------------------------
  161. // OrderedCollection::Before
  162. //------------------------------------------------------------------------------
  163.  
  164. ElementType OrderedCollection::Before(ElementType existing) const
  165. {
  166.     ValueLink* linkBefore = kODNULL;
  167.  
  168.     LinkedList* impl = (LinkedList*) &fImplementation; // cast away const
  169.     LinkedListIterator iter(impl);
  170.  
  171.     for (ValueLink* link = (ValueLink*) iter.First(); iter.IsNotComplete(); link = (ValueLink*) iter.Next())
  172.     {
  173.         ElementType v = ((ValueLink*) link)->GetValue();
  174.  
  175.         if (this->ElementsMatch(v,existing))    
  176.         {
  177.             linkBefore = (ValueLink*) fImplementation.Before(*link);
  178.             break;
  179.         }
  180.     }
  181.     
  182.     return linkBefore ? linkBefore->GetValue() : (ElementType)kODNULL;
  183. }
  184.  
  185. //------------------------------------------------------------------------------
  186. // OrderedCollection::First
  187. //------------------------------------------------------------------------------
  188.  
  189. ElementType OrderedCollection::First() const
  190. {
  191.     ValueLink* firstLink = (ValueLink*) fImplementation.First();
  192.     return firstLink ? firstLink->GetValue() : (ElementType)kODNULL;
  193. }
  194.  
  195. //------------------------------------------------------------------------------
  196. // OrderedCollection::Last
  197. //------------------------------------------------------------------------------
  198.  
  199. ElementType OrderedCollection::Last() const
  200. {
  201.     ValueLink* lastLink = (ValueLink*) fImplementation.Last();
  202.     return lastLink ? lastLink->GetValue() : (ElementType)kODNULL;
  203. }
  204.  
  205. //------------------------------------------------------------------------------
  206. // OrderedCollection::RemoveFirst
  207. //------------------------------------------------------------------------------
  208.  
  209. ElementType    OrderedCollection::RemoveFirst()
  210. {
  211.     ValueLink* aLink = (ValueLink*) fImplementation.RemoveFirst();
  212.     ElementType value = aLink ? aLink->GetValue() : kODNULL;
  213.     delete aLink;
  214.     return value;
  215. }
  216.  
  217. //------------------------------------------------------------------------------
  218. // OrderedCollection::RemoveLast
  219. //------------------------------------------------------------------------------
  220.  
  221. ElementType    OrderedCollection::RemoveLast()
  222. {
  223.     ValueLink* aLink = (ValueLink*) fImplementation.RemoveLast();
  224.     ElementType value = aLink ? aLink->GetValue() : kODNULL;
  225.     delete aLink;
  226.     return value;
  227. }
  228.  
  229. //------------------------------------------------------------------------------
  230. // OrderedCollection::Remove
  231. //------------------------------------------------------------------------------
  232.  
  233. ODBoolean OrderedCollection::Remove(ElementType existing)
  234. {
  235.     LinkedList* impl = (LinkedList*) &fImplementation; // cast away const
  236.     LinkedListIterator iter(impl);
  237.     ValueLink* aLink = (ValueLink*) iter.First();
  238.     ODBoolean removed = kODFalse;
  239.     while (aLink != kODNULL)
  240.     {
  241.         ElementType v = ((ValueLink*) aLink)->GetValue();
  242.  
  243.         if (this->ElementsMatch(v,existing))
  244.         {
  245.             fImplementation.Remove(*aLink);
  246.             delete aLink;
  247.             removed = kODTrue;
  248.             aLink = kODNULL;    
  249.         }
  250.         else
  251.             aLink = (ValueLink*) iter.Next();
  252.     }
  253.     return removed;
  254. }
  255.  
  256. //------------------------------------------------------------------------------
  257. // OrderedCollection::RemoveAll
  258. //------------------------------------------------------------------------------
  259.  
  260. void OrderedCollection::RemoveAll()
  261. {
  262.     Link* link = fImplementation.RemoveFirst();
  263.     while (link != kODNULL)
  264.     {
  265.         delete link;
  266.         link = fImplementation.RemoveFirst();
  267.     }
  268. }
  269.  
  270. //------------------------------------------------------------------------------
  271. // OrderedCollection::DeleteAll
  272. //------------------------------------------------------------------------------
  273.  
  274. void OrderedCollection::DeleteAll()
  275. {
  276.     Link* link = fImplementation.RemoveFirst();
  277.     while (link != kODNULL)
  278.     {
  279.         ElementType value = ((ValueLink*) link)->GetValue();
  280.         delete value;
  281.         delete link;
  282.         link = fImplementation.RemoveFirst();
  283.     }
  284. }
  285.  
  286. //------------------------------------------------------------------------------
  287. // OrderedCollection::Contains
  288. //------------------------------------------------------------------------------
  289.  
  290. ODBoolean    OrderedCollection::Contains(ElementType existing) const
  291. {
  292.     LinkedList* impl = (LinkedList*) &fImplementation; // cast away const
  293.     LinkedListIterator iter(impl);
  294.     ValueLink* aLink = (ValueLink*) iter.First();
  295.     while (aLink != kODNULL)
  296.     {
  297.         ElementType v = ((ValueLink*) aLink)->GetValue();
  298.  
  299.         if (this->ElementsMatch(v,existing))
  300.         {
  301.             return kODTrue;    
  302.         }
  303.         else
  304.             aLink = (ValueLink*) iter.Next();
  305.     }    
  306.     return kODFalse;
  307. }
  308.  
  309. //------------------------------------------------------------------------------
  310. // OrderedCollection::CreateIterator
  311. //------------------------------------------------------------------------------
  312.  
  313. OrderedCollectionIterator* OrderedCollection::CreateIterator()
  314. {
  315.     return new(fHeap) OrderedCollectionIterator(this);
  316. }
  317.  
  318.  
  319. //------------------------------------------------------------------------------
  320. // OrderedCollection::CreateNewLink
  321. //------------------------------------------------------------------------------
  322.  
  323. ValueLink*    OrderedCollection::CreateNewLink(ElementType value) const
  324. {
  325.     return new (fHeap) ValueLink(value);
  326. }
  327.  
  328. //------------------------------------------------------------------------------
  329. // OrderedCollection::ElementsMatch
  330. //------------------------------------------------------------------------------
  331.  
  332. ODBoolean    OrderedCollection::ElementsMatch(ElementType v1,ElementType v2) const
  333. {
  334.     return (v1 == v2);
  335. }
  336.  
  337. //======================================================================================
  338. // OrderedCollectionIterator
  339. //======================================================================================
  340.  
  341. //------------------------------------------------------------------------------
  342. // OrderedCollectionIterator::OrderedCollectionIterator
  343. //------------------------------------------------------------------------------
  344.  
  345. OrderedCollectionIterator::OrderedCollectionIterator(OrderedCollection* collection)    
  346.     : fImplementation(collection ? &(collection->fImplementation) : (LinkedList*)kODNULL)
  347. {
  348.     fCollection =  collection;
  349. }
  350.  
  351. //------------------------------------------------------------------------------
  352. // OrderedCollectionIterator::~OrderedCollectionIterator
  353. //------------------------------------------------------------------------------
  354.  
  355. OrderedCollectionIterator::~OrderedCollectionIterator()                        
  356. {
  357. }
  358.  
  359. //------------------------------------------------------------------------------
  360. // OrderedCollectionIterator::First
  361. //------------------------------------------------------------------------------
  362.  
  363. ElementType    OrderedCollectionIterator::First()
  364. {
  365.     ValueLink* link = (ValueLink*) fImplementation.First();
  366.     
  367.     return link ? link->GetValue() : (ElementType)kODNULL;
  368. }
  369.  
  370. //------------------------------------------------------------------------------
  371. // OrderedCollectionIterator::Next
  372. //------------------------------------------------------------------------------
  373.  
  374. ElementType    OrderedCollectionIterator::Next()
  375. {        
  376.     ValueLink* link = (ValueLink*) fImplementation.Next();
  377.     
  378.     return link ? link->GetValue() : (ElementType)kODNULL;
  379. }
  380.  
  381. //------------------------------------------------------------------------------
  382. // OrderedCollectionIterator::Last
  383. //------------------------------------------------------------------------------
  384.  
  385. ElementType    OrderedCollectionIterator::Last()
  386. {
  387.     ValueLink* link = (ValueLink*) fImplementation.Last();
  388.     
  389.     return link ? link->GetValue() : (ElementType)kODNULL;
  390. }
  391.  
  392. //------------------------------------------------------------------------------
  393. // OrderedCollectionIterator::Previous
  394. //------------------------------------------------------------------------------
  395.  
  396. ElementType    OrderedCollectionIterator::Previous()
  397. {
  398.     ValueLink* link = (ValueLink*) fImplementation.Previous();
  399.     
  400.     return link ? link->GetValue() : (ElementType)kODNULL;
  401. }
  402.  
  403. //------------------------------------------------------------------------------
  404. // OrderedCollectionIterator::IsNotComplete
  405. //------------------------------------------------------------------------------
  406.  
  407. ODBoolean OrderedCollectionIterator::IsNotComplete()
  408. {
  409.     return fImplementation.IsNotComplete();
  410. }
  411.  
  412.  
  413. //------------------------------------------------------------------------------
  414. // OrderedCollectionIterator::RemoveCurrent
  415. //------------------------------------------------------------------------------
  416.  
  417. void OrderedCollectionIterator::RemoveCurrent()
  418. {
  419.     fImplementation.RemoveCurrent();
  420. }
  421.  
  422.  
  423.  
  424.  
  425.  
  426.  
  427.  
  428.