clone from danieldin95

pkg/libol/safe.go

@@ -0,0 +1,271 @@
+package libol
+
+import "sync"
+
+//m := NewSafeStrStr(1024)
+//m.Set("hi", "1")
+//a := "3"
+//m.Set("hip", a)
+//c := m.Get("hip")
+//fmt.Printf("%s\n%s\n", m, c)
+
+type SafeStrStr struct {
+	size int
+	data map[string]string
+	lock sync.RWMutex
+}
+
+func NewSafeStrStr(size int) *SafeStrStr {
+	calSize := size
+	if calSize == 0 {
+		calSize = 128
+	}
+	return &SafeStrStr{
+		size: size,
+		data: make(map[string]string, calSize),
+	}
+}
+
+func (sm *SafeStrStr) Len() int {
+	sm.lock.RLock()
+	defer sm.lock.RUnlock()
+	return len(sm.data)
+}
+
+func (sm *SafeStrStr) Reset(k, v string) error {
+	sm.lock.Lock()
+	defer sm.lock.Unlock()
+
+	if sm.size != 0 && len(sm.data) >= sm.size {
+		return NewErr("SafeStrStr.Set already full")
+	}
+	sm.data[k] = v
+	return nil
+}
+
+func (sm *SafeStrStr) Set(k, v string) error {
+	sm.lock.Lock()
+	defer sm.lock.Unlock()
+
+	if sm.size != 0 && len(sm.data) >= sm.size {
+		return NewErr("SafeStrStr.Set already full")
+	}
+	if _, ok := sm.data[k]; !ok {
+		sm.data[k] = v
+	}
+	return nil
+}
+
+func (sm *SafeStrStr) Del(k string) {
+	sm.lock.Lock()
+	defer sm.lock.Unlock()
+
+	if _, ok := sm.data[k]; ok {
+		delete(sm.data, k)
+	}
+}
+
+func (sm *SafeStrStr) Get(k string) string {
+	sm.lock.RLock()
+	defer sm.lock.RUnlock()
+	return sm.data[k]
+}
+
+func (sm *SafeStrStr) GetEx(k string) (string, bool) {
+	sm.lock.RLock()
+	defer sm.lock.RUnlock()
+	v, ok := sm.data[k]
+	return v, ok
+}
+
+func (sm *SafeStrStr) Iter(proc func(k, v string)) int {
+	sm.lock.RLock()
+	defer sm.lock.RUnlock()
+
+	count := 0
+	for k, u := range sm.data {
+		if k != "" {
+			proc(k, u)
+			count += 1
+		}
+	}
+	return count
+}
+
+type SafeStrMap struct {
+	size int
+	data map[string]interface{}
+	lock sync.RWMutex
+}
+
+func NewSafeStrMap(size int) *SafeStrMap {
+	calSize := size
+	if calSize == 0 {
+		calSize = 128
+	}
+	return &SafeStrMap{
+		size: size,
+		data: make(map[string]interface{}, calSize),
+	}
+}
+
+func (sm *SafeStrMap) Len() int {
+	sm.lock.RLock()
+	defer sm.lock.RUnlock()
+	return len(sm.data)
+}
+
+func (sm *SafeStrMap) add(k string, v interface{}) error {
+	if sm.size != 0 && len(sm.data) >= sm.size {
+		return NewErr("SafeStrMap.Set already full")
+	}
+	if _, ok := sm.data[k]; !ok {
+		sm.data[k] = v
+	}
+	return nil
+}
+
+func (sm *SafeStrMap) Set(k string, v interface{}) error {
+	sm.lock.Lock()
+	defer sm.lock.Unlock()
+
+	return sm.add(k, v)
+}
+
+func (sm *SafeStrMap) Mod(k string, v interface{}) error {
+	sm.lock.Lock()
+	defer sm.lock.Unlock()
+
+	if _, ok := sm.data[k]; !ok {
+		return sm.add(k, v)
+	}
+	sm.data[k] = v
+	return nil
+}
+
+func (sm *SafeStrMap) Del(k string) {
+	sm.lock.Lock()
+	defer sm.lock.Unlock()
+
+	if _, ok := sm.data[k]; ok {
+		delete(sm.data, k)
+	}
+}
+
+func (sm *SafeStrMap) Clear() {
+	sm.lock.Lock()
+	defer sm.lock.Unlock()
+	sm.data = make(map[string]interface{}, sm.size)
+}
+
+func (sm *SafeStrMap) Get(k string) interface{} {
+	sm.lock.RLock()
+	defer sm.lock.RUnlock()
+	return sm.data[k]
+}
+
+func (sm *SafeStrMap) GetEx(k string) (interface{}, bool) {
+	sm.lock.RLock()
+	defer sm.lock.RUnlock()
+	v, ok := sm.data[k]
+	return v, ok
+}
+
+func (sm *SafeStrMap) Iter(proc func(k string, v interface{})) int {
+	sm.lock.RLock()
+	defer sm.lock.RUnlock()
+
+	count := 0
+	for k, u := range sm.data {
+		if u != nil {
+			proc(k, u)
+			count += 1
+		}
+	}
+	return count
+}
+
+// a := SafeVar
+// a.Set(0x01)
+// a.Get().(int)
+
+type SafeVar struct {
+	data interface{}
+	lock sync.RWMutex
+}
+
+func NewSafeVar() *SafeVar {
+	return &SafeVar{}
+}
+
+func (sv *SafeVar) Set(v interface{}) {
+	sv.lock.Lock()
+	defer sv.lock.Unlock()
+	sv.data = v
+}
+
+func (sv *SafeVar) Get() interface{} {
+	sv.lock.RLock()
+	defer sv.lock.RUnlock()
+	return sv.data
+}
+
+func (sv *SafeVar) GetWithFunc(proc func(v interface{})) {
+	sv.lock.RLock()
+	defer sv.lock.RUnlock()
+	proc(sv.data)
+}
+
+type SafeStrInt64 struct {
+	lock sync.RWMutex
+	data map[string]int64
+}
+
+func NewSafeStrInt64() *SafeStrInt64 {
+	return &SafeStrInt64{
+		data: make(map[string]int64, 32),
+	}
+}
+
+func (s *SafeStrInt64) Get(k string) int64 {
+	s.lock.RLock()
+	defer s.lock.RUnlock()
+	if v, ok := s.data[k]; ok {
+		return v
+	}
+	return 0
+}
+
+func (s *SafeStrInt64) Set(k string, v int64) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+	s.data[k] = v
+}
+
+func (s *SafeStrInt64) Add(k string, v int64) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+	if _, ok := s.data[k]; ok {
+		s.data[k] += v
+	} else {
+		s.data[k] = v
+	}
+}
+
+func (s *SafeStrInt64) Copy(dst map[string]int64) {
+	s.lock.RLock()
+	defer s.lock.RUnlock()
+	for k, v := range s.data {
+		dst[k] = v
+	}
+}
+
+func (s *SafeStrInt64) Data() map[string]int64 {
+	s.lock.RLock()
+	defer s.lock.RUnlock()
+	dst := make(map[string]int64, 32)
+	for k, v := range s.data {
+		dst[k] = v
+	}
+	return dst
+}