home *** CD-ROM | disk | FTP | other *** search
/ Quark 3 / Quark3.iso / KATALOG / ARCHIV / TOOL / T001.ZIP / SOURCE.ZIP / nodesequence.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1999-04-27  |  6.8 KB  |  273 lines
  1. /*
  2. Copyright (C) Matthew 'pagan' Baranowski & Sander 'FireStorm' van Rossen
  3.  
  4. This program is free software; you can redistribute it and/or
  5. modify it under the terms of the GNU General Public License
  6. as published by the Free Software Foundation; either version 2
  7. of the License, or (at your option) any later version.
  8.  
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. GNU General Public License for more details.
  13.  
  14. You should have received a copy of the GNU General Public License
  15. along with this program; if not, write to the Free Software
  16. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17. */
  18.  
  19. #include "ndictionary.h"
  20. #include <string.h>
  21. #include <iostream.h>
  22.  
  23. //void DebugToFile (char *msg, ...);
  24.  
  25. BOOL StrKeyComparatorInfo::equal( Object key1, Object key2 )
  26. {
  27.  return (!strcmp( (char*)key1, (char*)key2 )); 
  28. }
  29.  
  30.  
  31. /*
  32. =======
  33. destructor removes sequence positions, however does nothing for the object pointers
  34. use this if _only_ if don't need to delete position elements
  35. =======
  36. */
  37. NodeSequenceInfo::~NodeSequenceInfo()
  38. {
  39.     NodePosition pos, next;
  40.     if (!isEmpty()) {
  41.         for(pos=first(); pos!=NULL ; pos=next) {
  42.             next = after(pos);
  43.             remove(pos);
  44.         }
  45.     }
  46. }
  47.  
  48.  
  49. Object NodeSequenceInfo::replace(NodePosition position, Object newElement )
  50. {
  51.     NodePosition nodePosition = (NodePosition)position;
  52.     Object toReturn = nodePosition->element();
  53.     nodePosition->setElement( newElement );
  54.     return toReturn;
  55. };
  56.  
  57. void NodeSequenceInfo::dumpSequence()
  58. {
  59.         
  60.   cout << "Sequence Dump, size " <<  size() << endl;  
  61.   for (NodePosition pos = first(); pos != NULL; pos = after(pos) ) {
  62.     cout << "   Position " << pos;
  63.     cout << " next " << pos->getNextNode();
  64.     cout << " prev " << pos->getPrevNode();
  65.     cout << " element " << pos->element() << endl;
  66.   }
  67.                       
  68. }
  69.  
  70. void NodeSequenceInfo::swap(NodePosition p1,NodePosition p2 )
  71. {
  72.     NodePosition nP1 = (NodePosition)p1;
  73.     NodePosition nP2 = (NodePosition)p2;
  74.     Object element = nP1->element();
  75.     nP1->setElement( nP2->element() );
  76.     nP2->setElement( element );
  77. };
  78.  
  79. NodePosition NodeSequenceInfo::before( NodePosition p )
  80. {
  81.     NodePosition nodePosition = (NodePosition)p;
  82.     return nodePosition->getPrevNode();
  83. };
  84.  
  85. NodePosition NodeSequenceInfo::after( NodePosition p )
  86. {
  87.     NodePosition nodePosition = (NodePosition)p;
  88.     return nodePosition->getNextNode();
  89. };
  90.  
  91. NodePosition NodeSequenceInfo::insertFirst( Object element )
  92. {
  93.     NodePosition nP = new NodePositionInfo( this, element );
  94.     return insertFirst( nP );
  95. }
  96.  
  97. NodePosition NodeSequenceInfo::insertFirst( NodePosition nP )
  98. {
  99.     nP->setPrevNode( NULL );
  100.     nP->setNextNode( first_ );    
  101.     if (first_) first_->setPrevNode( nP );
  102.     first_ = nP;
  103.     if (nP->getNextNode() == NULL) {
  104.         last_ = nP;
  105.     }
  106.     
  107.     size_++;
  108.     return first_;
  109. }
  110.  
  111. NodePosition NodeSequenceInfo::insertLast( Object element )
  112. {
  113.     NodePosition nP = new NodePositionInfo( this, element );
  114.     return insertLast( nP );
  115. };
  116.  
  117.  
  118. NodePosition NodeSequenceInfo::insertLast( NodePosition nP )
  119. {
  120.     nP->setPrevNode( last_ );
  121.     nP->setNextNode( NULL );
  122.     if (last_) last_->setNextNode( nP );
  123.     last_ = nP;
  124.     if (nP->getPrevNode() == NULL) {
  125.         first_ = nP;
  126.     }
  127.     size_++;
  128.     return last_;
  129. };
  130.  
  131.  
  132. NodePosition NodeSequenceInfo::insertAfter(NodePosition p, Object element )
  133. {       
  134.     NodePosition node = (NodePosition)p;
  135.     if (node->getNextNode() == NULL) {
  136.                 NodePosition result = insertLast(element);                              
  137.         return result;
  138.     }
  139.  
  140.     NodePosition nP = new NodePositionInfo( this, element );
  141.     nP->setPrevNode( node );
  142.     nP->setNextNode( node->getNextNode() );
  143.     node->getNextNode()->setPrevNode( nP );
  144.     node->setNextNode( nP );
  145.     size_++;    
  146.     return nP;
  147.         
  148. };
  149.  
  150. NodePosition NodeSequenceInfo::insertBefore(NodePosition p, Object element )
  151. {
  152.     NodePosition node = (NodePosition)p;
  153.     if (node->getPrevNode() == NULL) {
  154.         return insertFirst( element );
  155.     }
  156.  
  157.     NodePosition nP = new NodePositionInfo( this, element );
  158.     nP->setNextNode( node );
  159.     nP->setPrevNode( node->getPrevNode() );
  160.     NodePosition prevNode = node->getPrevNode();
  161.     prevNode->setNextNode( nP );
  162.     node->setPrevNode( nP );
  163.     size_++;
  164.     return nP;
  165. };
  166.  
  167. Object NodeSequenceInfo::remove(NodePosition p )
  168. {
  169.     NodePosition nP = (NodePosition)p;
  170.     Object toReturn = nP->element();
  171.  
  172.     NodePosition prevNode = nP->getPrevNode();
  173.  
  174.     if (prevNode == NULL) {
  175.         Object result = removeFirst();                
  176.         return result;
  177.     }
  178.     
  179.     NodePosition nextNode = nP->getNextNode();
  180.  
  181.     if (nextNode == NULL) { 
  182.             Object result = removeLast();
  183.                 return result;
  184.  
  185.     }
  186.   
  187.     prevNode->setNextNode( nextNode );
  188.     nextNode->setPrevNode( prevNode );
  189.     delete nP;
  190.     size_--;
  191.     return toReturn;
  192. };
  193.  
  194. Object NodeSequenceInfo::removeAfter(NodePosition p )
  195. {
  196.  
  197.     NodePosition nP = (NodePosition)p;
  198.  
  199.     if (nP->getNextNode() == NULL) {
  200.         return NULL;
  201.     }
  202.     nP = nP->getNextNode();
  203.     
  204.     Object toReturn = nP->element();
  205.  
  206.     NodePosition prevNode = nP->getPrevNode();    
  207.     NodePosition nextNode = nP->getNextNode();
  208.  
  209.     if (nextNode == NULL) {
  210.         return removeLast();
  211.     }
  212.     
  213.     prevNode->setNextNode( nextNode );
  214.     nextNode->setPrevNode( prevNode );
  215.     delete nP;
  216.     size_--;
  217.     return toReturn;
  218. };
  219.  
  220. Object NodeSequenceInfo::removeBefore(NodePosition p )
  221. {
  222.     NodePosition nP = (NodePosition)p;
  223.  
  224.     if (nP->getPrevNode() == NULL) {
  225.         return NULL;
  226.     }
  227.     nP = nP->getPrevNode();
  228.     
  229.     Object toReturn = nP->element();
  230.  
  231.     NodePosition prevNode = nP->getPrevNode();
  232.  
  233.     if (prevNode == NULL) {
  234.         return removeFirst();
  235.     }
  236.     
  237.     NodePosition nextNode = nP->getNextNode();
  238.     
  239.     prevNode->setNextNode( nextNode );
  240.     nextNode->setPrevNode( prevNode );
  241.     delete nP;
  242.     size_--;
  243.     return toReturn;
  244. };
  245.  
  246. Object NodeSequenceInfo::removeFirst()
  247. {
  248.     NodePosition nP = (NodePosition)first_;
  249.     Object toReturn = nP->element();
  250.     
  251.     NodePosition nextNode = nP->getNextNode();
  252.     if (nextNode) nextNode->setPrevNode( NULL );
  253.     first_ = nextNode;
  254.     if (!first_) last_ = NULL;
  255.     delete nP;
  256.     size_--;
  257.     return toReturn;
  258. };
  259.  
  260. Object NodeSequenceInfo::removeLast()
  261. {
  262.     NodePosition nP = (NodePosition)last_;
  263.     Object toReturn = nP->element();
  264.     
  265.     NodePosition prevNode = nP->getPrevNode();
  266.     if (prevNode) prevNode->setNextNode( NULL );
  267.     last_ = prevNode;
  268.     if (!last_) first_ = NULL;
  269.     delete nP;
  270.     size_--;
  271.     return toReturn;
  272. };
  273.