map.go.tmpl

package {{ .Package }}

// Code generated by mapgen (https://github.com/s-kirby/mapgen), DO NOT EDIT.

// {{.MapName}} is a generated thread safe map
// with key {{.KeyType}} and value {{.ValType}}
type {{.MapName}} struct {
    {{ if .UseRWMutex }}
    sync.RWMutex
    {{ else }}
    sync.Mutex
    {{ end }}
    
    // M contains the underlying map.
    // Goroutines which access M directly should hold
    // the mutex.
    M map[{{.KeyType}}]{{.ValType}}
}  

// {{if .Exported}}New{{ else }}new{{end}}{{title .MapName}} returns an instantiated thread safe map
// with key {{.KeyType}} and value {{.ValType}}
func {{if .Exported}}New{{ else }}new{{end}}{{ title .MapName }}() *{{.MapName}} {
    return &{{.MapName}}{
        M: make(map[{{.KeyType}}]{{.ValType}}),
    }
}

// Open allows a closure to safely operate on the map
func (m *{{.MapName}}) Open(f func()) {
    m.Lock()
    defer m.Unlock()
    f()
}

// Copy generates a copy of the map.
func (m *{{.MapName}}) Copy() (c map[{{.KeyType}}]{{.ValType}}) {
	c = make(map[{{.KeyType}}]{{.ValType}}, len(m.M))
    {{ if .UseRWMutex }}
    m.RLock()
    {{ else }}
    m.Lock()
    {{ end }}
	for k, v := range m.M {
		c[k] = v
	}
    {{ if .UseRWMutex }}
    m.RUnlock()
    {{ else }}
    m.Unlock()
    {{ end }}
	return c
}

// Set sets a key on the map
func (m *{{.MapName}}) Set(key {{.KeyType}}, val {{.ValType}}) {
    m.Lock()
    m.M[key] = val
    m.Unlock()
}

// SetIfNotExist sets a key on the map if it doesn't exist.
// It returns the value which is set.
func (m *{{.MapName}}) SetIfNotExist(key {{.KeyType}}, val {{.ValType}}) {{.ValType}} {
    m.Lock()
    v, ok := m.M[key]
    if !ok {
        m.M[key] = val
    } else {
        val = v
    }
    m.Unlock()
    return val
}

// Delete removes a key from the map
func (m *{{.MapName}}) Delete(key {{.KeyType}}) {
    m.Lock()
    delete(m.M, key)
    m.Unlock()
}

// Get retrieves a key from the map
func (m *{{.MapName}}) Get(key {{.KeyType}}) ({{.ValType}}) {
    {{ if .UseRWMutex }}
    m.RLock()
    v := m.M[key]
    m.RUnlock()
    {{ else }}
    m.Lock()
    v := m.M[key]
    m.Unlock()
    {{ end }}

    return v
}

// Len returns the length of the map
func (m *{{.MapName}}) Len() int {
    {{ if .UseRWMutex }}
    m.RLock()
    n := len(m.M)
    m.RUnlock()
    {{ else }}
    m.Lock()
    n := len(m.M)
    m.Unlock()
    {{ end }}

    return n
}

// GetEx retrieves a key from the map
// and whether it exists
func (m *{{.MapName}}) GetEx(key {{.KeyType}}) ({{.ValType}}, bool) {
    {{ if .UseRWMutex }}
    m.RLock()
    v, exists := m.M[key]
    m.RUnlock()
    {{ else }}
    m.Lock()
    v, exists := m.M[key]
    m.Unlock()
    {{ end }}
    return v, exists
}

// Exists returns if a key exists
func (m *{{.MapName}}) Exists(key {{.KeyType}}) bool {
    {{ if .UseRWMutex }}
    m.RLock()
    _, exists := m.M[key]
    m.RUnlock()
    {{ else }}
    m.Lock()
    _, exists := m.M[key]
    m.Unlock()
    {{ end }}
    return exists
}