home *** CD-ROM | disk | FTP | other *** search
/ Informática Multimedia: Special Games / INFESPGAMES.mdf / os2 / ribble / support / assocary.c next >
Encoding:
C/C++ Source or Header  |  1994-07-08  |  5.8 KB  |  306 lines
  1. #include <AssocAry.h>
  2.  
  3.  
  4. template <class T>
  5. AssocAry<T>::AssocAry(void)
  6. : stackIter(stack)
  7. {
  8.   bucket = new AssocEl*[AssocTableSize];
  9.  
  10.   for (int i = AssocTableSize; --i >= 0; )
  11.     bucket[i] = 0;
  12. }
  13.  
  14. template <class T>
  15. AssocAry<T>::~AssocAry(void)
  16. {
  17.   delete [] bucket;
  18.  
  19.   while (stackIter)
  20.     delete stackIter++;
  21. }
  22.  
  23. template <class T>
  24. void
  25. AssocAry<T>::Destroy(void)
  26. {
  27.   for (int i = AssocTableSize; --i >= 0; )
  28.     bucket[i] = 0;
  29.  
  30.   stackIter.rewind();
  31.  
  32.   while (stackIter)
  33.     stackIter++->used = 0;
  34.  
  35.   stackIter.rewind();
  36. }
  37.  
  38. template <class T>
  39. void
  40. AssocAry<T>::insert(const T _a, const T _b)
  41. {
  42.   unsigned int index = (unsigned int)_a % AssocTableSize;
  43.  
  44.   AssocEl* element = bucket[index];
  45.   if (element == 0)
  46.     {
  47.       AssocEl* newElement = GetElement();
  48.       newElement->a = _a;
  49.       newElement->b = _b;
  50.       newElement->next = 0;
  51.       newElement->used = 1;
  52.       bucket[index] = newElement;
  53.     }
  54.   else
  55.     {
  56.       while (element)
  57.         {
  58.           if (element->a == _a)
  59.             {
  60.               element->b = _b;
  61.               break;
  62.             }
  63.  
  64.           AssocEl* next = element->next;
  65.           if (next == 0)
  66.             {
  67.               AssocEl* newElement = GetElement();
  68.               newElement->a = _a;
  69.               newElement->b = _b;
  70.               newElement->next = 0;
  71.               newElement->used = 1;
  72.               element->next = newElement;
  73.               break;
  74.             }
  75.           else
  76.             element = next;
  77.         }
  78.     }
  79. }
  80.  
  81. template <class T>
  82. int
  83. AssocAry<T>::findA(const T _b, T& _a) const 
  84. {
  85.   AssocElStackIter it(stack);
  86.  
  87.   while (it)
  88.     {
  89.       AssocEl* element = it++;
  90.       if (element->used == 1 && element->b == _b)
  91.         {
  92.           _a = element->a;
  93.           return 1;
  94.         }
  95.     }
  96.   return 0;
  97. }
  98.  
  99. template <class T>
  100. int
  101. AssocAry<T>::findB(const T _a, T& _b) const 
  102. {
  103.   unsigned int index = (unsigned int)_a % AssocTableSize;
  104.  
  105.   AssocEl* element = bucket[index];
  106.  
  107.   while (element)
  108.     {
  109.       if (element->a == _a)
  110.         {
  111.           _b = element->b;
  112.           return 1;
  113.         }
  114.       element = element->next;
  115.     }
  116.   return 0;
  117. }
  118.  
  119. template <class T>
  120. int
  121. AssocAry<T>::remove(const T _a)
  122. {
  123.   for (int i=0; i<AssocTableSize; i++)
  124.     {
  125.       AssocEl** prev = &bucket[i];
  126.       AssocEl* element = *prev;
  127.       while (element)
  128.         {
  129.           if (element->a == _a)
  130.             {
  131.               element->used = 0;
  132.               *prev = element->next;
  133.               return 1;
  134.             }
  135.  
  136.           prev = &element->next;
  137.           element = *prev;
  138.         }
  139.     }
  140.   return 0;
  141. }
  142.  
  143.  
  144. template <class T, class U>
  145. AssocAry2<T, U>::AssocAry2(void)
  146. : stackIter(stack)
  147. {
  148.   bucket = new AssocEl*[AssocTableSize];
  149.  
  150.   for (int i = AssocTableSize; --i >= 0; )
  151.     bucket[i] = 0;
  152. }
  153.  
  154. template <class T, class U>
  155. AssocAry2<T, U>::~AssocAry2(void)
  156. {
  157.   delete [] bucket;
  158.  
  159.   while (stackIter)
  160.     delete stackIter++;
  161. }
  162.  
  163. template <class T, class U>
  164. void
  165. AssocAry2<T, U>::Destroy(void)
  166. {
  167.   for (int i = AssocTableSize; --i >= 0; )
  168.     bucket[i] = 0;
  169.  
  170.   stackIter.rewind();
  171.  
  172.   while (stackIter)
  173.     stackIter++->used = 0;
  174.  
  175.   stackIter.rewind();
  176. }
  177.  
  178. template <class T, class U>
  179. void
  180. AssocAry2<T, U>::insert(const T _a, const U _b)
  181. {
  182.   unsigned int index = (unsigned int)_a % AssocTableSize;
  183.  
  184.   AssocEl* element = bucket[index];
  185.   if (element == 0)
  186.     {
  187.       AssocEl* newElement = GetElement();
  188.       newElement->a = _a;
  189.       newElement->b = _b;
  190.       newElement->next = 0;
  191.       newElement->used = 1;
  192.       bucket[index] = newElement;
  193.     }
  194.   else
  195.     {
  196.       while (element)
  197.         {
  198.           if (element->a == _a)
  199.             {
  200.               element->b = _b;
  201.               break;
  202.             }
  203.  
  204.           AssocEl* next = element->next;
  205.           if (next == 0)
  206.             {
  207.               AssocEl* newElement = GetElement();
  208.               newElement->a = _a;
  209.               newElement->b = _b;
  210.               newElement->next = 0;
  211.               newElement->used = 1;
  212.               element->next = newElement;
  213.               break;
  214.             }
  215.           else
  216.             element = next;
  217.         }
  218.     }
  219. }
  220.  
  221. template <class T, class U>
  222. int
  223. AssocAry2<T, U>::findA(const U _b, T& _a) const 
  224. {
  225.   AssocElStackIter it(stack);
  226.  
  227.   while (it)
  228.     {
  229.       AssocEl* element = it++;
  230.       if (element->used == 1 && element->b == _b)
  231.         {
  232.           _a = element->a;
  233.           return 1;
  234.         }
  235.     }
  236.   return 0;
  237. }
  238.  
  239. template <class T, class U>
  240. int
  241. AssocAry2<T, U>::findB(const T _a, U& _b) const 
  242. {
  243.   unsigned int index = (unsigned int)_a % AssocTableSize;
  244.  
  245.   AssocEl* element = bucket[index];
  246.  
  247.   while (element)
  248.     {
  249.       if (element->a == _a)
  250.         {
  251.           _b = element->b;
  252.           return 1;
  253.         }
  254.       element = element->next;
  255.     }
  256.   return 0;
  257. }
  258.  
  259. template <class T, class U>
  260. int
  261. AssocAry2<T, U>::remove(const T _a)
  262. {
  263.   for (int i=0; i<AssocTableSize; i++)
  264.     {
  265.       AssocEl** prev = &bucket[i];
  266.       AssocEl* element = *prev;
  267.       while (element)
  268.         {
  269.           if (element->a == _a)
  270.             {
  271.               element->used = 0;
  272.               *prev = element->next;
  273.               return 1;
  274.             }
  275.  
  276.           prev = &element->next;
  277.           element = *prev;
  278.         }
  279.     }
  280.   return 0;
  281. }
  282.  
  283. template <class T, class U>
  284. int
  285. AssocAry2<T, U>::remove(const U _b)
  286. {
  287.   for (int i=0; i<AssocTableSize; i++)
  288.     {
  289.       AssocEl** prev = &bucket[i];
  290.       AssocEl* element = *prev;
  291.       while (element)
  292.         {
  293.           if (element->b == _b)
  294.             {
  295.               element->used = 0;
  296.               *prev = element->next;
  297.               return 1;
  298.             }
  299.  
  300.           prev = &element->next;
  301.           element = *prev;
  302.         }
  303.     }
  304.   return 0;
  305. }
  306.