/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Muc/MucGeomSvc/MucGeomSvc-00-02-25/MucGeomSvc/tmp/hash_vector.hh

Go to the documentation of this file.

//======================================================================
//  File:        hash.h
//  Author:      Timothy A. Budd
//  Description: This file contains the interface and implementation
//               of the hash template classes.
//
//  Copyright (c) 1992 by Timothy A. Budd.  All Rights Reserved.
//      may be reproduced for any non-commercial purpose
//
//  Modified:  March 11, 1998 by Kyle Pope
//             Inherit from STL std::vector<T> class.
//
//======================================================================

#ifndef HASH_H
#define HASH_H

#include <stddef.h>
#include <vector>

//----------------------------------------------------------------------
//      class hashVector
//              vector indexed using hashed key values
//              template types are type of key
//              and type of value stored in vector
//----------------------------------------------------------------------

//template <class T> class vector;

using namespace std;

template <class H, class T> class hashVector : public vector<T>
{
public:
    // constructors
    hashVector(size_t max, size_t (*f)(const H &));
    hashVector(size_t max, size_t (*f)(const H &), T & initialValue);
    hashVector(const hashVector<H, T> & v);

    // subscript operation
    T & operator [] (const H & index);
    const T & operator [] (const H & index) const;

private:
    // store the hash function
    size_t (*hashfun)(const H &);
};

//----------------------------------------------------------------------
//      class hashVector implementation
//----------------------------------------------------------------------

template <class H, class T>
inline hashVector<H, T>::hashVector(size_t max, size_t (*f)(const H &))
    : vector<T>(max), hashfun(f)
{
    // no further initialization
}



template <class H, class T>
inline hashVector<H, T>::hashVector(size_t max, size_t (*f)(const H&), T& initialValue)
    : vector<T>(max, initialValue), hashfun(f)
{
    // no further initialization
}



template <class H, class T>
inline hashVector<H, T>::hashVector(const hashVector<H,T> & v)
    : vector<T>(v), hashfun(v.hashfun)
{
    // no further initialization
}



template <class H, class T>
inline T & hashVector<H, T>::operator[] (const H & index)
{
  // subscript a hash vector
  // hash the index value before indexing vector
  return vector<T>::operator[] ((*hashfun)(index) % size());
}


template <class H, class T>
inline const T & hashVector<H, T>::operator[] (const H & index) const
{
  // subscript a hash vector
  // hash the index value before indexing vector
  return vector<T>::operator[] ((*hashfun)(index) % size());
}

//----------------------------------------------------------------------
//      miscellaneous template functions
//----------------------------------------------------------------------

#endif

---