kern/v4/d0/defs/defs.go

// package defs -- предметные типы ядра.
package defs

import (
	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/def_bool"
	"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_time"
	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/def_txt"
	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/safe_bool"
	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/safe_bool_react"
	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/safe_mutex"
	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/safe_num"
	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/safe_txt"
	"gitp78su.ipnodns.ru/svi/kern/v4/d0/defs/table/owner"
	"gitp78su.ipnodns.ru/svi/kern/v4/d0/option"
	"gitp78su.ipnodns.ru/svi/kern/v4/d0/result"
)

// Bool -- внутренне представление логического значения.
type Bool = def_spec_base.Bool

// LBool -- неизменяемое булево значение.
type LBool = def_bool.LBool

//BoolConstraint -- ограничение внутреннего логического значения.
type BoolConstraint = def_spec_base.BoolConstraint

// LetBool -- возвращает новое внутреннее логическое значение.
func LetBool[T BoolConstraint](owner *LOwner, val T) *LBool {
	return def_bool.LetBool(owner, val)
}

// MBool -- изменяемое булево значение.
type MBool = def_bool.MBool

// MutBool -- возвращает новый изменяемый Bool.
func MutBool[T BoolConstraint](owner *LOwner, val T) *MBool {
	return def_bool.MutBool(owner, val)
}

// Num -- внутренне представление числа.
type Num = def_spec_base.Num

// LNum -- внутренне неизменяемое число.
type LNum = def_num.LNum

// LOwner -- неизменяемый владелец.
type LOwner = owner.LOwner

func LetOwner[T NumConstraint, U TxtConstraint](id T, name U) *LOwner {
	return owner.LetOwner(id, name)
}

// OwnerPass -- паспорт владельца объекта.
type OwnerPass = owner.OwnerPass

// LetNum -- возвращает новое внутреннее неизменяемое число.
func LetNum[T NumConstraint](owner *LOwner, val T) *LNum {
	return def_num.LetNum(owner, val)
}

// MNum -- внутреннее изменяемое число.
type MNum = def_num.MNum

// NumConstraint -- ограничение внутреннего целого.
type NumConstraint = def_spec_base.NumConstraint

// MutNum -- возвращает новое внутреннее изменяемое число.
func MutNum[T NumConstraint](owner *LOwner, val T) *MNum {
	return def_num.MutNum(owner, val)
}

// Txt -- внутренее представление текста.
type Txt = def_spec_base.Txt

// TxtConstraint -- разрешает строки и любые типы на его основе (например, ATxt).
type TxtConstraint = def_spec_fn.TxtConstraint

// LTxt -- внутренний неизменяемый текст.
type LTxt = def_txt.LTxt

// LetTxt -- создать новую неизменяемый текст.
func LetTxt[T TxtConstraint](msg T, arg ...any) *LTxt {
	return def_txt.LetTxt(msg, arg...)
}

// MTxt -- внутренний изменяемый текст.
type MTxt = def_txt.MTxt

// MutTxt -- создать новый внутрениий изменяемый текст.
func MutTxt[T TxtConstraint](msg T, arg ...any) *MTxt {
	return def_txt.MutTxt(msg, arg...)
}

// LErr -- внутренняя неизменяемая ошибка.
type LErr = def_err.LErr

// LetErr -- создать новую обёрнутую ошибку.
func LetErr[T TxtConstraint](msg T, arg ...any) *LErr {
	return def_err.LetErr(msg, arg...)
}

// BucketName -- имя сущности.
type BucketName *LTxt

// Result -- результат выполнения.
type Result[T any] = result.Result[T]

// ResOk -- возвращает успешный Result с значением.
func ResOk[T any](val T) *Result[T] {
	return result.ResOk(val)
}

// ResErr -- возвращает Result с ошибкой.
func ResErr[T any](err error) *Result[T] {
	return result.ResErr[T](err)
}

// WrapErr -- оборачивает существующий Result с ошибкой с новой ошибкой.
func WrapErr[T any](res *Result[T], err error) *Result[T] {
	return result.WrapErr(res, err)
}

// Option -- опциональный результат.
type Option[T any] = option.Option[T]

// NewSome -- создать новый опциональный результат.
func NewSome[T any](val T) *Option[T] {
	return option.NewSome(val)
}

// NewNone -- создать новый опциональный результат.
func NewNone[T any]() *Option[T] {
	return option.NewNone[T]()
}

// Time -- внутренее представление времени.
type Time = def_spec_base.Time

// LTime -- внутренее неизменяемое время.
//
// Вывод: "2006-01-02 15:04:05.000 -07 MST".
type LTime = def_time.LTime

// LetTimeAuto -- возвращает новое автоматическое внутреннее неизменяемое время.
//
// Вывод: "2006-01-02 15:04:05.000 -07 MST".
func LetTimeAuto() *LTime {
	return def_time.LetTimeAuto()
}

// MTime -- внутренее изменяемое время.
//
// Вывод: "2006-01-02 15:04:05.000 -07 MST".
type MTime = def_time.MTime

// MutTimeAuto -- возвращает новое автоматическое внутреннее изменяемое время.
//
// Вывод: "2006-01-02 15:04:05.000 -07 MST".
func MutTimeAuto() *MTime {
	return def_time.MutTimeAuto()
}

// Sprintf -- форматирует строку с помощью fmt.Sprintf.
func Sprintf[T TxtConstraint](val T, arg ...any) Txt {
	return def_spec_fn.Sprintf(val, arg...)
}

// Atoi -- возвращает возможное число.
func Atoi(val Txt) *Result[Num] {
	return def_spec_fn.Atoi(val)
}

// MSafeNum -- потокобезопасное число.
type MSafeNum = safe_num.MSafeNum

// MutSafeNumFromTxt -- возвращает новое потокобезопасное число из текста.
func MutSafeNumFromTxt[T TxtConstraint](owner *LOwner, strVal T) *Result[*MSafeNum] {
	return safe_num.MutSafeNumFromTxt(owner, strVal)
}

// MutSafeNumFromEnv -- возвращает новое потокобезопасное число из окружения.
func MutSafeNumFromEnv(owner *LOwner, env *LTxt) *Result[*MSafeNum] {
	return safe_num.MutSafeNumFromEnv(owner, env)
}

// MutSafeNum -- возвращает новое потокобезопасное число.
func MutSafeNum[T NumConstraint](owner *LOwner, val T) *MSafeNum {
	val_ := safe_num.MutSafeNum(owner, val)
	return val_
}

// MSafeTxt -- потокобезопасный внутренний текст.
type MSafeTxt = safe_txt.MSafeTxt

// MutSafeTxt -- возвращает новый потокобезопасный текст.
func MutSafeTxt[T TxtConstraint](txt T, arg ...any) *MSafeTxt {
	str := safe_txt.MutSafeTxt(txt, arg...)
	return str
}

// MutSafeTxt -- возвращает новый потокобезопасный текст.
func MutSafeTxtFromEnv(env *LTxt) *Result[*MSafeTxt] {
	str := safe_txt.MutSafeTxtFromEnv(env)
	return str
}

// MSafeBool -- потокобезопасный булевый признак.
type MSafeBool = safe_bool.MSafeBool

// MutSafeBool -- возвращает новый потокобезопасный булевый признак.
func MutSafeBool[T BoolConstraint](owner *owner.LOwner, val T) *MSafeBool {
	sf := safe_bool.MutSafeBool(owner, val)
	return sf
}

// MSafeBoolReact -- потокобезопасный булевый признак с реакцией на своё изменение.
type MSafeBoolReact = safe_bool_react.MSafeBoolReact

// MutSafeBoolReact -- возвращает новую потокобезопасную реактивную булеву переменную.
func MutSafeBoolReact[T BoolConstraint](owner *owner.LOwner, val T) *MSafeBoolReact {
	sf := safe_bool_react.MutSafeBoolReact(owner, val)
	return sf
}

// MSafeMutex -- безопасный мьютекс.
type MSafeMutex = safe_mutex.MSafeMutex

// MutSafeMutex -- возвращает новый потокобезопасный мьютекс.
func MutSafeMutex() *MSafeMutex {
	sf := safe_mutex.MutSafeMutex()
	return sf
}