oldHashList.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1997 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: oldHashList.h,v $ $Revision: 1.2 $ $State: Exp $
*********************************************************************/

#ifndef oldHashList_H_
#define oldHashList_H_

#include "vlList.h"

// This file is no longer part of VR-Link. The header and source are provided 
// as an example for customers who require backwards compatability. These
// classes are no longer supported by MAK. Customers may use the classes
// as they wish without obtaining permission from MAK. 

// In VR-Link 3.3, we significantly changed the semantics of our DtHashlist
// class.  The new version is defined in hashlist.h.  The older DtHashlist 
// class has been renamed DtOldHashlist, and is still defined here in this 
// file for backwards compatibility.  While we suggest that you port your 
// code to the new DtHashlist, which is cleaner and easier to use, if you 
// do not want to make that change, you can just use DtOldHashlist wherever 
// you used to use DtHashlist, and the rest of your old code should work.

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif

union DT_DLL_VLUTIL DtHashKey 
{
   DtHashKey(int ii) { i = ii; }
   DtHashKey(const void *pp) { p = (void *) pp; }
   int   i;
   void *p;
};

class DT_DLL_VLUTIL DtHashedItem
{
 public:
   friend class DtOldHashlist;
   
   DtHashKey key() { return myKey; }
   DtListItem *listItem() { return myItem; }
 protected: 
   DtHashedItem(DtHashKey k, DtListItem *item) : myKey(k), myItem(item) {}
   DtHashKey myKey;
   DtListItem *myItem;
};

class DT_DLL_VLUTIL DtOldHashlist
{
 public:
   DtOldHashlist(unsigned numBuckets);
   virtual ~DtOldHashlist();
   
   const DtList *list() const;
   virtual unsigned hash(DtHashKey key) const;
   virtual int isEqual(DtHashKey key1, DtHashKey key2) const;
   
   // In the event that an Item with key already exists, then add
   // will replace the data and move it to the location in list.
   // If your data was alloced, do not add unless you know key is
   // unique, or a memory leak will result.

   DtListItem *add (DtHashKey key, void *data);  
   DtListItem *addToStart(DtHashKey key, void *data);
   DtListItem *addToEnd (DtHashKey key, void *data);
   DtListItem *addBefore(DtHashKey key, void *data, 
          DtListItem *before);
   DtListItem *addAfter(DtHashKey key, void *data, 
         DtListItem *after);
   
   virtual void *remove(DtHashKey key);
   virtual void *operator[] (DtHashKey key) const;
   virtual void *lookup(DtHashKey key) const; 
   
   DtListItem *itemLookup(DtHashKey key) const;
   
   unsigned nBuckets(void) const;
   unsigned bucketCount(unsigned index) const;
   
 protected:
   DtList *bucket(DtHashKey key) const;
   void addToBucket(DtHashKey k, DtListItem *item);
   DtListItem *removeFromBucket(DtHashKey key);
   DtList *myList;
   DtList *buckets;
   unsigned nbuck;
};

inline const DtList *DtOldHashlist::list() const
{ 
   return myList; 
}

inline int DtOldHashlist::isEqual(DtHashKey key1, DtHashKey key2) const
{ 
   return key1.i == key2.i; 
}

inline unsigned DtOldHashlist::hash(DtHashKey key) const 
{
   return key.i % nbuck; 
}

inline DtList *DtOldHashlist::bucket(DtHashKey key) const 
{ 
   return &buckets[hash(key)]; 
}

inline void *DtOldHashlist::lookup (DtHashKey key) const
{  
   DtListItem *item = itemLookup(key);
   return (item ? item->data() : NULL); 
}

inline void *DtOldHashlist::operator[] (DtHashKey key) const 
{ 
   return lookup(key); 
}

inline unsigned int DtOldHashlist::nBuckets() const
{
   return nbuck; 
}

inline unsigned int DtOldHashlist::bucketCount(unsigned index) const
{ 
   return buckets[index].count();
}

inline DtListItem *DtOldHashlist::add(DtHashKey key, void *data)  
{
   return addAfter(key, data, list()->last()); 
}

inline DtListItem *DtOldHashlist::addToStart(DtHashKey key, void *data) 
{
   return addAfter(key, data, NULL);  
}

inline DtListItem *DtOldHashlist::addToEnd (DtHashKey key, void *data)  
{
   return addAfter(key, data, list()->last()); 
}

inline DtListItem *DtOldHashlist::addBefore(DtHashKey key, void *data, 
                DtListItem *before) 
{
   return addAfter(key, data, before ? before->prev() : (DtListItem*)NULL); 
}

class DT_DLL_VLUTIL DtOldIntrusiveHashlist : public DtOldHashlist
{
 public:
   DtOldIntrusiveHashlist(unsigned numBuckets);
};

#ifdef DtUSE_UTILITIES_NAMESPACE
} // end of namespace DtUSE_UTILITIES_NAMESPACE
#endif

#endif /* _HASHLIST_H_ */