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
{