From 33a661b5e520f44f4c5481825403b2cea66d27f3 Mon Sep 17 00:00:00 2001 From: ionutboangiu Date: Thu, 30 Sep 2021 18:26:44 +0300 Subject: [PATCH] Implement MapToDynamicOpts functions and define DynamicOpts for interface and bool types --- utils/libdynamics.go | 268 ++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 249 insertions(+), 19 deletions(-) diff --git a/utils/libdynamics.go b/utils/libdynamics.go index 87ab6de4d..409185776 100644 --- a/utils/libdynamics.go +++ b/utils/libdynamics.go @@ -18,6 +18,7 @@ along with this program. If not, see package utils import ( + "strconv" "strings" "time" @@ -44,6 +45,11 @@ type DynamicFloat64Opt struct { FilterIDs []string } +type DynamicBoolOpt struct { + Value bool + FilterIDs []string +} + type DynamicDurationOpt struct { Value time.Duration FilterIDs []string @@ -54,6 +60,11 @@ type DynamicDecimalBigOpt struct { FilterIDs []string } +type DynamicInterfaceOpt struct { + Value interface{} + FilterIDs []string +} + func CloneDynamicStringSliceOpt(in []*DynamicStringSliceOpt) (cl []*DynamicStringSliceOpt) { cl = make([]*DynamicStringSliceOpt, len(in)) copy(cl, in) @@ -62,31 +73,78 @@ func CloneDynamicStringSliceOpt(in []*DynamicStringSliceOpt) (cl []*DynamicStrin func CloneDynamicStringOpt(in []*DynamicStringOpt) (cl []*DynamicStringOpt) { cl = make([]*DynamicStringOpt, len(in)) - copy(cl, in) + for i, val := range in { + cl[i] = &DynamicStringOpt{ + FilterIDs: CloneStringSlice(val.FilterIDs), + Value: val.Value, + } + } + return +} + +func CloneDynamicInterfaceOpt(in []*DynamicInterfaceOpt) (cl []*DynamicInterfaceOpt) { + cl = make([]*DynamicInterfaceOpt, len(in)) + for i, val := range in { + cl[i] = &DynamicInterfaceOpt{ + FilterIDs: CloneStringSlice(val.FilterIDs), + Value: val.Value, + } + } + return +} + +func CloneDynamicBoolOpt(in []*DynamicBoolOpt) (cl []*DynamicBoolOpt) { + cl = make([]*DynamicBoolOpt, len(in)) + for i, val := range in { + cl[i] = &DynamicBoolOpt{ + FilterIDs: CloneStringSlice(val.FilterIDs), + Value: val.Value, + } + } return } func CloneDynamicIntOpt(in []*DynamicIntOpt) (cl []*DynamicIntOpt) { cl = make([]*DynamicIntOpt, len(in)) - copy(cl, in) + for i, val := range in { + cl[i] = &DynamicIntOpt{ + FilterIDs: CloneStringSlice(val.FilterIDs), + Value: val.Value, + } + } return } func CloneDynamicFloat64Opt(in []*DynamicFloat64Opt) (cl []*DynamicFloat64Opt) { cl = make([]*DynamicFloat64Opt, len(in)) - copy(cl, in) + for i, val := range in { + cl[i] = &DynamicFloat64Opt{ + FilterIDs: CloneStringSlice(val.FilterIDs), + Value: val.Value, + } + } return } func CloneDynamicDurationOpt(in []*DynamicDurationOpt) (cl []*DynamicDurationOpt) { cl = make([]*DynamicDurationOpt, len(in)) - copy(cl, in) + for i, val := range in { + cl[i] = &DynamicDurationOpt{ + FilterIDs: CloneStringSlice(val.FilterIDs), + Value: val.Value, + } + } return } func CloneDynamicDecimalBigOpt(in []*DynamicDecimalBigOpt) (cl []*DynamicDecimalBigOpt) { cl = make([]*DynamicDecimalBigOpt, len(in)) - copy(cl, in) + for i, val := range in { + cl[i] = &DynamicDecimalBigOpt{ + FilterIDs: CloneStringSlice(val.FilterIDs), + Value: CloneDecimalBig(val.Value), + } + } return } @@ -120,6 +178,21 @@ func DynamicStringOptEqual(v1, v2 []*DynamicStringOpt) bool { return true } +func DynamicBoolOptEqual(v1, v2 []*DynamicBoolOpt) bool { + if len(v1) != len(v2) { + return false + } + for i := range v1 { + if !SliceStringEqual(v1[i].FilterIDs, v2[i].FilterIDs) { + return false + } + if v1[i].Value != v2[i].Value { + return false + } + } + return true +} + func DynamicIntOptEqual(v1, v2 []*DynamicIntOpt) bool { if len(v1) != len(v2) { return false @@ -166,6 +239,19 @@ func DynamicDurationOptEqual(v1, v2 []*DynamicDurationOpt) bool { } func DynamicDecimalBigOptEqual(v1, v2 []*DynamicDecimalBigOpt) bool { + if len(v1) != len(v2) { + return false + } + for i := range v1 { + if !SliceStringEqual(v1[i].FilterIDs, v2[i].FilterIDs) || + v1[i].Value.Cmp(v2[i].Value) != 0 { + return false + } + } + return true +} + +func DynamicInterfaceOptEqual(v1, v2 []*DynamicInterfaceOpt) bool { if len(v1) != len(v2) { return false } @@ -173,7 +259,7 @@ func DynamicDecimalBigOptEqual(v1, v2 []*DynamicDecimalBigOpt) bool { if !SliceStringEqual(v1[i].FilterIDs, v2[i].FilterIDs) { return false } - if v1[i].Value.Cmp(v2[i].Value) != 0 { + if v1[i].Value != v2[i].Value { return false } } @@ -183,7 +269,7 @@ func DynamicDecimalBigOptEqual(v1, v2 []*DynamicDecimalBigOpt) bool { func DynamicStringSliceOptsToMap(dynOpts []*DynamicStringSliceOpt) map[string][]string { optMap := make(map[string][]string) for _, opt := range dynOpts { - optMap[StringSliceToStringWithSep(opt.FilterIDs, InfieldSep)] = opt.Value + optMap[strings.Join(opt.FilterIDs, InfieldSep)] = opt.Value } return optMap } @@ -191,7 +277,15 @@ func DynamicStringSliceOptsToMap(dynOpts []*DynamicStringSliceOpt) map[string][] func DynamicStringOptsToMap(dynOpts []*DynamicStringOpt) map[string]string { optMap := make(map[string]string) for _, opt := range dynOpts { - optMap[StringSliceToStringWithSep(opt.FilterIDs, InfieldSep)] = opt.Value + optMap[strings.Join(opt.FilterIDs, InfieldSep)] = opt.Value + } + return optMap +} + +func DynamicBoolOptsToMap(dynOpts []*DynamicBoolOpt) map[string]bool { + optMap := make(map[string]bool) + for _, opt := range dynOpts { + optMap[strings.Join(opt.FilterIDs, InfieldSep)] = opt.Value } return optMap } @@ -199,7 +293,7 @@ func DynamicStringOptsToMap(dynOpts []*DynamicStringOpt) map[string]string { func DynamicIntOptsToMap(dynOpts []*DynamicIntOpt) map[string]int { optMap := make(map[string]int) for _, opt := range dynOpts { - optMap[StringSliceToStringWithSep(opt.FilterIDs, InfieldSep)] = opt.Value + optMap[strings.Join(opt.FilterIDs, InfieldSep)] = opt.Value } return optMap } @@ -207,7 +301,7 @@ func DynamicIntOptsToMap(dynOpts []*DynamicIntOpt) map[string]int { func DynamicFloat64OptsToMap(dynOpts []*DynamicFloat64Opt) map[string]float64 { optMap := make(map[string]float64) for _, opt := range dynOpts { - optMap[StringSliceToStringWithSep(opt.FilterIDs, InfieldSep)] = opt.Value + optMap[strings.Join(opt.FilterIDs, InfieldSep)] = opt.Value } return optMap } @@ -215,7 +309,7 @@ func DynamicFloat64OptsToMap(dynOpts []*DynamicFloat64Opt) map[string]float64 { func DynamicDurationOptsToMap(dynOpts []*DynamicDurationOpt) map[string]string { optMap := make(map[string]string) for _, opt := range dynOpts { - optMap[StringSliceToStringWithSep(opt.FilterIDs, InfieldSep)] = opt.Value.String() + optMap[strings.Join(opt.FilterIDs, InfieldSep)] = opt.Value.String() } return optMap } @@ -223,18 +317,154 @@ func DynamicDurationOptsToMap(dynOpts []*DynamicDurationOpt) map[string]string { func DynamicDecimalBigOptsToMap(dynOpts []*DynamicDecimalBigOpt) map[string]string { optMap := make(map[string]string) for _, opt := range dynOpts { - optMap[StringSliceToStringWithSep(opt.FilterIDs, InfieldSep)] = opt.Value.String() + value := IfaceAsString(opt.Value) + optMap[strings.Join(opt.FilterIDs, InfieldSep)] = value } return optMap } -func StringSliceToStringWithSep(ss []string, sep string) string { - var str strings.Builder - for i := range ss { - str.WriteString(ss[i]) - if i != len(ss)-1 { - str.WriteString(sep) +func DynamicInterfaceOptsToMap(dynOpts []*DynamicInterfaceOpt) map[string]string { + optMap := make(map[string]string) + for _, opt := range dynOpts { + optMap[strings.Join(opt.FilterIDs, InfieldSep)] = IfaceAsString(opt.Value) + } + return optMap +} + +func MapToDynamicStringSliceOpts(optsMap map[string][]string) (dynOpts []*DynamicStringSliceOpt) { + dynOpts = make([]*DynamicStringSliceOpt, len(optsMap)) + for filters, opt := range optsMap { + if filters != EmptyString { + dynOpts = append(dynOpts, &DynamicStringSliceOpt{ + FilterIDs: strings.Split(filters, InfieldSep), + Value: opt, + }) + } else { + dynOpts = append(dynOpts, &DynamicStringSliceOpt{ + Value: opt, + }) } } - return str.String() + return +} + +func MapToDynamicStringOpts(optsMap map[string]string) (dynOpts []*DynamicStringOpt) { + dynOpts = make([]*DynamicStringOpt, len(optsMap)) + for filters, opt := range optsMap { + if filters != EmptyString { + dynOpts = append(dynOpts, &DynamicStringOpt{ + FilterIDs: strings.Split(filters, InfieldSep), + Value: opt, + }) + } else { + dynOpts = append(dynOpts, &DynamicStringOpt{ + Value: opt, + }) + } + } + return +} + +func MapToDynamicBoolOpts(optsMap map[string]bool) (dynOpts []*DynamicBoolOpt) { + dynOpts = make([]*DynamicBoolOpt, len(optsMap)) + for filters, opt := range optsMap { + if filters != EmptyString { + dynOpts = append(dynOpts, &DynamicBoolOpt{ + FilterIDs: strings.Split(filters, InfieldSep), + Value: opt, + }) + } else { + dynOpts = append(dynOpts, &DynamicBoolOpt{ + Value: opt, + }) + } + } + return +} + +func MapToDynamicDecimalBigOpts(optsMap map[string]string) (dynOpts []*DynamicDecimalBigOpt, err error) { + dynOpts = make([]*DynamicDecimalBigOpt, len(optsMap)) + for filters, opt := range optsMap { + var bigVal *decimal.Big + if bigVal, err = StringAsBig(opt); err != nil { + return + } + if filters != EmptyString { + dynOpts = append(dynOpts, &DynamicDecimalBigOpt{ + FilterIDs: strings.Split(filters, InfieldSep), + Value: bigVal, + }) + } else { + dynOpts = append(dynOpts, &DynamicDecimalBigOpt{ + Value: bigVal, + }) + } + } + return +} + +func MapToDynamicDurationOpts(optsMap map[string]string) (dynOpts []*DynamicDurationOpt, err error) { + dynOpts = make([]*DynamicDurationOpt, len(optsMap)) + for filters, opt := range optsMap { + var usageTTL time.Duration + if usageTTL, err = ParseDurationWithNanosecs(opt); err != nil { + return + } + if filters != EmptyString { + dynOpts = append(dynOpts, &DynamicDurationOpt{ + FilterIDs: strings.Split(filters, InfieldSep), + Value: usageTTL, + }) + } else { + dynOpts = append(dynOpts, &DynamicDurationOpt{ + Value: usageTTL, + }) + } + } + return +} + +func MapToDynamicFloat64Opts(optsMap map[string]float64) (dynOpts []*DynamicFloat64Opt) { + dynOpts = make([]*DynamicFloat64Opt, len(optsMap)) + for filters, opt := range optsMap { + if filters != EmptyString { + dynOpts = append(dynOpts, &DynamicFloat64Opt{ + FilterIDs: strings.Split(filters, InfieldSep), + Value: opt, + }) + } else { + dynOpts = append(dynOpts, &DynamicFloat64Opt{ + Value: opt, + }) + } + } + return +} + +func MapToDynamicInterfaceOpts(optsMap map[string]string) (dynOpts []*DynamicInterfaceOpt) { + dynOpts = make([]*DynamicInterfaceOpt, len(optsMap)) + for filters, opt := range optsMap { + if filters != EmptyString { + if optVal, err := strconv.Atoi(opt); err == nil { + dynOpts = append(dynOpts, &DynamicInterfaceOpt{ + FilterIDs: strings.Split(filters, InfieldSep), + Value: optVal, + }) + } + dynOpts = append(dynOpts, &DynamicInterfaceOpt{ + FilterIDs: strings.Split(filters, InfieldSep), + Value: opt, + }) + } else { + dynOpts = append(dynOpts, &DynamicInterfaceOpt{ + Value: opt, + }) + } + } + return +} + +func CloneDecimalBig(in *decimal.Big) (cln *decimal.Big) { + *cln = *in + return }