mirror of
https://github.com/nim-lang/Nim.git
synced 2026-01-07 13:33:22 +00:00
98 lines
2.6 KiB
Nim
Executable File
98 lines
2.6 KiB
Nim
Executable File
#
|
|
#
|
|
# Nimrod's Runtime Library
|
|
# (c) Copyright 2011 Andreas Rumpf
|
|
#
|
|
# See the file "copying.txt", included in this
|
|
# distribution, for details about the copyright.
|
|
#
|
|
|
|
## This module implements efficient computations of hash values for diverse
|
|
## Nimrod types.
|
|
|
|
import
|
|
strutils
|
|
|
|
type
|
|
THash* = int ## a hash value; hash tables using these values should
|
|
## always have a size of a power of two and can use the ``and``
|
|
## operator instead of ``mod`` for truncation of the hash value.
|
|
|
|
proc `!&`*(h: THash, val: int): THash {.inline.} =
|
|
## mixes a hash value `h` with `val` to produce a new hash value. This is
|
|
## only needed if you need to implement a hash proc for a new datatype.
|
|
result = h +% val
|
|
result = result +% result shl 10
|
|
result = result xor (result shr 6)
|
|
|
|
proc `!$`*(h: THash): THash {.inline.} =
|
|
## finishes the computation of the hash value. This is
|
|
## only needed if you need to implement a hash proc for a new datatype.
|
|
result = h +% h shl 3
|
|
result = result xor (result shr 11)
|
|
result = result +% result shl 15
|
|
|
|
proc hashData*(Data: Pointer, Size: int): THash =
|
|
## hashes an array of bytes of size `size`
|
|
var h: THash = 0
|
|
var p = cast[cstring](Data)
|
|
var i = 0
|
|
var s = size
|
|
while s > 0:
|
|
h = h !& ord(p[i])
|
|
Inc(i)
|
|
Dec(s)
|
|
result = !$h
|
|
|
|
proc hash*(x: Pointer): THash {.inline.} =
|
|
## efficient hashing of pointers
|
|
result = (cast[THash](x)) shr 3 # skip the alignment
|
|
|
|
proc hash*(x: int): THash {.inline.} =
|
|
## efficient hashing of integers
|
|
result = x
|
|
|
|
proc hash*(x: int64): THash {.inline.} =
|
|
## efficient hashing of integers
|
|
result = toU32(x)
|
|
|
|
proc hash*(x: char): THash {.inline.} =
|
|
## efficient hashing of characters
|
|
result = ord(x)
|
|
|
|
proc hash*(x: string): THash =
|
|
## efficient hashing of strings
|
|
var h: THash = 0
|
|
for i in 0..x.len-1:
|
|
h = h !& ord(x[i])
|
|
result = !$h
|
|
|
|
proc hashIgnoreStyle*(x: string): THash =
|
|
## efficient hashing of strings; style is ignored
|
|
var h: THash = 0
|
|
for i in 0..x.len-1:
|
|
var c = x[i]
|
|
if c == '_':
|
|
continue # skip _
|
|
if c in {'A'..'Z'}:
|
|
c = chr(ord(c) + (ord('a') - ord('A'))) # toLower()
|
|
h = h !& ord(c)
|
|
result = !$h
|
|
|
|
proc hashIgnoreCase*(x: string): THash =
|
|
## efficient hashing of strings; case is ignored
|
|
var h: THash = 0
|
|
for i in 0..x.len-1:
|
|
var c = x[i]
|
|
if c in {'A'..'Z'}:
|
|
c = chr(ord(c) + (ord('a') - ord('A'))) # toLower()
|
|
h = h !& ord(c)
|
|
result = !$h
|
|
|
|
proc hash*[T: tuple](x: T): THash =
|
|
## efficient hashing of tuples.
|
|
for f in fields(x):
|
|
result = result !& hash(f)
|
|
result = !$result
|
|
|