home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
OS/2 Shareware BBS: 10 Tools
/
10-Tools.zip
/
cset21v1.zip
/
IBMCPP
/
IBMCLASS
/
IBSTKSS.C
< prev
next >
Wrap
Text File
|
1993-09-22
|
10KB
|
244 lines
/*******************************************************************************
* *
* COPYRIGHT: *
* IBM C/C++ Tools Version 2.01 - Collection Class Library *
* Licensed Materials - Property of IBM *
* (C) Copyright IBM Corporation 1992, 1993 *
* All Rights Reserved *
* US Government Users Restricted Rights - Use, duplication, or disclosure *
* restricted by GSA ADP Schedule Contract with IBM Corp. *
* *
*******************************************************************************/
template < class Element, class Key, class ElementOps, size_t nodeSize >
void const* IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Lnode::
getElement () const
{ return &ivItem;
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
void* IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Lnode::
getElement ()
{ return &ivItem;
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
void IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Lnode::
replaceElement (void const* element)
{ ivItem = *(Element const*) element;
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Lnode::
isKeyEqualTo (void const* lnode) const
{ return 0 == elementOps().keyOps.compare (
elementOps().key (ivItem),
elementOps().key (((Lnode const*) lnode)->ivItem));
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Lnode::
isKeyEqualToKeyOfElement (void const* element) const
{ return 0 == elementOps().keyOps.compare (
elementOps().key (ivItem),
elementOps().key (*(Element const*) element));
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Lnode::
isKeyEqualToKey (void const* key) const
{ return 0 == elementOps().keyOps.compare (
elementOps().key (ivItem),
*(Key const*) key);
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
IBSTKeySortedSetImpl::Lnode*
IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
newLnode (void const* element) const
{ IBSTKeySortedSetImpl::Lnode* result = new Lnode(*(Element const*) element);
ICHECK (result != 0, IOutOfMemory, IOutOfMemoryText)
return result;
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
IBSTKeySortedSetImpl::Lnode*
IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
newLnodeFromLnode (void const* lnode) const
{ IBSTKeySortedSetImpl::Lnode* result = new Lnode(*(Lnode const*) lnode);
ICHECK (result != 0, IOutOfMemory, IOutOfMemoryText)
return result;
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
IBSTKeySortedSetImpl::Inode*
IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
newInode () const
{ IBSTKeySortedSetImpl::Inode* result = new Inode();
ICHECK (result != 0, IOutOfMemory, IOutOfMemoryText)
return result;
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
IBSTKeySortedSetImpl::Inode*
IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
newInode (void const* inode) const
{ Inode const* in = (Inode const*) inode;
Inode* result = new Inode (*in);
ICHECK (result != 0, IOutOfMemory, IOutOfMemoryText)
for (IPosition i = 0; i < result->ivm; i++)
result->ivNodeptrs[i] = in->ivNodeptrs[i];
for (i = 0; i < result->ivm-1; i++)
result->ivKeys [i] = in->ivKeys [i];
return result;
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
void* IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
newKey () const
{ void* result = new KeyWrapper;
ICHECK (result != 0, IOutOfMemory, IOutOfMemoryText)
return result;
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
void IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
deleteLnode (void* lnode) const
{ delete ((Lnode*) lnode);
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
void IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
deleteInode (void* inode) const
{ delete ((Inode*) inode);
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
void IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
deleteKey (void* key) const
{ delete ((KeyWrapper*) key);
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
isKeyLessThan (void const* key1, void const* key2) const
{ return 0 > elementOps().keyOps.compare (
* (Key*) key1,
* (Key*) key2);
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
void IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
copyKey (void *to, unsigned int toIndex,
void const* from, unsigned int fromIndex) const
{ ((Key*)to) [toIndex] = ((Key*)from) [fromIndex];
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
isKeyLessThanLnode (void const* key, void const* lnode) const
{ return 0 > elementOps().keyOps.compare (
*(Key const*) key,
elementOps().key (((Lnode const*) lnode)->ivItem));
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
void IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
copyKeyFromLnode (void* key, void const* lnode)
{ *(Key*)key = elementOps().key (((Lnode const*) lnode)->ivItem);
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
isKeyGreaterThanLnode (void const* key,
unsigned int index,
void const* lnode) const
{ return 0 < elementOps().keyOps.compare (
((Key const*) key) [index],
elementOps().key (((Lnode const*) lnode)->ivItem));
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
isKeyGreaterThanKey (void const* key1,
unsigned int index,
void const* key2) const
{ return 0 < elementOps().keyOps.compare (
((Key const*) key1) [index],
*(Key const*) key2);
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
isKeyGreaterThanElement (void const* key,
unsigned int index,
void const* element) const
{ return 0 < elementOps().keyOps.compare (
((Key const*) key) [index],
elementOps().key (*(Element const*) element));
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Cursor::
setToFirst ()
{ return ivCollection->setToFirst (*this);
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Cursor::
setToNext ()
{ return ivCollection->setToNext (*this);
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Cursor::
isValid () const
{ return ivNode != 0;
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
void IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Cursor::
invalidate ()
{ ivNode = 0;
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
constantFunctionIteration (void *iterationFunction,
void* env,
void const* lnode) const
{ return (*(IBoolean (*) (Element const&, void*)) iterationFunction)
(((Lnode const*)lnode)->ivItem, env);
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
functionIteration (void *iterationFunction, void* env, void* lnode) const
{ return (*(IBoolean (*) (Element&, void*)) iterationFunction)
(((Lnode*)lnode)->ivItem, env);
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
constantIteratorIteration (void* iterator, void const* lnode) const
{ return ((IConstantIterator < Element >*)iterator)->
applyTo (((Lnode const*)lnode)->ivItem);
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
iteratorIteration (void* iterator, void* lnode) const
{ return ((IIterator < Element >*)iterator)->
applyTo (((Lnode*)lnode)->ivItem);
}
template < class Element, class Key, class ElementOps, size_t nodeSize >
long IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
functionComparison (void *comparisonFunction,
void const* lnode1,
void const* lnode2) const
{ return (*(long (*) (Element const&, Element const&) const)
comparisonFunction)
( ((Lnode const*)lnode1)->ivItem,
((Lnode const*)lnode2)->ivItem );
}