IdHashTableHelper.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
/***************************************************************************
 * Identifier Hashes
 * -----------------------------------------
 *
 * Author       : Martin Woudstra
 * Creation Date: 03 May 2004
 * Last Update  : 27 April 2005
 ***************************************************************************/
 
#ifndef MUONCALIBIDENTIFIER_IDHASHTABLEHELPER_H
# define MUONCALIBIDENTIFIER_IDHASHTABLEHELPER_H
// std
#include <limits.h>
// other packages
// this package
 
template < unsigned int N, class ID, class HASH >
class IdHashTableHelper {
public:
   //
   // nested types 
   //
   enum { NFIELDS = N, NMAX=UINT_MAX };
   typedef ID IdentifierType;
   typedef HASH HashType;
   typedef HASH ValueType; 
   //
   // Member functions
   //
   IdHashTableHelper();
   explicit IdHashTableHelper( const IdentifierType& id );
   explicit IdHashTableHelper( int fields[N] );
   virtual ~IdHashTableHelper();
   const IdentifierType& getId() const;
   void setId( const IdentifierType& id );
   int operator[]( unsigned int fieldIndex ) const;
   void setField( int index, int value );
   void setFields( int fields[N] );
   static void setDefaults( const IdentifierType& defId, const HashType& defHash );
   /* Return whether identifier is valid by comparing it with the default.
      Can be overloaded in derived class (probably not needed). */
   static bool isValid( const IdentifierType& );
   static HashType defaultHash();
   static IdentifierType defaultIdentifier();
   static ValueType defaultValue();
private:
   //
   // Member data
   //
   IdentifierType m_id;
   int m_fields[N];     // the expanded identifier fields to use as indices
   //
   // Static members
   //
   static IdentifierType s_defaultId;
   static HashType       s_defaultHash;
};
 
template < unsigned int N, class ID, class HASH >
inline IdHashTableHelper<N,ID,HASH>::IdHashTableHelper() {
   for ( unsigned int i = 0; i < N; ++i ) m_fields[i] = INT_MAX;
}
 
template < unsigned int N, class ID, class HASH >
inline
IdHashTableHelper<N,ID,HASH>::IdHashTableHelper(
   const typename IdHashTableHelper<N,ID,HASH>::IdentifierType& id )
   : m_id(id)
{
   for ( unsigned int i = 0; i < N; ++i ) m_fields[i] = INT_MAX;
}
 
template < unsigned int N, class ID, class HASH >
inline IdHashTableHelper<N,ID,HASH>::IdHashTableHelper( int fields[N] ) {
   for ( unsigned int i = 0; i < N; ++i ) m_fields[i] = fields[i];
}
 
template < unsigned int N, class ID, class HASH >
inline IdHashTableHelper<N,ID,HASH>::~IdHashTableHelper() {
   // nothing to do
}
 
template < unsigned int N, class ID, class HASH >
inline int IdHashTableHelper<N,ID,HASH>::operator[]( unsigned int index ) const {
   return m_fields[index];
}
 
template < unsigned int N, class ID, class HASH >
inline const typename IdHashTableHelper<N,ID,HASH>::IdentifierType&
IdHashTableHelper<N,ID,HASH>::getId() const {
   return m_id;
}
 
template < unsigned int N, class ID, class HASH >
inline void
IdHashTableHelper<N,ID,HASH>::setId( const typename IdHashTableHelper<N,ID,HASH>::IdentifierType& id ) {
   m_id = id;
}
 
template < unsigned int N, class ID, class HASH >
inline void IdHashTableHelper<N,ID,HASH>::setField( int index, int value ) {
   m_fields[index] = value;
}
 
template < unsigned int N, class ID, class HASH >
inline void IdHashTableHelper<N,ID,HASH>::setFields( int fields[N] ) {
   for ( unsigned int i = 0; i < N; ++i ) m_fields[i] = fields[i];
}
 
template < unsigned int N, class ID, class HASH >
inline void IdHashTableHelper<N,ID,HASH>::setDefaults(
   const typename IdHashTableHelper<N,ID,HASH>::IdentifierType& defId,
   const typename IdHashTableHelper<N,ID,HASH>::HashType& defHash ) {
   s_defaultId   = defId;
   s_defaultHash = defHash;
}
 
template < unsigned int N, class ID, class HASH >
inline typename IdHashTableHelper<N,ID,HASH>::HashType
IdHashTableHelper<N,ID,HASH>::defaultHash() {
   return s_defaultHash;
}
 
template < unsigned int N, class ID, class HASH >
inline typename IdHashTableHelper<N,ID,HASH>::IdentifierType
IdHashTableHelper<N,ID,HASH>::defaultIdentifier() {
   return s_defaultId;
}
 
template < unsigned int N, class ID, class HASH >
inline typename IdHashTableHelper<N,ID,HASH>::ValueType
IdHashTableHelper<N,ID,HASH>::defaultValue() {
   return defaultHash();
}
 
template < unsigned int N, class ID, class HASH >
inline bool IdHashTableHelper<N,ID,HASH>::isValid( const IdentifierType& id ) {
  return id != s_defaultId;
}
 
//
// static members
//
template < unsigned int N, class ID, class HASH > 
typename IdHashTableHelper<N,ID,HASH>::IdentifierType 
IdHashTableHelper<N,ID,HASH>::s_defaultId =
typename IdHashTableHelper<N,ID,HASH>::IdentifierType();
 
template < unsigned int N, class ID, class HASH >
typename IdHashTableHelper<N,ID,HASH>::HashType 
IdHashTableHelper<N,ID,HASH>::s_defaultHash =
typename IdHashTableHelper<N,ID,HASH>::HashType();
 
#endif // MUONCALIBIDENTIFIER_IDHASHTABLEHELPER_H