refactored data-types to reduce plugin sizes

types/dict/dict-type.go

@@ -0,0 +1,201 @@
+// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// dict-type.go
+package dict
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
+const DictTypeName = "dict"
+
+type DictType map[any]any
+
+func IsDict(v any) (ok bool) {
+	_, ok = v.(*DictType)
+	return ok
+}
+
+func MakeDict() (dict *DictType) {
+	d := make(DictType)
+	dict = &d
+	return
+}
+
+func NewDict(dictAny map[any]any) (dict *DictType) {
+	var d DictType
+	if dictAny != nil {
+		d = make(DictType, len(dictAny))
+		for i, item := range dictAny {
+			d[i] = item
+		}
+	} else {
+		d = make(DictType)
+	}
+	dict = &d
+	return
+}
+
+func newDict(dictAny map[any]kern.Term) (dict *DictType) {
+	// TODO Change with a call to NewDict()
+	var d DictType
+	if dictAny != nil {
+		d = make(DictType, len(dictAny))
+		for i, item := range dictAny {
+			d[i] = item
+		}
+	} else {
+		d = make(DictType)
+	}
+	dict = &d
+	return
+}
+
+func (dict *DictType) toMultiLine(sb *strings.Builder, opt kern.FmtOpt) {
+	indent := kern.GetFormatIndent(opt)
+	flags := kern.GetFormatFlags(opt)
+	//sb.WriteString(strings.Repeat("  ", indent))
+	sb.WriteByte('{')
+
+	if len(*dict) > 0 {
+		innerOpt := kern.MakeFormatOptions(flags, indent+1)
+		nest := strings.Repeat("  ", indent+1)
+		sb.WriteByte('\n')
+
+		first := true
+		for name, value := range *dict {
+			if first {
+				first = false
+			} else {
+				sb.WriteByte(',')
+				sb.WriteByte('\n')
+			}
+
+			sb.WriteString(nest)
+			if key, ok := name.(string); ok {
+				sb.WriteByte('"')
+				sb.WriteString(key)
+				sb.WriteByte('"')
+			} else {
+				fmt.Fprintf(sb, "%v", name)
+			}
+			sb.WriteString(": ")
+			if f, ok := value.(kern.Formatter); ok {
+				sb.WriteString(f.ToString(innerOpt))
+			} else if _, ok = value.(kern.Functor); ok {
+				sb.WriteString("func(){}")
+			} else {
+				fmt.Fprintf(sb, "%v", value)
+			}
+		}
+		sb.WriteByte('\n')
+		sb.WriteString(strings.Repeat("  ", indent))
+	}
+	sb.WriteString("}")
+}
+
+func (dict *DictType) ToString(opt kern.FmtOpt) string {
+	var sb strings.Builder
+	flags := kern.GetFormatFlags(opt)
+	if flags&kern.MultiLine != 0 {
+		dict.toMultiLine(&sb, opt)
+	} else {
+		sb.WriteByte('{')
+		first := true
+		for key, value := range *dict {
+			if first {
+				first = false
+			} else {
+				sb.WriteString(", ")
+			}
+			if s, ok := key.(string); ok {
+				sb.WriteByte('"')
+				sb.WriteString(s)
+				sb.WriteByte('"')
+			} else {
+				fmt.Fprintf(&sb, "%v", key)
+			}
+			sb.WriteString(": ")
+			if formatter, ok := value.(kern.Formatter); ok {
+				sb.WriteString(formatter.ToString(opt))
+			} else if t, ok := value.(kern.Term); ok {
+				sb.WriteString(t.String())
+			} else {
+				fmt.Fprintf(&sb, "%#v", value)
+			}
+		}
+		sb.WriteByte('}')
+	}
+	return sb.String()
+}
+
+func (dict *DictType) String() string {
+	return dict.ToString(0)
+}
+
+func (dict *DictType) TypeName() string {
+	return DictTypeName
+}
+
+func (dict *DictType) HasKey(target any) (ok bool) {
+	for key := range *dict {
+		if ok = reflect.DeepEqual(key, target); ok {
+			break
+		}
+	}
+	return
+}
+
+func (dict *DictType) SetItem(key any, value any) {
+	(*dict)[key] = value
+}
+
+func (dict *DictType) GetItem(key any) (value any, exists bool) {
+	value, exists = (*dict)[key]
+	return
+}
+
+func (dict *DictType) Clone() (c *DictType) {
+	c = newDict(nil)
+	for k, v := range *dict {
+		(*c)[k] = kern.Clone(v)
+	}
+	return
+}
+
+func (dict *DictType) Merge(second *DictType) {
+	if second != nil {
+		for k, v := range *second {
+			(*dict)[k] = v
+		}
+	}
+}
+
+func (dict *DictType) Equals(dict2 DictType) (answer bool) {
+	if dict2 != nil && len(*dict) == len(dict2) {
+		answer = true
+		for key, value1 := range *dict {
+			if value2, exists := dict2.GetItem(key); exists {
+				if !kern.Equal(value1, value2) {
+					answer = false
+					break
+				}
+			} else {
+				answer = false
+				break
+			}
+		}
+	}
+	return
+}
+
+////////////////
+
+// type DictFormat interface {
+// 	ToDict() *DictType
+// }