chainedHashMap.go

package hashMap

import (
"container/list"
"crypto/sha1"
"math/big"
)

typechainedHashMapstruct {
hashMapBase
backets []*list.List
}

func (h*chainedHashMap) Init(capuint32) {
h.hashMapBase.Init(cap)
ifcap==0 {
h.backets=nil
 } else {
h.backets=make([]*list.List, h.Cap, h.Cap)
 }
}

func (h*chainedHashMap) Move(capuint32) {
oldBackets:=h.backets
h.Init(cap)
for_, list:=rangeoldBackets {
iflist!=nil {
fore:=list.Front(); e!=nil; e=e.Next() {
h.HashInsert(e.Value.(hashElement).Key, e.Value.(hashElement).Value)
 }
 }
 }
}

func (h*chainedHashMap) hash(keyinterface{}) uint32 {
hashValue:=h.HashFunc(key, sha1.New())
mb:=big.NewInt(int64(h.Cap))
hashValue.Mod(hashValue, mb)
returnuint32(hashValue.Uint64())
}

func (h*chainedHashMap) existInList(keyinterface{}, list*list.List) (*list.Element, bool) {
fore:=list.Front(); e!=nil; e=e.Next() {
ife.Value.(hashElement).Key==key {
returne, true
 }
 }
returnnil, false
}

func (h*chainedHashMap) HashInsert(keyinterface{}, valueinterface{}) {
h.UpScale()
hashKey:=h.hash(key)
ifh.backets[hashKey] ==nil {
h.backets[hashKey] =list.New()
 }
e:=hashElement{Key: key, Value: value}
le, exist:=h.existInList(key, h.backets[hashKey])
ifexist {
le.Value=e
 } else {
h.backets[hashKey].PushFront(e)
h.Count++
 }
}

func (h*chainedHashMap) HashGet(keyinterface{}) (interface{}, bool) {
ifh.Count!=0 {
hashKey:=h.hash(key)
ifh.backets[hashKey] ==nil {
returnnil, false
 }
le, exist:=h.existInList(key, h.backets[hashKey])
ifexist {
returnle.Value.(hashElement).Value, true
 }
 }
returnnil, false
}

func (h*chainedHashMap) HashDelete(keyinterface{}) {
hashKey:=h.hash(key)
ifh.backets[hashKey] ==nil {
return
 }
le, exist:=h.existInList(key, h.backets[hashKey])
ifexist {
h.backets[hashKey].Remove(le)
 }
ifh.backets[hashKey].Len() ==0 {
h.backets[hashKey] =nil
h.Count--
 }
h.DownScale()
}

funcnewChainedHashMap() *chainedHashMap {
h:=new(chainedHashMap)
h.hashMapBase.hashMap=h
h.hashMapBase.scaleableMap=h
returnh
}