chore: import upstream snapshot with attribution

core/conflicts/serialization.go

@@ -0,0 +1,122 @@
+// Copyright 2025 Dolthub, Inc.
+//
+// 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 conflicts
+
+import (
+	"context"
+
+	"github.com/cockroachdb/errors"
+
+	"github.com/dolthub/doltgresql/core/rootobject/objinterface"
+	"github.com/dolthub/doltgresql/utils"
+)
+
+// Serialize returns the Conflict as a byte slice. If the Conflict is invalid, then this returns a nil slice.
+func (conflict Conflict) Serialize(ctx context.Context) (_ []byte, err error) {
+	if !conflict.ID.IsValid() {
+		return nil, nil
+	}
+
+	// Write all of the conflicts to the writer
+	writer := utils.NewWriter(512)
+	writer.VariableUint(0) // Version
+	// Serialize "ours", "theirs", and "ancestor"
+	var ours, theirs, ancestor []byte
+	if conflict.Ours != nil {
+		ours, err = conflict.Ours.Serialize(ctx)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if conflict.Theirs != nil {
+		theirs, err = conflict.Theirs.Serialize(ctx)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if conflict.Ancestor != nil {
+		ancestor, err = conflict.Ancestor.Serialize(ctx)
+		if err != nil {
+			return nil, err
+		}
+	}
+	// Write the conflict data
+	writer.Id(conflict.ID)
+	writer.String(conflict.FromHash)
+	writer.Int64(int64(conflict.RootObjectID))
+	writer.Bool(conflict.Ours != nil)
+	writer.Bool(conflict.Theirs != nil)
+	writer.Bool(conflict.Ancestor != nil)
+	writer.ByteSlice(ours)
+	writer.ByteSlice(theirs)
+	writer.ByteSlice(ancestor)
+	// Returns the data
+	return writer.Data(), nil
+}
+
+// DeserializeConflict returns the Conflict that was serialized in the byte slice. Returns an empty Conflict (invalid
+// ID) if data is nil or empty.
+func DeserializeConflict(ctx context.Context, data []byte) (_ Conflict, err error) {
+	if len(data) == 0 {
+		return Conflict{}, nil
+	}
+	reader := utils.NewReader(data)
+	version := reader.VariableUint()
+	if version > 0 {
+		return Conflict{}, errors.Errorf("version %d of conflicts is not supported, please upgrade the server", version)
+	}
+
+	// Read from the reader
+	conflict := Conflict{}
+	conflict.ID = reader.Id()
+	conflict.FromHash = reader.String()
+	conflict.RootObjectID = objinterface.RootObjectID(reader.Int64())
+	hasOurs := reader.Bool()
+	hasTheirs := reader.Bool()
+	hasAncestor := reader.Bool()
+	ours := reader.ByteSlice()
+	theirs := reader.ByteSlice()
+	ancestor := reader.ByteSlice()
+	// Deserialize "ours", "theirs", and "ancestor"
+	if hasOurs {
+		conflict.Ours, err = DeserializeRootObject(ctx, conflict.RootObjectID, ours)
+		if err != nil {
+			return Conflict{}, err
+		}
+	}
+	if hasTheirs {
+		conflict.Theirs, err = DeserializeRootObject(ctx, conflict.RootObjectID, theirs)
+		if err != nil {
+			return Conflict{}, err
+		}
+	}
+	if hasAncestor {
+		conflict.Ancestor, err = DeserializeRootObject(ctx, conflict.RootObjectID, ancestor)
+		if err != nil {
+			return Conflict{}, err
+		}
+	}
+	if !reader.IsEmpty() {
+		return Conflict{}, errors.Errorf("extra data found while deserializing a conflict")
+	}
+	// Return the deserialized object
+	return conflict, nil
+}
+
+// DeserializeRootObject handles root object deserialization, and is declared in a different package. It is assigned
+// here by an Init function to get around import cycles.
+var DeserializeRootObject = func(ctx context.Context, rootObjID objinterface.RootObjectID, data []byte) (objinterface.RootObject, error) {
+	return nil, errors.New("DeserializeRootObject was never initialized")
+}