gosafe

README

gosafe

Store values in a thread-safe way. Supports arbitrary values, slices and maps. Uses generics which means that go 1.18+ is required.

Example

package main

import (
	"github.com/janitorjeff/gosafe"
)

func main() {
	m := gosafe.Map[int, string]{} // equivalent to map[int]string
	m.Set(123, "abc")              // m[123] = "abc"
	n, ok := m.Get(123)            // n, ok := m[123]
	// ...
}

Alongside the thread-safe methods unsafe ones are provided which allow for easy extension.

package main

import (
	"github.com/janitorjeff/gosafe"
)

type CustomSlice struct {
	gosafe.Slice[string]
}

func NewSlice() CustomSlice {
	return CustomSlice{gosafe.Slice[string]{}}
}

func (s *CustomSlice) ChangeElemsWithLengthGreaterThanThree() {
	// make it thread safe
	s.Lock()
	defer s.Unlock()

	// use unsafe methods to avoid mutex deadlock
	for i := 0; i < s.LenUnsafe(); i++ {
		if len(s.GetUnsafe(i)) > 3 {
			s.SetUnsafe(i, "changed")
		}
	}
}

func main() {
	s := NewSlice()
	s.Append("abc", "def", "long-string", "xyz")
	s.ChangeElemsWithLengthGreaterThanThree()
	print(s.Get(0), "\n") // abc
	print(s.Get(2))       // changed
}

Documentation

Index

• type Map
  • func (m *Map[K, V]) Delete(key K)
  • func (m *Map[K, V]) DeleteUnsafe(key K)
  • func (m *Map[K, V]) Get(key K) (V, bool)
  • func (m *Map[K, V]) GetUnsafe(key K) (V, bool)
  • func (m *Map[K, V]) Set(key K, value V)
  • func (m *Map[K, V]) SetUnsafe(key K, value V)
• type Slice
  • func (s *Slice[T]) Append(elems ...T)
  • func (s *Slice[T]) AppendUnsafe(elems ...T)
  • func (s *Slice[T]) DeleteStable(i int)
  • func (s *Slice[T]) DeleteStableUnsafe(i int)
  • func (s *Slice[T]) DeleteUnstable(i int)
  • func (s *Slice[T]) DeleteUnstableUnsafe(i int)
  • func (s *Slice[T]) Get(i int) T
  • func (s *Slice[T]) GetUnsafe(i int) T
  • func (s *Slice[T]) In(elem T) bool
  • func (s *Slice[T]) InUnsafe(elem T) bool
  • func (s *Slice[T]) Len() int
  • func (s *Slice[T]) LenUnsafe() int
  • func (s *Slice[T]) Set(i int, value T)
  • func (s *Slice[T]) SetUnsafe(i int, value T)
• type Value
  • func (v *Value[T]) Get() T
  • func (v *Value[T]) GetUnsafe() T
  • func (v *Value[T]) Set(value T)
  • func (v *Value[T]) SetUnsafe(value T)

Types

type Map

type Map[K comparable, V any] struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func (*Map[K, V]) Delete

func (m *Map[K, V]) Delete(key K)

func (*Map[K, V]) DeleteUnsafe

func (m *Map[K, V]) DeleteUnsafe(key K)

func (*Map[K, V]) Get

func (m *Map[K, V]) Get(key K) (V, bool)

func (*Map[K, V]) GetUnsafe

func (m *Map[K, V]) GetUnsafe(key K) (V, bool)

func (*Map[K, V]) Set

func (m *Map[K, V]) Set(key K, value V)

func (*Map[K, V]) SetUnsafe

func (m *Map[K, V]) SetUnsafe(key K, value V)

type Slice

type Slice[T comparable] struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func (*Slice[T]) Append

func (s *Slice[T]) Append(elems ...T)

func (*Slice[T]) AppendUnsafe

func (s *Slice[T]) AppendUnsafe(elems ...T)

func (*Slice[T]) DeleteStable

func (s *Slice[T]) DeleteStable(i int)

Preserves order

func (*Slice[T]) DeleteStableUnsafe

func (s *Slice[T]) DeleteStableUnsafe(i int)

Preserves order

func (*Slice[T]) DeleteUnstable

func (s *Slice[T]) DeleteUnstable(i int)

Doesn't preserve order

func (*Slice[T]) DeleteUnstableUnsafe

func (s *Slice[T]) DeleteUnstableUnsafe(i int)

Doesn't preserve order

func (*Slice[T]) Get

func (s *Slice[T]) Get(i int) T

func (*Slice[T]) GetUnsafe

func (s *Slice[T]) GetUnsafe(i int) T

func (*Slice[T]) In

func (s *Slice[T]) In(elem T) bool

func (*Slice[T]) InUnsafe

func (s *Slice[T]) InUnsafe(elem T) bool

func (*Slice[T]) Len

func (s *Slice[T]) Len() int

func (*Slice[T]) LenUnsafe

func (s *Slice[T]) LenUnsafe() int

func (*Slice[T]) Set

func (s *Slice[T]) Set(i int, value T)

func (*Slice[T]) SetUnsafe

func (s *Slice[T]) SetUnsafe(i int, value T)

type Value

type Value[T any] struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func (*Value[T]) Get

func (v *Value[T]) Get() T

func (*Value[T]) GetUnsafe

func (v *Value[T]) GetUnsafe() T

func (*Value[T]) Set

func (v *Value[T]) Set(value T)

func (*Value[T]) SetUnsafe

func (v *Value[T]) SetUnsafe(value T)