md3view/nodesequence.cpp

275 lines
6.8 KiB
C++
Raw Normal View History

2011-12-05 12:41:28 +00:00
/*
Copyright (C) 2010 Matthew Baranowski, Sander van Rossen & Raven software.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "ndictionary.h"
#include <string.h>
#include <iostream>
using namespace std;
//void DebugToFile (char *msg, ...);
BOOL StrKeyComparatorInfo::equal( Object key1, Object key2 )
{
return (!strcmp( (char*)key1, (char*)key2 ));
}
/*
=======
destructor removes sequence positions, however does nothing for the object pointers
use this if _only_ if don't need to delete position elements
=======
*/
NodeSequenceInfo::~NodeSequenceInfo()
{
NodePosition pos, next;
if (!isEmpty()) {
for(pos=first(); pos!=NULL ; pos=next) {
next = after(pos);
remove(pos);
}
}
}
Object NodeSequenceInfo::replace(NodePosition position, Object newElement )
{
NodePosition nodePosition = (NodePosition)position;
Object toReturn = nodePosition->element();
nodePosition->setElement( newElement );
return toReturn;
};
void NodeSequenceInfo::dumpSequence()
{
cout << "Sequence Dump, size " << size() << endl;
for (NodePosition pos = first(); pos != NULL; pos = after(pos) ) {
cout << " Position " << pos;
cout << " next " << pos->getNextNode();
cout << " prev " << pos->getPrevNode();
cout << " element " << pos->element() << endl;
}
}
void NodeSequenceInfo::swap(NodePosition p1,NodePosition p2 )
{
NodePosition nP1 = (NodePosition)p1;
NodePosition nP2 = (NodePosition)p2;
Object element = nP1->element();
nP1->setElement( nP2->element() );
nP2->setElement( element );
};
NodePosition NodeSequenceInfo::before( NodePosition p )
{
NodePosition nodePosition = (NodePosition)p;
return nodePosition->getPrevNode();
};
NodePosition NodeSequenceInfo::after( NodePosition p )
{
NodePosition nodePosition = (NodePosition)p;
return nodePosition->getNextNode();
};
NodePosition NodeSequenceInfo::insertFirst( Object element )
{
NodePosition nP = new NodePositionInfo( this, element );
return insertFirst( nP );
}
NodePosition NodeSequenceInfo::insertFirst( NodePosition nP )
{
nP->setPrevNode( NULL );
nP->setNextNode( first_ );
if (first_) first_->setPrevNode( nP );
first_ = nP;
if (nP->getNextNode() == NULL) {
last_ = nP;
}
size_++;
return first_;
}
NodePosition NodeSequenceInfo::insertLast( Object element )
{
NodePosition nP = new NodePositionInfo( this, element );
return insertLast( nP );
};
NodePosition NodeSequenceInfo::insertLast( NodePosition nP )
{
nP->setPrevNode( last_ );
nP->setNextNode( NULL );
if (last_) last_->setNextNode( nP );
last_ = nP;
if (nP->getPrevNode() == NULL) {
first_ = nP;
}
size_++;
return last_;
};
NodePosition NodeSequenceInfo::insertAfter(NodePosition p, Object element )
{
NodePosition node = (NodePosition)p;
if (node->getNextNode() == NULL) {
NodePosition result = insertLast(element);
return result;
}
NodePosition nP = new NodePositionInfo( this, element );
nP->setPrevNode( node );
nP->setNextNode( node->getNextNode() );
node->getNextNode()->setPrevNode( nP );
node->setNextNode( nP );
size_++;
return nP;
};
NodePosition NodeSequenceInfo::insertBefore(NodePosition p, Object element )
{
NodePosition node = (NodePosition)p;
if (node->getPrevNode() == NULL) {
return insertFirst( element );
}
NodePosition nP = new NodePositionInfo( this, element );
nP->setNextNode( node );
nP->setPrevNode( node->getPrevNode() );
NodePosition prevNode = node->getPrevNode();
prevNode->setNextNode( nP );
node->setPrevNode( nP );
size_++;
return nP;
};
Object NodeSequenceInfo::remove(NodePosition p )
{
NodePosition nP = (NodePosition)p;
Object toReturn = nP->element();
NodePosition prevNode = nP->getPrevNode();
if (prevNode == NULL) {
Object result = removeFirst();
return result;
}
NodePosition nextNode = nP->getNextNode();
if (nextNode == NULL) {
Object result = removeLast();
return result;
}
prevNode->setNextNode( nextNode );
nextNode->setPrevNode( prevNode );
delete nP;
size_--;
return toReturn;
};
Object NodeSequenceInfo::removeAfter(NodePosition p )
{
NodePosition nP = (NodePosition)p;
if (nP->getNextNode() == NULL) {
return NULL;
}
nP = nP->getNextNode();
Object toReturn = nP->element();
NodePosition prevNode = nP->getPrevNode();
NodePosition nextNode = nP->getNextNode();
if (nextNode == NULL) {
return removeLast();
}
prevNode->setNextNode( nextNode );
nextNode->setPrevNode( prevNode );
delete nP;
size_--;
return toReturn;
};
Object NodeSequenceInfo::removeBefore(NodePosition p )
{
NodePosition nP = (NodePosition)p;
if (nP->getPrevNode() == NULL) {
return NULL;
}
nP = nP->getPrevNode();
Object toReturn = nP->element();
NodePosition prevNode = nP->getPrevNode();
if (prevNode == NULL) {
return removeFirst();
}
NodePosition nextNode = nP->getNextNode();
prevNode->setNextNode( nextNode );
nextNode->setPrevNode( prevNode );
delete nP;
size_--;
return toReturn;
};
Object NodeSequenceInfo::removeFirst()
{
NodePosition nP = (NodePosition)first_;
Object toReturn = nP->element();
NodePosition nextNode = nP->getNextNode();
if (nextNode) nextNode->setPrevNode( NULL );
first_ = nextNode;
if (!first_) last_ = NULL;
delete nP;
size_--;
return toReturn;
};
Object NodeSequenceInfo::removeLast()
{
NodePosition nP = (NodePosition)last_;
Object toReturn = nP->element();
NodePosition prevNode = nP->getPrevNode();
if (prevNode) prevNode->setNextNode( NULL );
last_ = prevNode;
if (!last_) first_ = NULL;
delete nP;
size_--;
return toReturn;
};