IdentifierToHash.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONCALIBIDENTIFIER_IDENTIFIERTOHASH_H
#define MUONCALIBIDENTIFIER_IDENTIFIERTOHASH_H
 
/***************************************************************************
 * Identifier utility
 * -----------------------------------------
 *
 * Author       : Martin Woudstra
 * Creation Date: 28 April 2004
 * Last Update  : 27 April 2005
 ***************************************************************************/
 
#include "MuonCalibIdentifier/MultiDimArray.h"
#include "GaudiKernel/MsgStream.h"
#include "AthenaKernel/getMessageSvc.h"
 
#include <iostream>
#include <sstream>
#include <string>
#include <limits.h>

template <class T>
class IdentifierToHash {
public:
   //
   // nested types
   //
   enum { NFIELDS = T::NFIELDS, NMAX=UINT_MAX };
   typedef typename T::IdentifierType IdType;
   typedef typename T::HashType HashType;
   typedef MultiDimArray<T,NFIELDS> ArrayType;
   static HashType defaultHashValue() {
      return T::defaultHash();
   }

   template < unsigned int N, class K >
   class RecursiveIndexCall {
   public:
      static const typename K::ValueType& getConstRef( const K& obj, const T& indices ) {
     int idx = indices[N-1];
#ifdef IDENTIFIERTOHASH_DEBUG
    MsgStream log(Athena::getMessageSvc(),"RecursiveIndexCall");
    log<<MSG::DEBUG<<"[" << idx << "]"<<endmsg;
#endif
     return RecursiveIndexCall<N-1,typename K::SubType>::getConstRef( obj[ idx ], indices );
      }
      static typename K::ValueType& getRef( K& obj, const T& indices ) {
     int idx = indices[N-1];
#ifdef IDENTIFIERTOHASH_DEBUG
    log<<MSG::DEBUG<<"{" << idx << "}"<<endmsg;
#endif
     return RecursiveIndexCall<N-1,typename K::SubType>::getRef( obj[ idx ], indices );
      }
   };
   
   // specialise for N=1 to end recursion
   template < class K >
   class RecursiveIndexCall<1,K> {
   public:
      static const typename K::ValueType& getConstRef( const K& obj, const T& indices ) {
     int idx = indices[0];
#ifdef IDENTIFIERTOHASH_DEBUG
    MsgStream log(Athena::getMessageSvc(),"RecursiveIndexCall");
    log<<MSG::DEBUG<<"[" << idx << "]"<<endmsg;
#endif
     return obj[ idx ];
      }
      static typename K::ValueType& getRef( K& obj, const T& indices ) {
     int idx = indices[0];
#ifdef IDENTIFIERTOHASH_DEBUG
    log<<MSG::DEBUG<<"{" << idx << "}"<<endmsg;
#endif
     return obj[ idx ];
      }
   };
   
   // zero is invalid. Make empty class.
   template < class K >
   class RecursiveIndexCall<0,K> {
   };

   template < unsigned int N, class K>
   class RecursiveRangeCheck {
   public:
      static bool isInRange( const K& obj, const T& indices ) {
     int idx = indices[N-1];
     bool bOK = obj.isInRange( idx );
#ifdef IDENTIFIERTOHASH_DEBUG
    MsgStream log(Athena::getMessageSvc(),"RecursiveRangeCheck");
    log<<MSG::DEBUG<<"(" << idx << ")"<<endmsg;
     if ( !bOK ) {
      log<<MSG::DEBUG<<" CHECK: " << idx << " Out of range (" << obj.minIndex() << "," << obj.maxIndex() << ")"<<endmsg;
     } 
#endif
     return bOK && RecursiveRangeCheck<N-1,typename K::SubType>::isInRange( obj[ idx ], indices );
      }
     
   };

   template <class K>
   class RecursiveRangeCheck<1,K> {
   public:
      static bool isInRange( const K& obj, const T& indices ) {
     int idx = indices[0];
     bool bOK = obj.isInRange( idx );
#ifdef IDENTIFIERTOHASH_DEBUG
    MsgStream log(Athena::getMessageSvc(),"RecursiveRangeCheck");
    log<<MSG::DEBUG<<"(" << idx << ")"<<endmsg;
     if ( !bOK ) {
      log<<MSG::DEBUG<<" CHECK: Out of range (" << obj.minIndex() << "," << obj.maxIndex() << ")"<<endmsg;
     }else {
      log<<MSG::DEBUG<<" CHECK: Range OK"<<endmsg;
     }
#endif
     return bOK;
      }
   };

   template <class K>
   class RecursiveRangeCheck<0,K> {
      // empty class
   };
   //
   // Member functions
   //
   IdentifierToHash();
   explicit IdentifierToHash( const T& idFields );
   void clear();
   unsigned int size() const;
   unsigned int totalSize() const;
   HashType addEntry( const IdType& id );
   bool addEntry( const IdType& id, const HashType& aHash );
   HashType getHash( const IdType& id ) const;
   void dumpOneEntry( const IdType& id, std::ostream& os ) const;
   std::string dumpOneEntryToString( const IdType& id ) const;
   void dump( std::ostream& os = std::cout ) const;
   std::string dumpToString() const;
private:
   mutable T m_idFields;
   unsigned int m_entries;
   ArrayType m_data;
};
 
template <class T>
inline IdentifierToHash<T>::IdentifierToHash()
   : m_entries(0)
{}
 
template <class T>
inline IdentifierToHash<T>::IdentifierToHash( const T& idFields )
   : m_idFields( idFields ), m_entries(0)
{}
 
template <class T>
bool
IdentifierToHash<T>::addEntry( const typename IdentifierToHash<T>::IdType& id,
                   const typename IdentifierToHash<T>::HashType& aHash ) {
#ifdef IDENTIFIERTOHASH_DEBUG
   MsgStream log(Athena::getMessageSvc(),"IdentifierToHash<T>");
   log<<MSG::DEBUG<<"IdentifierToHash<T>::addEntry(0x" << std::hex << id << std::dec << "," << aHash << ")"<<endmsg;
#endif
   if ( !T::isValid( id ) ) {
#ifdef IDENTIFIERTOHASH_DEBUG
   log<<MSG::DEBUG<<": id is invalid. Nothing added."<<endmsg;
#endif
      return false;
   }
   m_idFields.setAll( id );
#ifdef 
   log<<MSG::DEBUG<<"::IdToHashTable"<<endmsg;
#endif
   
   HashType& hashRef =
      RecursiveIndexCall< NFIELDS, ArrayType >::getRef( m_data, m_idFields );
   // only add hash if entry is not yet taken
   if ( hashRef != defaultHashValue() ) {
#ifdef IDENTIFIERTOHASH_DEBUG
      log<<MSG::WARNING<<"id already taken by hash=" << hashRef << ". Nothing added."<<endmsg;
#endif
      return false;
   } else {
      // set the hash to the indicated value
      hashRef = aHash;
#ifdef IDENTIFIERTOHASH_DEBUG
      log<<MSG::DEBUG<<" ADDED."<<endmsg;
#endif
   }
 
   ++m_entries;
   return true;
}
 
template <class T>
typename IdentifierToHash<T>::HashType
IdentifierToHash<T>::addEntry( const typename IdentifierToHash<T>::IdType& id ) {
   HashType aHash = m_entries;
   if ( !addEntry( id, aHash ) ) return defaultHashValue();
   return aHash;
}
 
template <class T>
inline typename IdentifierToHash<T>::HashType
IdentifierToHash<T>::getHash( const typename IdentifierToHash<T>::IdType& id ) const {
   if ( !T::isValid( id ) ) return defaultHashValue();
   m_idFields.setAll( id );
   // check that fields are in range
   if ( !RecursiveRangeCheck< NFIELDS, ArrayType >::isInRange( m_data, m_idFields ) ) {
      return defaultHashValue();
   }
   return RecursiveIndexCall< NFIELDS, ArrayType >::getConstRef( m_data, m_idFields );
}
 
template <class T>
inline void IdentifierToHash<T>::clear() {
   m_entries = 0;
   m_data.clear();
}
 
template <class T>
inline unsigned int IdentifierToHash<T>::size() const {
   return m_entries;
}
 
 
template <class T>
inline unsigned int IdentifierToHash<T>::totalSize() const {
   return m_data.totalSize();
}
 
template <class T>
inline void IdentifierToHash<T>::dumpOneEntry( const typename IdentifierToHash<T>::IdType& id,
                           std::ostream& os ) const {
   m_idFields.setAll( id );
   m_data.dumpOneEntry( m_idFields, os );
}
 
template <class T>
inline std::string IdentifierToHash<T>::dumpOneEntryToString( const typename IdentifierToHash<T>::IdType& id ) const {
   m_idFields.setAll( id );
   return m_data.dumpOneEntryToString( m_idFields );
}
 
template <class T>
inline void IdentifierToHash<T>::dump( std::ostream& os ) const {
   m_data.dump( os );
}
 
template <class T>
inline std::string IdentifierToHash<T>::dumpToString() const {
   return m_data.dumpToString();
}
 
 
#endif // MUONCALIBIDENTIFIER_IDENTIFIERTOHASH_H