kern/v4/d0/defs/safe_num/safe_num.go

// package safe_num -- потокобезопасный число.
package safe_num

import (
	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/def_err"
	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/def_num"
	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/def_spec_base"
	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/def_spec_fn"
	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/def_txt"
	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/safe_mutex"
	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/table/owner"
	"gitp78su.ipnodns.ru/svi/kern/v4/d0/result"
)

// MSafeNum -- потокобезопасное число.
type MSafeNum struct {
	*safe_mutex.MSafeMutex
	val *def_num.MNum
}

// MutSafeNum -- возвращает новое потокобезопасное число.
func MutSafeNum[T def_spec_base.NumConstraint](owner *owner.LOwner, val T) *MSafeNum {
	sf := &MSafeNum{
		MSafeMutex: safe_mutex.MutSafeMutex(),
		val:        def_num.MutNum(owner, val),
	}
	return sf
}

// MutSafeNumFromTxt -- возвращает новое потокобезопасное число из текста.
func MutSafeNumFromTxt[T def_spec_base.TxtConstraint](owner *owner.LOwner, txtVal T) *result.Result[*MSafeNum] {
	res := def_spec_fn.Atoi(def_spec_base.Txt(txtVal))
	if res.IsErr() {
		err := def_err.LetErr(owner, "MutSafeNumFromTxt(): in parse str(%v), err=\n\t%w", txtVal, res.Err())
		return result.ResErr[*MSafeNum](err)
	}
	_val := MutSafeNum(owner, res.Ok())
	return result.ResOk(_val)
}

// MutSafeNumFromEnv -- возвращает новое потокобезопасное число из окружения.
func MutSafeNumFromEnv(owner *owner.LOwner, env *def_txt.LTxt) *result.Result[*MSafeNum] {
	sf := MutSafeNum(owner, 0)
	res := sf.FromEnv(env)
	if res.IsErr() {
		err := def_err.LetErr(owner, "MutSafeNumFromEnv(): in parse env(%v), err=\n\t%w", env, res.Err())
		return result.ResErr[*MSafeNum](err)
	}
	return result.ResOk(sf)
}

// FromBool -- устанавливает значение из булева значения.
func (sf *MSafeNum) FromBool(val def_spec_base.Bool) def_spec_base.Num {
	sf.Lock()
	defer sf.Unlock()
	if val {
		sf.val.Set(1)
		return 1
	}
	sf.val.Set(0)
	return 0
}

// Get -- возвращает хранимое число.
func (sf *MSafeNum) Get() def_spec_base.Num {
	sf.RLock()
	defer sf.RUnlock()
	return sf.val.Get()
}

// Dec -- уменьшает значение на 1.
func (sf *MSafeNum) Dec() {
	sf.Lock()
	defer sf.Unlock()
	sf.val.Dec()
}

// Inc -- увеличивает значение на 1.
func (sf *MSafeNum) Inc() {
	sf.Lock()
	defer sf.Unlock()
	sf.val.Inc()
}

// Set -- устанавливает число.
func (sf *MSafeNum) Set(val def_spec_base.Num) {
	sf.Lock()
	defer sf.Unlock()
	sf.val.Set(val)
}

// Reset -- сбрасывает число.
func (sf *MSafeNum) Reset() {
	sf.Lock()
	defer sf.Unlock()
	sf.val.Reset()
}

// FromTxt -- получает число из текста.
func (sf *MSafeNum) FromTxt(txtVal *def_txt.LTxt) *result.Result[def_spec_base.Num] {
	sf.Lock()
	defer sf.Unlock()
	res := sf.val.FromTxt(txtVal)
	if res.IsErr() {
		err := def_err.LetErr(sf.val.Owner(),
			"MSafeInt.FromStr(): form str(%v) to int, err=\n\t%v",
			txtVal, res.Error())
		return result.ResErr[def_spec_base.Num](err)
	}
	return result.ResOk(sf.val.Get())
}

// FromByte -- получает число из среза байт.
func (sf *MSafeNum) FromByte(binData []byte) *result.Result[def_spec_base.Num] {
	sf.Lock()
	defer sf.Unlock()
	res := sf.val.FromByte(binData)
	if res.IsErr() {
		err := def_err.LetErr(sf.val.Owner(),
			"MSafeInt.FromByte(): form binData(%v) to int",
			binData, res.Error())
		return result.ResErr[def_spec_base.Num](err)
	}
	return result.ResOk(sf.val.Get())
}

// ToByte -- конвертирует число в срез байт.
func (sf *MSafeNum) ToByte() []byte {
	sf.RLock()
	defer sf.RUnlock()
	return sf.val.ToByte()
}

// ToBool -- конвертирует число в bool.
func (sf *MSafeNum) ToBool() def_spec_base.Bool {
	sf.RLock()
	defer sf.RUnlock()
	return sf.val.ToBool()
}

// Txt -- конвертирует число в текст.
func (sf *MSafeNum) Txt() *def_txt.LTxt {
	sf.RLock()
	defer sf.RUnlock()
	return sf.val.Txt()
}

// FromEnv -- получает значение из окружения.
func (sf *MSafeNum) FromEnv(env *def_txt.LTxt) *result.Result[*def_num.LNum] {
	sf.Lock()
	defer sf.Unlock()
	return sf.val.FromEnv(env)
}