go
/
active3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

partialField dandole mayor responsabilidad al hacerlo generico

Browse Source
master
DEV 2 years ago
parent 431371070b
commit e258650aa7
17 changed files with 220 additions and 454 deletions
Show Stats Download Patch File Download Diff File

9
A/main.go
Unescape View File

@ -3,6 +3,8 @@ package main
import (
"aflds"
"fmt"
"math/rand"
"time"
)
type (
@ -17,14 +19,17 @@ func Una () S {
return S { A : "Un valiue" }
}
func randomInt(min, max int) int {
rand.Seed(time.Now().UnixNano()) // Semilla para generar números aleatorios únicos
return rand.Intn(max-min+1) + min
}
func main() {
doInt := *aflds.NewDOFieldInt("Mi",func()int{ return 22 })
doInt := aflds.NewDFieldInt("Mi",func()int{ return randomInt(1, 100000) })
fmt.Printf("1 - %v\n",doInt.Value())

91
AATest/dofield_test.go
Unescape View File

@ -1,91 +0,0 @@
// ------------------------------------------------------------------------
// ℹ️ Project active3
// 🔗 Active Thing (activething.com) git.activething.com/go
//
// File name dofield_test.go
// ✍️ Created by DEV
// 📅 Modified 03/05/2024
//
// 🔒 Copyright 2024 activething.com
//
// 📜 LICENSE --------------------------------------------------------------
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ------------------------------------------------------------------------
package AATest
import (
"aflds"
"testing"
)
func BenchmarkNewDOFieldInt(b *testing.B) {
valueFn := func() int {
return 42
}
for i := 0; i < b.N; i++ {
aflds.NewDOFieldInt("test", valueFn)
}
}
func BenchmarkNewDOFieldInt2(b *testing.B) {
valueFn := func() int {
return 42
}
for i := 0; i < b.N; i++ {
aflds.NewDOFieldInt2("test", valueFn)
}
}
func BenchmarkAccessValueFn(b *testing.B) {
valueFn := func() int {
return 42
}
f := aflds.NewDOFieldInt("test", valueFn)
for i := 0; i < b.N; i++ {
f.Value()
}
}
func BenchmarkAccessValueFn2(b *testing.B) {
valueFn := func() int {
return 42
}
f := aflds.NewDOFieldInt2("test", valueFn)
for i := 0; i < b.N; i++ {
f.Value()
}
}
func BenchmarkAccessValue(b *testing.B) {
valueFn := func() int {
return 42
}
f := aflds.NewDOFieldInt("test", valueFn)
for i := 0; i < b.N; i++ {
f.Value()
}
}
func BenchmarkAccessValue2(b *testing.B) {
valueFn := func() int {
return 42
}
f := aflds.NewDOFieldInt2("test", valueFn)
for i := 0; i < b.N; i++ {
f.Value()
}
}

48
core/aflds/field_any.go
Unescape View File

@ -32,62 +32,46 @@ import (
type (
FieldAny struct {
valuer[any]
partialField
valuerMode
value *any
valueFn func() any
}
)
func NewFieldAny (name string, value any) *FieldAny {
return &FieldAny{
partialField : makePartialField(name),
valuerMode : localValuer{},
value : &value } }
valuer: newLocalValuer[any](value),
partialField : makePartialField(name) } }
func NewDFieldAny (name string, valueFn func() any) *FieldAny {
if valueFn == nil {
panic(G.ErrInvalidDeferFunc)
}
return &FieldAny{
partialField: makePartialField(name),
valuerMode: deferValuer{},
valueFn : valueFn,
}
}
valuer: newDeferValuer[any](valueFn),
partialField: makePartialField(name) } }
func (f FieldAny) Kind() Kind {
return KindAny | f.valuerKind() }
func (f FieldAny) Value() any {
if f.isLocal() {
return *f.value
}
return f.valueFn()
}
func (f FieldAny) Bool () (bool,bool) {
v,ok := f.Value().(bool)
v,ok := f.native().(bool)
return v,ok
}
func (f FieldAny) Binary () ([]byte,bool) {
v, ok := f.Value().([]byte)
v, ok := f.native().([]byte)
return v, ok
}
func (f FieldAny) String () (string,bool) {
v,ok := f.Value().(string)
v,ok := f.native().(string)
return v,ok
}
func (f FieldAny) Int () (int,bool) {
switch t := f.Value().(type) {
switch t := f.native().(type) {
case int : return t,true
case int8 : return int(t),true
case int16: return int(t),true
@ -98,7 +82,7 @@ func (f FieldAny) Int () (int,bool) {
}
func (f FieldAny) Uint () (uint,bool) {
switch t := f.Value().(type) {
switch t := f.native().(type) {
case uint : return t,true
case uint8 : return uint(t),true
case uint16: return uint(t),true
@ -109,7 +93,7 @@ func (f FieldAny) Uint () (uint,bool) {
}
func (f FieldAny) Float () (float64,bool) {
vl := f.Value()
vl := f.native()
v, ok := vl.(float64)
if !ok {
var f32 float32
@ -122,24 +106,24 @@ func (f FieldAny) Float () (float64,bool) {
func (f FieldAny) Date () (time.Time,bool) {
v, ok := f.Value().(time.Time)
v, ok := f.native().(time.Time)
return v, ok
}
func (f FieldAny) Time () (time.Time,bool) {
v, ok := f.Value().(time.Time)
v, ok := f.native().(time.Time)
return v, ok
}
func (f FieldAny) Error () (error,bool) {
v, ok := f.Value().(error)
v, ok := f.native().(error)
return v, ok
}
func (f FieldAny) Reflect () (reflect.Value,bool) {
v, ok := f.Value().(reflect.Value)
v, ok := f.native().(reflect.Value)
return v, ok
}
@ -147,7 +131,7 @@ func (f FieldAny) Reflect () (reflect.Value,bool) {
func (f FieldAny) Build (builder ablds.Builder) {
builder.Object(func(b ablds.ObjectBuilder){
b.Field(f.name).Any(f.Value()) }) }
b.Field(f.name).Any(f.native()) }) }

33
core/aflds/field_binary.go
Unescape View File

@ -28,51 +28,32 @@ import "ablds"
type (
FieldBinary struct {
valuer [[]byte]
partialField
valuerMode
value *[]byte
valueFn func()[]byte
}
)
func NewFieldBinary (name string, value []byte) *FieldBinary {
return &FieldBinary{
partialField: makePartialField(name),
valuerMode: localValuer{},
value: &value } }
valuer: newLocalValuer[[]byte](value),
partialField: makePartialField(name) }}
func NewDFieldBinary (name string, valueFn func() []byte) *FieldBinary {
if valueFn == nil {
panic(G.ErrInvalidDeferFunc)
}
return &FieldBinary {
partialField: makePartialField(name),
valuerMode: deferValuer{},
valueFn : valueFn,
}
}
valuer : newDeferValuer[[]byte](valueFn),
partialField: makePartialField(name) } }
func (f FieldBinary) getValue() []byte {
if f.isLocal() {
return *f.value
}
return f.valueFn()
}
func (f FieldBinary) Kind () Kind {
return KindBinary | f.valuerKind() }
func (f FieldBinary) Value() any {
return f.getValue()
}
func (f FieldBinary) Binary() ([]byte,bool) {
return f.getValue(),true }
return f.native(),true }
func (f FieldBinary) Build (builder ablds.Builder) {
builder.Object(func(b ablds.ObjectBuilder){
b.Field(f.name).Binary(f.getValue()) }) }
b.Field(f.name).Binary(f.native()) }) }

33
core/aflds/field_bool.go
Unescape View File

@ -28,52 +28,33 @@ import "ablds"
type (
FieldBool struct {
valuer[bool]
partialField
valuerMode
value *bool
valueFn func() bool
}
)
func NewFieldBool (name string, value bool) *FieldBool {
return &FieldBool{
partialField: makePartialField(name),
valuerMode: localValuer{},
value : &value } }
valuer : newLocalValuer[bool](value),
partialField: makePartialField(name) } }
func NewDFieldBool (name string, valueFn func() bool) *FieldBool {
if valueFn == nil {
panic(G.ErrInvalidDeferFunc)
}
return &FieldBool{
partialField: makePartialField(name),
valuerMode: deferValuer{},
valueFn : valueFn,
}
}
func (f FieldBool) getValue() bool {
if f.isLocal() {
return *f.value
}
return f.valueFn()
}
valuer : newDeferValuer[bool](valueFn),
partialField: makePartialField(name) } }
func (f FieldBool) Kind () Kind {
return KindBool | f.valuerKind() }
func (f FieldBool) Value() any {
return f.valueFn
}
func (f FieldBool) Bool() (bool,bool) {
return f.valueFn(),true }
return f.native(),true }
func (f FieldBool) Build (builder ablds.Builder) {
builder.Object(func(b ablds.ObjectBuilder){
b.Field(f.name).Bool(f.getValue()) }) }
b.Field(f.name).Bool(f.native()) }) }

35
core/aflds/field_duration.go
Unescape View File

@ -31,53 +31,32 @@ import (
type (
FieldDuration struct {
valuer[time.Duration]
partialField
valuerMode
value *time.Duration
valueFn func () time.Duration
}
)
func NewFieldDuration (name string, value time.Duration) *FieldDuration {
return &FieldDuration{
partialField: makePartialField(name),
valuerMode: localValuer{},
value : &value } }
valuer : newLocalValuer[time.Duration](value),
partialField: makePartialField(name) } }
func NewDFieldDuration (name string, valueFn func() time.Duration) *FieldDuration {
if valueFn == nil {
panic(G.ErrInvalidDeferFunc)
}
return &FieldDuration{
partialField: makePartialField(name),
valuerMode: deferValuer{},
valueFn : valueFn,
}
}
func (f FieldDuration) getValue() time.Duration {
if f.isLocal() {
return *f.value
}
return f.valueFn()
}
valuer : newDeferValuer[time.Duration](valueFn),
partialField: makePartialField(name) } }
func (f FieldDuration) Kind () Kind {
return KindDuration | f.valuerKind() }
func (f FieldDuration) Value() any {
return f.getValue()
}
func (f FieldDuration) Duration() (time.Duration,bool) {
return f.getValue(),true }
return f.native(),true }
func (f FieldDuration) Build (builder ablds.Builder) {
builder.Object(func(b ablds.ObjectBuilder){
b.Field(f.name).Duration(f.getValue()) }) }
b.Field(f.name).Duration(f.native()) }) }

35
core/aflds/field_error.go
Unescape View File

@ -30,53 +30,32 @@ import (
type (
FieldError struct {
valuer[error]
partialField
valuerMode
value *error
valueFn func() error
}
)
func NewFieldError (name string, value error) *FieldError {
return &FieldError{
partialField: makePartialField(name),
valuerMode: localValuer{},
value : &value }}
valuer: newLocalValuer[error](value),
partialField: makePartialField(name) }}
func NewDFieldError (name string, valueFn func() error) *FieldError {
if valueFn == nil {
panic(G.ErrInvalidDeferFunc)
}
return &FieldError{
partialField: makePartialField(name),
valuerMode : deferValuer{},
valueFn : valueFn,
}
}
func (f FieldError) getValue() error {
if f.isLocal() {
return *f.value
}
return f.valueFn()
}
valuer: newDeferValuer[error](valueFn),
partialField: makePartialField(name) } }
func (f FieldError) Kind () Kind {
return KindError | f.valuerKind() }
func (f FieldError) Value() any {
return f.getValue()
}
func (f FieldError) Error() (error,bool) {
return f.getValue(),true }
return f.native(),true }
func (f FieldError) Build (builder ablds.Builder) {
builder.Object(func(b ablds.ObjectBuilder){
b.Field(f.name).Error(f.getValue()) }) }
b.Field(f.name).Error(f.native()) }) }

23
core/aflds/field_float.go
Unescape View File

@ -28,8 +28,8 @@ import "ablds"
type (
FieldFloat struct {
valuer[float64]
partialField
valuerMode
value *float64
valueFn func() float64
}
@ -37,9 +37,8 @@ type (
func NewFieldFloat (name string, value float64) *FieldFloat {
return &FieldFloat{
partialField: makePartialField(name),
valuerMode : localValuer{},
value : &value } }
valuer: newLocalValuer[float64](value),
partialField: makePartialField(name) } }
func NewDFieldFloat (name string, valueFn func()float64) *FieldFloat {
@ -47,25 +46,15 @@ func NewDFieldFloat (name string, valueFn func()float64) *FieldFloat {
panic(G.ErrInvalidDeferFunc)
}
return &FieldFloat{
partialField: makePartialField(name),
valuerMode : deferValuer{},
valueFn : valueFn } }
valuer : newDeferValuer[float64](valueFn),
partialField: makePartialField(name) } }
func (f FieldFloat) getValue() float64 {
if f.isLocal() {
return *f.value
}
return f.valueFn()
}
func (f FieldFloat) Kind () Kind {
return KindFloat | f.valuerKind() }
func (f FieldFloat) Value() any {
return f.getValue()
}
func (f FieldFloat) Float() (float64,bool) {
return f.valueFn(),true }
@ -73,6 +62,6 @@ func (f FieldFloat) Float() (float64,bool) {
func (f FieldFloat) Build (builder ablds.Builder) {
builder.Object(func(b ablds.ObjectBuilder){
b.Field(f.name).Float64(f.getValue())
b.Field(f.name).Float64(f.native())
})
}

73
core/aflds/field_int.go
Unescape View File

@ -30,18 +30,16 @@ import (
type (
FieldInt struct {
valuer [int]
partialField
valuerMode
value *int
valueFn func()int
}
)
func NewFieldInt (name string, value int) *FieldInt {
return &FieldInt{
partialField: makePartialField(name),
valuerMode : localValuer{},
value : &value } }
partialField: makePartialField(name,),
valuer : newLocalValuer[int](value) } }
func NewDFieldInt (name string, valueFn func()int) *FieldInt {
@ -50,79 +48,22 @@ func NewDFieldInt (name string, valueFn func()int) *FieldInt {
}
return &FieldInt{
partialField: makePartialField(name),
valuerMode : deferValuer{},
valueFn : valueFn,
}
}
func NewDOFieldInt (name string, valueFn func()int) *FieldInt {
if valueFn == nil {
panic(G.ErrInvalidDeferFunc)
}
f := &FieldInt{
partialField: makePartialField(name),
valuerMode : deferValuer{},
}
f.valueFn = func() int {
if f.value == nil {
//fmt.Println("Llamada a funcion ")
v := valueFn()
f.value = &v
return v
}
//fmt.Println("Devolviendo cache")
return *f.value
}
return f
}
func NewDOFieldInt2 (name string, valueFn func()int) *FieldInt {
if valueFn == nil {
panic(G.ErrInvalidDeferFunc)
}
f := &FieldInt{
partialField: makePartialField(name),
valuerMode : deferValuer{},
}
f.valueFn = func() int {
//fmt.Println("Llamada a funcion ")
v := valueFn()
f.value = &v
f.valueFn = func() int {
//fmt.Println("Devolviendo cache")
return *f.value
}
return v
}
return f
}
valuer : newDeferValuer[int](valueFn) } }
func (f FieldInt) getValue() int {
if f.isLocal() {
return *f.value
}
return f.valueFn()
}
func (f FieldInt) Kind () Kind {
return KindInt | f.valuerKind() }
func (f FieldInt) Value() any {
return f.getValue() }
func (f FieldInt) Int() (int,bool) {
return f.getValue(),true }
return f.native(),true }
func (f FieldInt) Build (builder ablds.Builder) {
builder.Object(func(b ablds.ObjectBuilder){
b.Field(f.name).Int(f.getValue()) }) }
b.Field(f.name).Int(f.native()) }) }

32
core/aflds/field_reflect.go
Unescape View File

@ -31,50 +31,32 @@ import (
type (
FieldReflect struct {
valuer[reflect.Value]
partialField
valuerMode
value *reflect.Value
valueFn func() reflect.Value
}
)
func NewFieldReflect (name string, value reflect.Value) *FieldReflect {
return &FieldReflect{
partialField: makePartialField(name),
valuerMode : localValuer{},
value : &value } }
valuer : newLocalValuer[reflect.Value](value),
partialField: makePartialField(name) } }
func NewDFieldReflect (name string, valueFn func()reflect.Value) *FieldReflect {
if valueFn == nil {
panic(G.ErrInvalidDeferFunc)
}
return &FieldReflect{
partialField: makePartialField(name),
valuerMode : deferValuer{},
valueFn : valueFn ,
}
}
valuer: newDeferValuer[reflect.Value](valueFn),
partialField: makePartialField(name )} }
func (f FieldReflect) getValue() reflect.Value {
if f.isLocal() {
return *f.value
}
return f.valueFn()
}
func (f FieldReflect) Kind () Kind {
return KindReflect | f.valuerKind() }
func (f FieldReflect) Value() any {
return f.getValue() }
func (f FieldReflect) Reflect() (reflect.Value,bool) {
return f.getValue(),true }
return f.native(),true }
func (f FieldReflect) Build (builder ablds.Builder) {
builder.Object(func(b ablds.ObjectBuilder){
b.Field(f.name).Reflect(f.getValue()) }) }
b.Field(f.name).Reflect(f.native()) }) }

35
core/aflds/field_strings.go
Unescape View File

@ -30,54 +30,35 @@ import (
type (
FieldString struct {
valuer[string]
partialField
valuerMode
value *string
valueFn func() string
}
)
func NewFieldString (name string, value string) *FieldString {
return &FieldString{
partialField: makePartialField(name),
valuerMode: localValuer{},
value: &value,
}
}
valuer : newLocalValuer[string](value),
partialField: makePartialField(name) } }
func NewDFieldString (name string, valueFn func()string) *FieldString {
if valueFn == nil {
panic(G.ErrInvalidDeferFunc)
}
return &FieldString{
partialField: makePartialField(name),
valuerMode : deferValuer{},
valueFn : valueFn ,
}
}
valuer : newDeferValuer[string](valueFn) ,
partialField: makePartialField(name) } }
func (f FieldString) getValue() string {
if f.isLocal() {
return *f.value
}
return f.valueFn()
}
func (f FieldString) Kind () Kind {
return KindString | f.valuerKind() }
func (f FieldString) Value() any {
return f.getValue() }
func (f FieldString) String() (string,bool) {
return f.getValue(),true }
return f.native(),true }
func (f FieldString) Build (builder ablds.Builder) {
builder.Object(func(b ablds.ObjectBuilder){
b.Field(f.name).String(f.getValue())
b.Field(f.name).String(f.native())
})
}

35
core/aflds/field_time.go
Unescape View File

@ -31,51 +31,32 @@ import (
type (
FieldTime struct {
valuer[time.Time]
partialField
valuerMode
value *time.Time
valueFn func() time.Time
}
)
func NewFieldTime (name string, value time.Time) *FieldTime {
return &FieldTime{
partialField: makePartialField(name),
valuerMode: localValuer{},
value: &value } }
valuer : newLocalValuer[time.Time](value),
partialField: makePartialField(name) } }
func NewDFieldTime(name string, valueFn func()time.Time) *FieldTime {
if valueFn == nil {
panic(G.ErrInvalidDeferFunc)
}
func NewDFieldTime (name string, valueFn func() time.Time) *FieldTime {
return &FieldTime{
partialField: makePartialField(name),
valuerMode : deferValuer{},
valueFn : valueFn ,
}
}
valuer : newDeferValuer[time.Time](valueFn),
partialField: makePartialField(name) } }
func (f FieldTime) getValue() time.Time {
if f.isLocal() {
return *f.value
}
return f.valueFn()
}
func (f FieldTime) Kind () Kind {
return KindTime | f.valuerKind() }
func (f FieldTime) Value() any {
return f.getValue() }
func (f FieldTime) Time() (time.Time,bool) {
return f.getValue(),true }
return f.native(),true }
func (f FieldTime) Build (builder ablds.Builder) {
builder.Object(func(b ablds.ObjectBuilder){
b.Field(f.name).Time(f.getValue()) }) }
b.Field(f.name).Time(f.native()) }) }

32
core/aflds/field_uint.go
Unescape View File

@ -29,19 +29,17 @@ import (
type (
FieldUint struct {
FieldUint struct {
valuer [uint]
partialField
valuerMode
value *uint
valueFn func() uint
}
)
func NewFieldUint (name string, value uint) *FieldUint {
return &FieldUint{
partialField: makePartialField(name),
valuerMode: localValuer{},
value: &value } }
valuer : newLocalValuer[uint](value) } }
func NewDFieldUint (name string, valueFn func()uint) *FieldUint {
@ -50,32 +48,22 @@ func NewDFieldUint (name string, valueFn func()uint) *FieldUint {
}
return &FieldUint{
partialField: makePartialField(name),
valuerMode : deferValuer{},
valueFn : valueFn ,
}
}
valuer : newDeferValuer[uint](valueFn) } }
func (f FieldUint) getValue() uint {
if f.isLocal() {
return *f.value
}
return f.valueFn()
}
func (f FieldUint) Kind () Kind {
return KindInt | f.valuerKind() }
func (f FieldUint) Value() any {
return f.getValue() }
func (f FieldUint) Kind () Kind {
return KindUint | f.valuerKind() }
func (f FieldUint) Uint() (uint,bool) {
return f.getValue(),true }
return f.native(),true }
func (f FieldUint) Build (builder ablds.Builder) {
builder.Object(func(b ablds.ObjectBuilder){
b.Field(f.name).Uint(f.getValue()) }) }
b.Field(f.name).Uint(f.native()) }) }

35
core/aflds/partial_field.go
Unescape View File

@ -37,44 +37,43 @@ type (
// sobrescribe alguno de estos métodos, se produce shadowing, lo que significa
// que la implementación en Field prevalecerá sobre la implementación nula de
// partialField.
partialField struct {
name string
partialField[T any] struct {
valuer[T]
name string
}
)
func makePartialField (name string) partialField {
return partialField{ name : name } }
func makePartialField[T any] (name string) partialField[T] {
return partialField[T]{
name : name } }
func (f partialField) Name() string {
func (f partialField[T]) Name() string {
return f.name }
func (f partialField) Bool () (bool, bool) { return false, false }
func (f partialField[T]) Bool () (bool, bool) { return false, false }
func (f partialField) String() (string, bool) { return "", false }
func (f partialField[T]) String() (string, bool) { return "", false }
func (f partialField) Binary() ([]byte, bool) { return nil, false }
func (f partialField[T]) Binary() ([]byte, bool) { return nil, false }
func (f partialField) Int () (int, bool) { return 0, false }
func (f partialField[T]) Int () (int, bool) { return 0, false }
func (f partialField) Uint () (uint, bool) { return 0, false }
func (f partialField[T]) Uint () (uint, bool) { return 0, false }
func (f partialField) Float () (float64, bool) { return 0, false }
func (f partialField[T]) Float() (float64, bool) { return 0, false }
func (f partialField) Time () (time.Time, bool) { return g.timeZero, false }
func (f partialField[T]) Time () (time.Time, bool) { return g.timeZero, false }
func (f partialField) Duration () (time.Duration, bool) { return 0, false }
func (f partialField[T]) Duration() (time.Duration, bool) { return 0, false }
func (f partialField) Error () (error, bool) { return nil, false }
func (f partialField[T]) Error () (error, bool) { return nil, false }
func (f partialField) Reflect () (reflect.Value, bool) { return g.reflectZero, false }
func (f partialField[T]) Reflect() (reflect.Value, bool) { return g.reflectZero, false }

22
core/aflds/valuer_mode.go → core/aflds/valuer.go
Unescape View File

@ -24,28 +24,12 @@
package aflds
type (
valuerMode interface {
valuer [T any] interface {
valuerKind() Kind
isLocal () bool
native () T
Value () any
}
localValuer struct {}
deferValuer struct {}
)
func (_ localValuer) valuerKind() Kind { return 0 }
func (_ localValuer) isLocal() bool { return true }
func (_ deferValuer) valuerKind() Kind { return KindDefer }
func (_ deferValuer) isLocal() bool { return false }

53
core/aflds/valuer_defer.go
Unescape View File

@ -0,0 +1,53 @@
// ------------------------------------------------------------------------
// ℹ️ Project active3
// 🔗 Active Thing (activething.com) git.activething.com/go
//
// File name defer_valuer.go
// ✍️ Created by DEV
// 📅 Modified 03/05/2024
//
// 🔒 Copyright 2024 activething.com
//
// 📜 LICENSE --------------------------------------------------------------
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ------------------------------------------------------------------------
package aflds
type (
deferValuer [T any] struct {
valueFn func() T
}
)
func newDeferValuer [T any] (valueFn func() T) *deferValuer[T] {
if valueFn == nil {
panic(G.ErrInvalidDeferFunc)
}
return &deferValuer[T]{
valueFn : valueFn }}
func (_ deferValuer[T]) valuerKind() Kind {
return KindDefer }
func (v deferValuer[T]) native () T {
return v.valueFn() }
func (v deferValuer[T]) Value () any {
return v.valueFn() }

50
core/aflds/valuer_local.go
Unescape View File

@ -0,0 +1,50 @@
// ------------------------------------------------------------------------
// ℹ️ Project active3
// 🔗 Active Thing (activething.com) git.activething.com/go
//
// File name local_valuer.go
// ✍️ Created by DEV
// 📅 Modified 03/05/2024
//
// 🔒 Copyright 2024 activething.com
//
// 📜 LICENSE --------------------------------------------------------------
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ------------------------------------------------------------------------
package aflds
type (
localValuer [T any] struct {
value T
}
)
func newLocalValuer [T any] (value T) *localValuer[T] {
return &localValuer[T]{
value : value }}
func (_ localValuer[T]) valuerKind() Kind {
return 0 }
func (v localValuer[T]) native () T {
return v.value }
func (v localValuer[T]) Value () any {
return v.value }
Write Preview
Loading…
Cancel
Save

Powered by TurnKey Linux.