SVI Рабочее сохранение

v4/d0/defs/def_err/def_err_let.go

@@ -24,6 +24,15 @@ func LetErr[T def_spec_fn.TxtConstraint](owner *owner.LOwner,
 	return sf
 }
 
+// WrapTxt -- возвращает обёрнутую ошибку.
+func (sf *LErr) WrapTxt[T def_spec_base.TxtConstraint](owner *owner.LOwner, err T, arg ...any) *LErr {
+	sf.CheckOwner()
+	_sf := &LErr{
+		LTxt: def_txt.LetTxt(owner, sf.Error()+"\n\t"+string(err), arg...),
+	}
+	return _sf
+}
+
 // WrapErr -- возвращает обёрнутую ошибку.
 func (sf *LErr) WrapErr(owner *owner.LOwner, err error, arg ...any) *LErr {
 	sf.CheckOwner()

v4/d0/defs/def_err/def_err_let_test.go

@@ -1,6 +1,7 @@
 package def_err
 
 import (
+	"fmt"
 	"testing"
 
 	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/table/owner"
@@ -18,6 +19,75 @@ func TestLetErr(t *testing.T) {
 		owner: owner.LetOwner(1, "test_owner"),
 	}
 	sf.let()
+	sf.wrap()
+}
+
+// Оборачивает ошибку
+func (sf *tester) wrap() {
+	sf.t.Log("wrap")
+	err := sf.err
+	sf.err = sf.err.WrapErr(sf.owner, fmt.Errorf("add err"))
+	strErr := sf.err.String()
+	_err := `LTxt(
+	OwnerPass(OwnerPass(
+	ownerDest(LOwner(
+	id(1)
+	name(test_owner)
+))
+	ownerCur(LOwner(
+	id(1)
+	name(test_owner)
+))
+))
+	Val(LTxt(
+	OwnerPass(OwnerPass(
+	ownerDest(LOwner(
+	id(1)
+	name(test_owner)
+))
+	ownerCur(LOwner(
+	id(1)
+	name(test_owner)
+))
+))
+	Val(test_good_err)
+)
+	add err)
+)`
+	if strErr != _err {
+		sf.t.Fatalf("wrap(): err=\n\t%v", strErr)
+	}
+	sf.err = err.WrapTxt(sf.owner, "456")
+	strErr = sf.err.String()
+	_err = `LTxt(
+	OwnerPass(OwnerPass(
+	ownerDest(LOwner(
+	id(1)
+	name(test_owner)
+))
+	ownerCur(LOwner(
+	id(1)
+	name(test_owner)
+))
+))
+	Val(LTxt(
+	OwnerPass(OwnerPass(
+	ownerDest(LOwner(
+	id(1)
+	name(test_owner)
+))
+	ownerCur(LOwner(
+	id(1)
+	name(test_owner)
+))
+))
+	Val(test_good_err)
+)
+	456)
+)`
+	if strErr != _err {
+		sf.t.Fatalf("wrap(): err=\n\t%v", strErr)
+	}
 }
 
 // Создание ошибки
@@ -30,6 +100,9 @@ func (sf *tester) let() {
 func (sf *tester) letGood1() {
 	sf.t.Log("letGood1")
 	sf.err = LetErr(sf.owner, "test_good_err")
+	if !sf.err.IsErr() {
+		sf.t.Fatalf("letGood1(): strErr is empty")
+	}
 }
 
 // Нет владельца для ошибка

v4/d0/defs/def_let/def_let.go

@@ -1,17 +1,29 @@
 // package def_let -- неизменяемый контейнер
 package def_let
 
+import (
+	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/table/owner"
+	"gitp78su.ipnodns.ru/svi/kern/v4/d0/helpers"
+)
+
 // Let -- неизменяемый контейнер
 type Let[T any] struct {
-	val T
+	owner *owner.LOwner
+	val   T
 }
 
 // NewLet -- возвращает новый параметрический неизменяемый контейнер
-func NewLet[T any](val T) *Let[T] {
-	return &Let[T]{val: val}
+func NewLet[T any](owner *owner.LOwner, val T) *Let[T] {
+	helpers.If(owner == nil).Hassert("NewLet(): owner==nil")
+	sf := &Let[T]{
+		owner: owner,
+		val:   val,
+	}
+	return sf
 }
 
 // Get -- возвращает хранимое значение
-func (l *Let[T]) Get() T {
-	return l.val
+func (sf *Let[T]) Get() T {
+	sf.owner.Pass().CheckOwner()
+	return sf.val
 }

v4/d0/defs/def_let/def_let_test.go

@@ -0,0 +1,29 @@
+package def_let
+
+import (
+	"testing"
+
+	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/table/owner"
+)
+
+type tester struct {
+	t     *testing.T
+	owner *owner.LOwner
+}
+
+func TestLet(t *testing.T) {
+	sf := &tester{
+		t:     t,
+		owner: owner.LetOwner(1, "test_owner"),
+	}
+	sf.new()
+}
+
+// Возвращает новый контейнер неизменяемости
+func (sf *tester) new() {
+	sf.t.Log("new")
+	val := NewLet(sf.owner, 5)
+	if val.Get() != 5 {
+		sf.t.Fatalf("new(): val(%v)!=5", val.Get())
+	}
+}

v4/d0/defs/def_move/def_move.go

@@ -5,13 +5,13 @@ import (
 	"reflect"
 
 	"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/table/owner"
 	"gitp78su.ipnodns.ru/svi/kern/v4/d0/helpers"
 )
 
 // Move -- параметрический контейнер с семантикой перемещения
 type Move[T any] struct {
-	type_ def_spec_base.Txt
+	owner *owner.LOwner
 	val   *T // Фактическое значение
 }
 
@@ -20,7 +20,8 @@ const (
 )
 
 // NewMove -- возвращает новый параметрический контейнер с семантикой перемещения
-func NewMove[T any](val T) *Move[T] {
+func NewMove[T any](owner *owner.LOwner, val T) *Move[T] {
+	helpers.If(owner == nil).Hassert("NewMove[%T](): owner==nil", val)
 	v := reflect.ValueOf(val)
 	switch v.Kind() {
 	case reflect.Pointer, reflect.Slice, reflect.Map, reflect.Chan, reflect.Func, reflect.Interface:
@@ -28,14 +29,15 @@ func NewMove[T any](val T) *Move[T] {
 		helpers.If(isNil).Hassert(str5)
 	}
 	sf := &Move[T]{
+		owner: owner,
 		val:   &val,
-		type_: def_spec_fn.Sprintf("%T", val),
 	}
 	return sf
 }
 
 // Set -- устанавливает внутреннее значение
 func (sf *Move[T]) Set(val T) {
+	sf.owner.Pass().CheckOwner()
 	v := reflect.ValueOf(val)
 	switch v.Kind() {
 	case reflect.Pointer, reflect.Slice, reflect.Map, reflect.Chan, reflect.Func, reflect.Interface:
@@ -47,9 +49,10 @@ func (sf *Move[T]) Set(val T) {
 
 // Move -- перемещает другому владельцу хранимое значение
 func (sf *Move[T]) Move() T {
+	sf.owner.Pass().CheckOwner()
 	defer func() {
 		sf.val = nil
 	}()
-	helpers.If(sf.val == nil).Hassert("Box.Move[%v]: val already moved", sf.type_)
+	helpers.If(sf.val == nil).Hassert("Box.Move[%T]: val already moved", sf.val)
 	return *sf.val
 }

v4/d0/defs/def_move/dev_move_test.go

@@ -0,0 +1,32 @@
+package def_move
+
+import (
+	"testing"
+
+	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/def_spec_base"
+	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/table/owner"
+)
+
+type tester struct {
+	t     *testing.T
+	owner *owner.LOwner
+	val   *Move[def_spec_base.Num]
+}
+
+func TestMove(t *testing.T) {
+	sf := &tester{
+		t:     t,
+		owner: owner.LetOwner(1, "test_owner"),
+	}
+	sf.new()
+}
+
+// Возвращает новый контейнер перемещения
+func (sf *tester) new() {
+	sf.t.Log("new")
+	val := NewMove(sf.owner, 7)
+	_val := val.Move()
+	if _val != 7 {
+		sf.t.Fatalf("new(): val(%v)!=7", _val)
+	}
+}

v4/d0/defs/def_mut/def_mut.go

@@ -1,22 +1,35 @@
 // package def_mut -- параметрический изменяемый контейнер
 package def_mut
 
+import (
+	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/table/owner"
+	"gitp78su.ipnodns.ru/svi/kern/v4/d0/helpers"
+)
+
 // Mut -- параметрический изменяемый контейнер
 type Mut[T any] struct {
-	val T
+	owner *owner.LOwner
+	val   T
 }
 
 // NewMut -- возвращает новый параметрический изменяемый контейнер
-func NewMut[T any](val T) *Mut[T] {
-	return &Mut[T]{val: val}
+func NewMut[T any](owner *owner.LOwner, val T) *Mut[T] {
+	helpers.If(owner == nil).Hassert("NewMut(): owner==nil")
+	sf := &Mut[T]{
+		owner: owner,
+		val:   val,
+	}
+	return sf
 }
 
 // Get -- возвращает хранимое значение
 func (sf *Mut[T]) Get() T {
+	sf.owner.Pass().CheckOwner()
 	return sf.val
 }
 
 // Set -- устанавливает хранимое значение
 func (sf *Mut[T]) Set(val T) {
+	sf.owner.Pass().CheckOwner()
 	sf.val = val
 }

v4/d0/defs/def_mut/def_mut_test.go

@@ -0,0 +1,35 @@
+package def_mut
+
+import (
+	"testing"
+
+	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/table/owner"
+)
+
+type tester struct {
+	t     *testing.T
+	owner *owner.LOwner
+}
+
+func TestMut(t *testing.T) {
+	sf := &tester{
+		t:     t,
+		owner: owner.LetOwner(1, "test_owner"),
+	}
+	sf.new()
+}
+
+// Создаёт новый контейнер
+func (sf *tester) new() {
+	sf.t.Log("new")
+	val := NewMut(sf.owner, 6)
+	_val := val.Get()
+	if _val != 6 {
+		sf.t.Fatalf("new(): val(%v)!=6", _val)
+	}
+	val.Set(5)
+	_val = val.Get()
+	if _val != 5 {
+		sf.t.Fatalf("new(): val(%v)!=5", _val)
+	}
+}

v4/d0/defs/def_time/def_time_mut.go

@@ -10,7 +10,7 @@ import (
 	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/def_spec_fn"
 	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/table/owner"
 	"gitp78su.ipnodns.ru/svi/kern/v4/d0/helpers"
-	"gitp78su.ipnodns.ru/svi/kern/v4/d0/option"
+	"gitp78su.ipnodns.ru/svi/kern/v4/d0/result"
 	"gitp78su.ipnodns.ru/svi/kern/v4/d0/tuf"
 )
 
@@ -19,13 +19,16 @@ import (
 // Вывод: "2006-01-02 15:04:05.000 -07 MST".
 type MTime struct {
 	*def_mut.Mut[def_spec_base.Time]
+	owner *owner.LOwner
 }
 
 // MutTime -- возвращает новое внутреннее изменяемое время.
-func MutTime[T def_spec_fn.TxtConstraint](val T) *MTime {
+func MutTime[T def_spec_fn.TxtConstraint](owner *owner.LOwner, val T) *MTime {
+	helpers.If(owner == nil).Hassert("MutTime(): owner==nil")
 	helpers.If(val == "").Hassert("MutTime(): val is empty")
 	sf := &MTime{
-		Mut: def_mut.NewMut(def_spec_base.Time(val)),
+		Mut:   def_mut.NewMut(owner, def_spec_base.Time(val)),
+		owner: owner,
 	}
 	return sf
 }
@@ -33,23 +36,24 @@ func MutTime[T def_spec_fn.TxtConstraint](val T) *MTime {
 // MutTimeAuto -- возвращает новое автоматическое внутреннее изменяемое время.
 //
 // Вывод: "2006-01-02 15:04:05.000 -07 MST".
-func MutTimeAuto() *MTime {
+func MutTimeAuto(owner *owner.LOwner) *MTime {
 	_val := time.Now().Local().Format("2006-01-02 15:04:05.000 -07 MST")
 	val := def_spec_base.Time(_val)
 	sf := &MTime{
-		Mut: def_mut.NewMut(val),
+		Mut:   def_mut.NewMut(owner, val),
+		owner: owner,
 	}
 	return sf
 }
 
 // MutTimeFromTuf -- десериализует из def_spec_base.ATxt в строки.
-func MutTimeFromTuf(owner *owner.LOwner, txtMsg def_spec_base.Txt) *option.Option[*def_err.LErr] {
+func MutTimeFromTuf(owner *owner.LOwner, txtMsg def_spec_base.Txt) *result.Result[def_spec_base.Txt] {
 	resRec := tuf.RecFromTuf(owner, "ETime", txtMsg) // Получить текст записи
 	if resRec.IsErr() {
 		err := def_err.LetErr(owner, "MutTimeFromTuf(): in extract record from TUF, err=\n\t%v", resRec.Error())
-		return option.NewSome(err)
+		return result.ResErr[def_spec_base.Txt](err)
 	}
-	return option.NewNone[*def_err.LErr]()
+	return resRec
 }
 
 // Get -- получить время.

v4/d0/defs/defs.go

@@ -160,8 +160,8 @@ type MTime = def_time.MTime
 // MutTimeAuto -- возвращает новое автоматическое внутреннее изменяемое время.
 //
 // Вывод: "2006-01-02 15:04:05.000 -07 MST".
-func MutTimeAuto() *MTime {
-	return def_time.MutTimeAuto()
+func MutTimeAuto(owner *LOwner) *MTime {
+	return def_time.MutTimeAuto(owner)
 }
 
 // Sprintf -- форматирует строку с помощью fmt.Sprintf.
@@ -212,7 +212,7 @@ func MutSafeTxtFromEnv(owner *LOwner, env *LTxt) *Result[*MSafeTxt] {
 type MSafeBool = safe_bool.MSafeBool
 
 // MutSafeBool -- возвращает новый потокобезопасный булевый признак.
-func MutSafeBool[T BoolConstraint](owner *owner.LOwner, val T) *MSafeBool {
+func MutSafeBool[T BoolConstraint](owner *LOwner, val T) *MSafeBool {
 	sf := safe_bool.MutSafeBool(owner, val)
 	return sf
 }
@@ -221,7 +221,7 @@ func MutSafeBool[T BoolConstraint](owner *owner.LOwner, val T) *MSafeBool {
 type MSafeBoolReact = safe_bool_react.MSafeBoolReact
 
 // MutSafeBoolReact -- возвращает новую потокобезопасную реактивную булеву переменную.
-func MutSafeBoolReact[T BoolConstraint](owner *owner.LOwner, val T) *MSafeBoolReact {
+func MutSafeBoolReact[T BoolConstraint](owner *LOwner, val T) *MSafeBoolReact {
 	sf := safe_bool_react.MutSafeBoolReact(owner, val)
 	return sf
 }

v4/d0/depth0.go

@@ -52,8 +52,9 @@ func LetTimeAuto() *LTime {
 // Вывод: "2006-01-02 15:04:05.000 -07 MST".
 type MTime = defs.MTime
 
-func MutTimeAuto() *MTime {
-	return defs.MutTimeAuto()
+// MutTimeAuto -- автоматическое изменяемое время
+func MutTimeAuto(owner *LOwner) *MTime {
+	return defs.MutTimeAuto(owner)
 }
 
 // Num -- внутренне представление числа.

v4/d1/local_ctx/ctx_value/ctx_value.go

@@ -23,7 +23,7 @@ func NewCtxValue[T d0.TxtConstraint](owner *owner.LOwner, key d0.Txt, val any, c
 		MSafeMutex: d0.MutSafeMutex(),
 		key:        d0.LetTxt(owner, key),
 		createAt:   d0.LetTimeAuto(),
-		UpdateAt_:  d0.MutTimeAuto(),
+		UpdateAt_:  d0.MutTimeAuto(owner),
 		Val_:       val,
 		Comment_:   d0.LetTxt(owner, comment),
 	}

v4/d1/local_ctx/local_ctx.go

@@ -104,7 +104,7 @@ func (sf *LocalCtx) Set(key *d0.LTxt, val any, comment d0.Txt) {
 	_val, isOk := sf.dictVal[key.Get()]
 	if isOk {
 		_val.Lock()
-		_val.UpdateAt_ = d0.MutTimeAuto()
+		_val.UpdateAt_ = d0.MutTimeAuto(sf.owner)
 		_val.Val_ = val
 		_val.Unlock()
 		return

v4/d2/lsi/kstore_kv_std/kv_bucket_base/kv_bucket_base.go

@@ -19,6 +19,7 @@ import (
 // Он должен быть разумным значением (например, до 100 МБ).
 // Как только бакет заполнится, он будет вытеснен на диск.
 type KvBucketBase struct {
+	owner      *d0.LOwner
 	Name_      *d0.LTxt                             `json:"name"`       // Имя бакета
 	Level_     d0.Num                               `json:"level"`      // Уровень бакета
 	Number_    d0.Num                               `json:"num"`        // Номер бакета
@@ -31,17 +32,19 @@ type KvBucketBase struct {
 }
 
 // NewKvBucketBase -- создание нового базового бакета хранилища KV.
-func NewKvBucketBase(name *d0.LTxt, level, number d0.Num) *KvBucketBase {
-	d0.If(name.Get() == "").Hassert("NewKvBucketBase: name is empty", []any{})
-	d0.If(level < 0).Hassert("NewKvBucketBase: level is negative", []any{})
-	d0.If(number < 0).Hassert("NewKvBucketBase: number is negative", []any{})
+func NewKvBucketBase(owner *d0.LOwner, name *d0.LTxt, level, number d0.Num) *KvBucketBase {
+	d0.If(owner == nil).Hassert("NewKvBucketBase: owner==nil")
+	d0.If(name.Get() == "").Hassert("NewKvBucketBase: name is empty")
+	d0.If(level < 0).Hassert("NewKvBucketBase: level is negative")
+	d0.If(number < 0).Hassert("NewKvBucketBase: number is negative")
 	sf := &KvBucketBase{
+		owner:      owner,
 		Name_:      name,
 		Level_:     level,
 		Number_:    number,
 		dictRec:    map[rec_key.ARecKey]rec_kv.IRecKvFix{},
 		CreatedAt_: d0.LetTimeAuto(),
-		UpdatedAt_: d0.MutTimeAuto(),
+		UpdatedAt_: d0.MutTimeAuto(owner),
 	}
 	return sf
 }

v4/d2/lsi/store_ent/rec_meta/rec_meta.go

@@ -46,7 +46,7 @@ func NewRecMeta(owner *d0.LOwner, key rec_key.IRecKeyFix) *RecMeta {
 		Vers_:      1,
 		Operation_: d0.LetTxt(owner, "create"),
 		createdAt_: d0.LetTimeAuto(),
-		updateAt_:  d0.MutTimeAuto(),
+		updateAt_:  d0.MutTimeAuto(owner),
 	}
 	_ = IRecMeta(sf)
 	return sf