1 // Copyright 2016 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
12 // This file contains reference map implementations for unit-tests.
14 // mapInterface is the interface Map implements.
15 type mapInterface interface {
16 Load(interface{}) (interface{}, bool)
17 Store(key, value interface{})
18 LoadOrStore(key, value interface{}) (actual interface{}, loaded bool)
20 Range(func(key, value interface{}) (shouldContinue bool))
23 // RWMutexMap is an implementation of mapInterface using a sync.RWMutex.
24 type RWMutexMap struct {
26 dirty map[interface{}]interface{}
29 func (m *RWMutexMap) Load(key interface{}) (value interface{}, ok bool) {
31 value, ok = m.dirty[key]
36 func (m *RWMutexMap) Store(key, value interface{}) {
39 m.dirty = make(map[interface{}]interface{})
45 func (m *RWMutexMap) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) {
47 actual, loaded = m.dirty[key]
51 m.dirty = make(map[interface{}]interface{})
59 func (m *RWMutexMap) Delete(key interface{}) {
65 func (m *RWMutexMap) Range(f func(key, value interface{}) (shouldContinue bool)) {
67 keys := make([]interface{}, 0, len(m.dirty))
68 for k := range m.dirty {
69 keys = append(keys, k)
73 for _, k := range keys {
84 // DeepCopyMap is an implementation of mapInterface using a Mutex and
85 // atomic.Value. It makes deep copies of the map on every write to avoid
86 // acquiring the Mutex in Load.
87 type DeepCopyMap struct {
92 func (m *DeepCopyMap) Load(key interface{}) (value interface{}, ok bool) {
93 clean, _ := m.clean.Load().(map[interface{}]interface{})
94 value, ok = clean[key]
98 func (m *DeepCopyMap) Store(key, value interface{}) {
106 func (m *DeepCopyMap) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) {
107 clean, _ := m.clean.Load().(map[interface{}]interface{})
108 actual, loaded = clean[key]
110 return actual, loaded
114 // Reload clean in case it changed while we were waiting on m.mu.
115 clean, _ = m.clean.Load().(map[interface{}]interface{})
116 actual, loaded = clean[key]
124 return actual, loaded
127 func (m *DeepCopyMap) Delete(key interface{}) {
135 func (m *DeepCopyMap) Range(f func(key, value interface{}) (shouldContinue bool)) {
136 clean, _ := m.clean.Load().(map[interface{}]interface{})
137 for k, v := range clean {
144 func (m *DeepCopyMap) dirty() map[interface{}]interface{} {
145 clean, _ := m.clean.Load().(map[interface{}]interface{})
146 dirty := make(map[interface{}]interface{}, len(clean)+1)
147 for k, v := range clean {