EIC code displayed by LXR master/​geant4/​examples/​extended/​medical/​dna/​moleculardna/​include/​DNAHashing.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-02-23 09:21:58

 //
 // ********************************************************************
 // * License and Disclaimer                                           *
 // *                                                                  *
 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
 // * conditions of the Geant4 Software License,  included in the file *
 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
 // * include a list of copyright holders.                             *
 // *                                                                  *
 // * Neither the authors of this software system, nor their employing *
 // * institutes,nor the agencies providing financial support for this *
 // * work  make  any representation or  warranty, express or implied, *
 // * regarding  this  software system or assume any liability for its *
 // * use.  Please see the license in the file  LICENSE  and URL above *
 // * for the full disclaimer and the limitation of liability.         *
 // *                                                                  *
 // * This  code  implementation is the result of  the  scientific and *
 // * technical work of the GEANT4 collaboration.                      *
 // * By using,  copying,  modifying or  distributing the software (or *
 // * any work based  on the software)  you  agree  to acknowledge its *
 // * use  in  resulting  scientific  publications,  and indicate your *
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
 //
 //
 //
 //  MolecularDNAHashing.hh
 //  Geant4
 //
 //  Created by Mathieu Karamitros
 //
 //
 
 #ifndef MolecularDNAHashing_h
 #define MolecularDNAHashing_h
 
 #include <cstdint>
 #include <string>
 #include <type_traits>
 #include <utility>
 
 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 
 namespace G4::hashing
 {
 namespace crc32
 {
 //--------------------------------------------------------------------------
 // Generate CRC lookup table
 //--------------------------------------------------------------------------
 
 template<unsigned long long c, int k = 8>
 struct f : f<((c & 1) ? 0xedb88320 : 0) ^ (c >> 1), k - 1>
 {};
 template<unsigned long long c>
 struct f<c, 0>
 {
     enum
     {
       value = c
     };
 };
 
 #define _A_(x) _B_(x) _B_(x + 128llu)
 #define _B_(x) _C_(x) _C_(x + 64llu)
 #define _C_(x) _D_(x) _D_(x + 32llu)
 #define _D_(x) _E_(x) _E_(x + 16llu)
 #define _E_(x) _F_(x) _F_(x + 8llu)
 #define _F_(x) _G_(x) _G_(x + 4llu)
 #define _G_(x) _H_(x) _H_(x + 2llu)
 #define _H_(x) _I_(x) _I_(x + 1llu)
 #define _I_(x) f<x>::value,
 
 static constexpr unsigned fCrc_table[] = {_A_(0llu)};
 
 //--------------------------------------------------------------------------
 // CRC32 ALGO
 //--------------------------------------------------------------------------
 
 //--------------------------------
 // RUN TIME ALGO
 uint32_t Hash(const char* str, size_t len);
 
 //--------------------------------------------------------------------------
 // Details for compilation time
 namespace detail
 {
 // CRC32 Table (zlib polynomial)
 template<size_t idx>
 constexpr uint32_t Combine_crc32(const char* str, uint32_t part)
 {
   return (part >> 8) ^ fCrc_table[(part ^ str[idx]) & 0x000000FF];
 }
 
 // recursion
 template<size_t idx>
 constexpr uint32_t Crc32(const char* str)
 {
   return Combine_crc32<idx>(str, Crc32<idx - 1>(str));
 }
 
 // stop-recursion
 template<>
 constexpr uint32_t Crc32<size_t(-1)>(const char* /*str*/)
 {
   return 0xFFFFFFFF;
 }
 }  // namespace detail
 
 //--------------------------------------------------------------------------
 // use COMPILATION TIME CRC32 as a hash function
 template<size_t len>
 constexpr uint32_t Hash(const char (&str)[len])
 {
   return (detail::Crc32<len - 2>(str)) ^ 0xFFFFFFFF;
 }
 
 //--------------------------------------------------------------------------
 // std::string hasher for convenience
 uint32_t Hash(const std::string& str);
 // in window
 // warning C4717: 'G4::hashing::crc32::crc32_hasher<G4String>::operator()': recursive on all control
 // paths, function will cause runtime stack overflow
 /*
 template <typename T>
 struct crc32_hasher
 {
   template <size_t len>
   uint32_t constexpr operator()(const char (&str)[len]) const
   {
     return hash(str);
   }
 
   uint32_t operator()(T str) const { return hash(str); }
 };
 
 template <typename T>
 uint32_t constexpr hash(T&& t)
 {
   return crc32_hasher<typename std::decay<T>::type>()(std::forward<T>(t));
 }
 */
 }  // namespace crc32
 
 //--------------------------------------------------------------------------
 // fnv ALGO
 //--------------------------------------------------------------------------
 
 namespace fnv
 {
 // Fowler / Noll / Vo (fnv) Hash - 1a
 // magic numbers from http://www.isthe.com/chongo/tech/comp/fnv/
 #define fnv_offset_basis 0xcbf29ce484222325U
 #define fnv_prime 0x100000001b3U  // 64 bits
 // 224 + 28 + 0x93
 
 //------------------------------------------------------------------------
 // Run time
 size_t Hash(const std::string& str);
 
 //--------------------------------------------------------------------------
 // Details for compilation time
 namespace detail
 {
 // recursion
 template<int idx>
 constexpr size_t Fnv(const char* str, size_t len, size_t hash)
 {
   return Fnv<idx - 1>(str, len, (hash ^ (str[len - idx])) * fnv_prime);
 }
 
 // stop-recursion
 template<>
 constexpr size_t Fnv<-1>(const char*, size_t, size_t hash)
 {
   return hash;
 }
 }  // namespace detail
 
 //------------------------------------------------------------------------
 // COMPILATION TIME
 template<size_t len>
 constexpr size_t Hash(const char (&str)[len])
 {
   return detail::Fnv<len - 2>(str, len - 2, fnv_offset_basis);
 }
 
 //------------------------------------------------------------------------
 template<class>
 struct fnv_hasher;
 
 template<typename T>
 struct fnv_hasher
 {
     template<size_t len>
     size_t constexpr operator()(const char (&str)[len]) const
     {
       return Hash(str);
     }
 
     size_t operator()(const T& str) const { return Hash(str); }
 };
 
 //      template<>
 //      size_t fnv_hasher<std::string>::operator()(const std::string& str)
 //      const{
 //          return hash(str.c_str());
 //      }
 
 template<typename T>
 size_t constexpr Hash(T&& t)
 {
   return fnv_hasher<typename std::decay<T>::type>()(std::forward<T>(t));
 }
 }  // namespace fnv
 
 //--------------------------------------------------------------------------
 // LARSON
 //--------------------------------------------------------------------------
 
 namespace larson
 {
 //------------------------------------------------------------------------
 // Details for compilation time
 namespace detail
 {
 // recursion
 template<int idx>
 constexpr size_t Larson(const char* str, size_t len, size_t hash)
 {
   return Larson<idx - 1>(str, len + 1, hash * 101 + str[len]);
 }
 
 // stop-recursion
 template<>
 constexpr size_t Larson<-1>(const char*, size_t, size_t hash)
 {
   return hash;
 }
 }  // namespace detail
 
 //------------------------------------------------------------------------
 // COMPILATION TIME
 template<size_t len>
 constexpr size_t Cthash(const char (&str)[len], unsigned int seed = 0)
 {
   return detail::Larson<len - 2>(str, 0, seed);
 }
 
 //------------------------------------------------------------------------
 // RUN TIME
 size_t Hash(const char* str, unsigned int seed = 0);
 
 size_t Hash(std::string str, unsigned int seed = 0);
 }  // namespace larson
 
 //--------------------------------------------------------------------------
 // DEFAULT STRING HASHER
 //--------------------------------------------------------------------------
 
 template<typename T>
 struct hasher
 {
     std::size_t constexpr operator()(char const* input) const
     {
       return *input ? static_cast<std::size_t>(*input) + 33 * (*this)(input + 1) : 5381;
     }
 
     std::size_t operator()(const std::string& str) const { return (*this)(str.c_str()); }
 };
 
 template<typename T>
 std::size_t constexpr Hash(T&& t)
 {
   return hasher<typename std::decay<T>::type>()(std::forward<T>(t));
 }
 
 // not necessary
 template<>
 std::size_t constexpr Hash<const char*>(const char*&& str)
 {
   return hasher<std::string>()(str);
 }
 
 inline namespace literals
 {
 std::size_t constexpr operator"" _hash(const char* s, size_t)
 {
   return hasher<std::string>()(s);
 }
 }  // namespace literals
 }  // namespace G4::hashing
 
 using namespace G4::hashing::literals;
 
 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team