kern/v4/lev0/lev0.go

// package lev0 -- сущности уровня 0
package lev0

import (
	"gitp78su.ipnodns.ru/svi/kern/v4/lev0/defs"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev0/defs/safe_chan"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev0/helpers"
)

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

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

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

// LetBool -- возвращает новое внутреннее логическое значение.
func LetBool(val Bool) *LBool {
	return defs.LetBool(val)
}

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

// MutBool -- возвращает новый изменяемый Bool.
func MutBool(val Bool) *MBool {
	return defs.MutBool(val)
}

// Time -- внутреннее время.
type Time = defs.Time

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

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

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

func MutTimeAuto() *MTime {
	return defs.MutTimeAuto()
}

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

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

// LetNum -- возвращает новое внутреннее неизменяемое число.
func LetNum(val Num) *LNum {
	return defs.LetNum(val)
}

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

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

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

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

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

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

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

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

// Result — обёртка вокруг результата с возможной ошибкой.
type Result[T any] = defs.Result[T]

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

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

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

// Option — обёртка вокруг результата с возможной пустотой.
type Option[T any] = defs.Option[T]

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

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

// AssertAction -- хранит состояние для проверки.
type AssertAction[T ~bool] = helpers.AssertAction[T]

// If -- условие для проверки.
func If[T ~bool](isOk T) *AssertAction[T] {
	return helpers.If(isOk)
}

// SleepMs -- задержка в миллисекундах.
func SleepMs() {
	helpers.SleepMs()
}

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

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

// SafeChan -- умный безопасный канал.
type SafeChan[T any] = safe_chan.SafeChan[T]

// safe_chan.SafeChanParam[T]
type SafeChanParam[T any] = safe_chan.SafeChanParam[T]

func MutSafeChan[T any](param *safe_chan.SafeChanParam[T]) *SafeChan[T] {
	return safe_chan.MutSafeChan(param)
}

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

// BucketName -- имя сущности.
type BucketName = defs.BucketName

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

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

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

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

// MutSafeNum -- возвращает новое потокобезопасное число.
func MutSafeNum(val Num) *MSafeNum {
	val_ := defs.MutSafeNum(val)
	return val_
}

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

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

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

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

// MutSafeBool -- возвращает новый потокобезопасный булевый признак.
func MutSafeBool(val Bool) *MSafeBool {
	sf := defs.MutSafeBool(val)
	return sf
}

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

// MutSafeBoolReact -- возвращает новую потокобезопасную реактивную булеву переменную.
func MutSafeBoolReact() *MSafeBoolReact {
	val := defs.MutSafeBoolReact()
	return val
}

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

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