Serialize Patio data values and data layouts to protobuf

2 files changed, 189 insertions, 2 deletions

diff --git a/src/main/java/org/shedlang/compiler/patio/protobuf/PatioToProtobuf.java b/src/main/java/org/shedlang/compiler/patio/protobuf/PatioToProtobuf.java
index 8009d1b2..5cea9b23 100644
--- a/src/main/java/org/shedlang/compiler/patio/protobuf/PatioToProtobuf.java
+++ b/src/main/java/org/shedlang/compiler/patio/protobuf/PatioToProtobuf.java
@@ -2,6 +2,7 @@ package org.shedlang.compiler.patio.protobuf;
 
 import org.shedlang.compiler.patio.*;
 import org.shedlang.compiler.patio.types.*;
+import org.shedlang.compiler.patio.values.*;
 import org.shedlang.compiler.sources.Source;
 
 import java.util.Optional;
@@ -103,6 +104,89 @@ public class PatioToProtobuf {
         };
     }
 
+    // == Data ptr values ==
+
+    public static PatioProtobuf.PatioDataPtrValue serializeDataPtrValue(PatioDataPtrValue value) {
+        var builder = PatioProtobuf.PatioDataPtrValue.newBuilder();
+
+        switch (value) {
+            case PatioDataPtrValueDataElement patioDataPtrValueDataElement -> {
+                var dataElementBuilder = PatioProtobuf.PatioDataPtrValueDataElement.newBuilder();
+                dataElementBuilder.setName(patioDataPtrValueDataElement.name());
+                builder.setDataElement(dataElementBuilder);
+            }
+
+            case PatioDataPtrValueNull patioDataPtrValueNull -> {
+                builder.setNull(PatioProtobuf.PatioDataPtrValueNull.newBuilder());
+            }
+        }
+
+        return builder.build();
+    }
+
+    public static PatioDataPtrValue deserializeDataPtrValue(PatioProtobuf.PatioDataPtrValue valueProtobuf) {
+        return switch (valueProtobuf.getValueCase()) {
+            case DATA_ELEMENT ->
+                new PatioDataPtrValueDataElement(valueProtobuf.getDataElement().getName());
+
+            case NULL ->
+                new PatioDataPtrValueNull();
+
+            case VALUE_NOT_SET ->
+                throw new UnsupportedOperationException("TODO");
+        };
+    }
+
+    // == Int values ==
+
+    public static PatioProtobuf.PatioIntValue serializeIntValue(PatioIntValue value) {
+        var builder = PatioProtobuf.PatioIntValue.newBuilder();
+
+        switch (value) {
+            case PatioIntValueByteOffsetOf patioIntValueByteOffsetOf -> {
+                var byteOffsetOfBuilder = PatioProtobuf.PatioIntValueByteOffsetOf.newBuilder();
+                byteOffsetOfBuilder.setLayout(serializeDataLayout(patioIntValueByteOffsetOf.layout()));
+                byteOffsetOfBuilder.addAllOffset(patioIntValueByteOffsetOf.offset());
+                builder.setByteOffsetOf(byteOffsetOfBuilder);
+            }
+
+            case PatioIntValueByteSizeOf patioIntValueByteSizeOf -> {
+                var byteSizeOfBuilder = PatioProtobuf.PatioIntValueByteSizeOf.newBuilder();
+                byteSizeOfBuilder.setLayout(serializeDataLayout(patioIntValueByteSizeOf.layout()));
+                builder.setByteSizeOf(byteSizeOfBuilder);
+            }
+
+            case PatioIntValueLiteral patioIntValueLiteral -> {
+                var literalBuilder = PatioProtobuf.PatioIntValueLiteral.newBuilder();
+                literalBuilder.setValue(patioIntValueLiteral.value());
+                builder.setLiteral(literalBuilder);
+            }
+        }
+
+        return builder.build();
+    }
+
+    public static PatioIntValue deserializeIntValue(PatioProtobuf.PatioIntValue valueProtobuf) {
+        return switch (valueProtobuf.getValueCase()) {
+            case BYTE_OFFSET_OF ->
+                new PatioIntValueByteOffsetOf(
+                    deserializeDataLayout(valueProtobuf.getByteOffsetOf().getLayout()),
+                    valueProtobuf.getByteOffsetOf().getOffsetList()
+                );
+
+            case BYTE_SIZE_OF ->
+                new PatioIntValueByteSizeOf(
+                    deserializeDataLayout(valueProtobuf.getByteSizeOf().getLayout())
+                );
+
+            case LITERAL ->
+                new PatioIntValueLiteral(valueProtobuf.getLiteral().getValue());
+
+            case VALUE_NOT_SET ->
+                throw new UnsupportedOperationException("TODO");
+        };
+    }
+
     // == Data layouts ==
 
     public static PatioProtobuf.PatioDataLayout serializeDataLayout(PatioDataLayout layout) {
@@ -189,4 +273,98 @@ public class PatioToProtobuf {
             }
         };
     }
+
+    // == Data values ==
+
+    public static PatioProtobuf.PatioDataValue serializeDataValue(PatioDataValue value) {
+        var builder = PatioProtobuf.PatioDataValue.newBuilder();
+        switch (value) {
+            case PatioDataValueArray patioDataValueArray -> {
+                var arrayBuilder = PatioProtobuf.PatioDataValueArray.newBuilder();
+                arrayBuilder.setElementLayout(serializeDataLayout(patioDataValueArray.elementLayout()));
+                for (var element : patioDataValueArray.elements()) {
+                    arrayBuilder.addElements(serializeDataValue(element));
+                }
+                builder.setArray(arrayBuilder);
+            }
+
+            case PatioDataValueBool patioDataValueBool -> {
+                var boolBuilder = PatioProtobuf.PatioDataValueBool.newBuilder();
+                boolBuilder.setValue(patioDataValueBool.value());
+                builder.setBool(boolBuilder);
+            }
+
+            case PatioDataValueByte patioDataValueByte -> {
+                var byteBuilder = PatioProtobuf.PatioDataValueByte.newBuilder();
+                byteBuilder.setValue(patioDataValueByte.value());
+                builder.setByte(byteBuilder);
+            }
+
+            case PatioDataValueDataPtr patioDataValueDataPtr -> {
+                var dataPtrBuilder = PatioProtobuf.PatioDataValueDataPtr.newBuilder();
+                dataPtrBuilder.setValue(serializeDataPtrValue(patioDataValueDataPtr.value()));
+                builder.setDataPtr(dataPtrBuilder);
+            }
+
+            case PatioDataValueInt patioDataValueInt -> {
+                var intBuilder = PatioProtobuf.PatioDataValueInt.newBuilder();
+                intBuilder.setValue(serializeIntValue(patioDataValueInt.value()));
+                builder.setInt(intBuilder);
+            }
+
+            case PatioDataValueInt32 patioDataValueInt32 -> {
+                var int32Builder = PatioProtobuf.PatioDataValueInt32.newBuilder();
+                int32Builder.setValue(serializeIntValue(patioDataValueInt32.value()));
+                builder.setInt32(int32Builder);
+            }
+
+            case PatioDataValueStruct patioDataValueStruct -> {
+                var structBuilder = PatioProtobuf.PatioDataValueStruct.newBuilder();
+                for (var element : patioDataValueStruct.elements()) {
+                    structBuilder.addElements(serializeDataValue(element));
+                }
+                builder.setStruct(structBuilder);
+            }
+        }
+
+        return builder.build();
+    }
+
+    public static PatioDataValue deserializeDataValue(PatioProtobuf.PatioDataValue valueProtobuf) {
+        return switch (valueProtobuf.getValueCase()) {
+            case ARRAY ->
+                PatioDataValues.array(
+                    deserializeDataLayout(valueProtobuf.getArray().getElementLayout()),
+                    valueProtobuf.getArray().getElementsList().stream()
+                        .map(PatioToProtobuf::deserializeDataValue)
+                        .collect(Collectors.toList())
+                );
+
+            case BOOL ->
+                PatioDataValues.bool(valueProtobuf.getBool().getValue());
+
+            case BYTE ->
+                PatioDataValues.byte_(valueProtobuf.getByte().getValue());
+
+            case DATA_PTR ->
+                PatioDataValues.dataPtr(deserializeDataPtrValue(valueProtobuf.getDataPtr().getValue()));
+
+            case INT ->
+                PatioDataValues.int_(deserializeIntValue(valueProtobuf.getInt().getValue()));
+
+            case INT32 ->
+                PatioDataValues.int32(deserializeIntValue(valueProtobuf.getInt32().getValue()));
+
+            case STRUCT ->
+                PatioDataValues.struct(
+                    valueProtobuf.getStruct().getElementsList().stream()
+                        .map(PatioToProtobuf::deserializeDataValue)
+                        .collect(Collectors.toList())
+                );
+
+            case VALUE_NOT_SET -> {
+                throw new UnsupportedOperationException("TODO");
+            }
+        };
+    }
 }
diff --git a/src/main/java/org/shedlang/compiler/patio/types/PatioDataValues.java b/src/main/java/org/shedlang/compiler/patio/types/PatioDataValues.java
index 1c62e0c8..4390021b 100644
--- a/src/main/java/org/shedlang/compiler/patio/types/PatioDataValues.java
+++ b/src/main/java/org/shedlang/compiler/patio/types/PatioDataValues.java
@@ -1,5 +1,6 @@
 package org.shedlang.compiler.patio.types;
 
+import org.shedlang.compiler.patio.values.PatioDataPtrValue;
 import org.shedlang.compiler.patio.values.PatioDataPtrValueNull;
 import org.shedlang.compiler.patio.values.PatioIntValue;
 import org.shedlang.compiler.patio.values.PatioIntValueLiteral;
@@ -24,12 +25,20 @@ public class PatioDataValues {
         return new PatioDataValueByte((byte) value);
     }
 
+    public static PatioDataValue dataPtr(PatioDataPtrValue value) {
+        return new PatioDataValueDataPtr(value);
+    }
+
     public static PatioDataValue dataPtrNull() {
-        return new PatioDataValueDataPtr(new PatioDataPtrValueNull());
+        return dataPtr(new PatioDataPtrValueNull());
     }
 
     public static PatioDataValue int_(int value) {
-        return new PatioDataValueInt(new PatioIntValueLiteral(value));
+        return int_(new PatioIntValueLiteral(value));
+    }
+
+    public static PatioDataValue int_(PatioIntValue value) {
+        return new PatioDataValueInt(value);
     }
 
     public static PatioDataValue int32(int value) {