refactor: keep only one struct for package

pkg/alrsh/overridable.go

@@ -0,0 +1,146 @@
+// ALR - Any Linux Repository
+// Copyright (C) 2025 The ALR Authors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package alrsh
+
+import (
+	"bytes"
+	"encoding/gob"
+	"encoding/json"
+)
+
+type OverridableField[T any] struct {
+	data map[string]T
+	// It can't be a pointer
+	//
+	// See https://gitea.com/xorm/xorm/issues/2431
+	resolved T
+}
+
+func (f *OverridableField[T]) Set(key string, value T) {
+	if f.data == nil {
+		f.data = make(map[string]T)
+	}
+	f.data[key] = value
+}
+
+func (f *OverridableField[T]) Get(key string) T {
+	if f.data == nil {
+		f.data = make(map[string]T)
+	}
+	return f.data[key]
+}
+
+func (f *OverridableField[T]) Has(key string) (T, bool) {
+	if f.data == nil {
+		f.data = make(map[string]T)
+	}
+	val, ok := f.data[key]
+	return val, ok
+}
+
+func (f *OverridableField[T]) SetResolved(value T) {
+	f.resolved = value
+}
+
+func (f *OverridableField[T]) Resolved() T {
+	return f.resolved
+}
+
+func (f *OverridableField[T]) All() map[string]T {
+	return f.data
+}
+
+func (o *OverridableField[T]) Resolve(overrides []string) {
+	for _, override := range overrides {
+		if v, ok := o.Has(override); ok {
+			o.SetResolved(v)
+		}
+	}
+}
+
+func (f *OverridableField[T]) ToDB() ([]byte, error) {
+	var data map[string]T
+
+	if f.data == nil {
+		data = make(map[string]T)
+	} else {
+		data = f.data
+	}
+
+	return json.Marshal(data)
+}
+
+func (f *OverridableField[T]) FromDB(data []byte) error {
+	if len(data) == 0 {
+		*f = OverridableField[T]{data: make(map[string]T)}
+		return nil
+	}
+
+	var temp map[string]T
+	if err := json.Unmarshal(data, &temp); err != nil {
+		return err
+	}
+
+	if temp == nil {
+		temp = make(map[string]T)
+	}
+
+	*f = OverridableField[T]{data: temp}
+	return nil
+}
+
+type overridableFieldGobPayload[T any] struct {
+	Data     map[string]T
+	Resolved T
+}
+
+func (f *OverridableField[T]) GobEncode() ([]byte, error) {
+	var buf bytes.Buffer
+	enc := gob.NewEncoder(&buf)
+
+	payload := overridableFieldGobPayload[T]{
+		Data:     f.data,
+		Resolved: f.resolved,
+	}
+
+	if err := enc.Encode(payload); err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+func (f *OverridableField[T]) GobDecode(data []byte) error {
+	dec := gob.NewDecoder(bytes.NewBuffer(data))
+
+	var payload overridableFieldGobPayload[T]
+	if err := dec.Decode(&payload); err != nil {
+		return err
+	}
+
+	f.data = payload.Data
+	f.resolved = payload.Resolved
+	return nil
+}
+
+func OverridableFromMap[T any](data map[string]T) OverridableField[T] {
+	if data == nil {
+		data = make(map[string]T)
+	}
+	return OverridableField[T]{
+		data: data,
+	}
+}