feat: Add support for variable length unsigned integers in mspec.

Author: chrisdutz

code-generation/language-java/src/main/java/org/apache/plc4x/language/java/JavaLanguageTemplateHelper.java

@@ -1411,4 +1411,13 @@ public String getExternalTypeImports() {
         return imports.toString();
     }
 
+    public boolean isVarduintField(Field field) {
+        Optional<Term> encoding = field.getEncoding();
+        if (encoding.isPresent()) {
+            String encodingName = encoding.get().asLiteral().orElseThrow().asStringLiteral().orElseThrow().getValue();
+            return encodingName.equalsIgnoreCase("VARUDINT");
+        }
+        return false;
+    }
+
 }

code-generation/language-java/src/main/resources/templates/java/complex-type-template.java.ftlh

@@ -548,7 +548,11 @@ public<#if type.isDiscriminatedParentTypeDefinition()> abstract</#if> class ${ty
                 <#assign vstringTypeReference = simpleTypeReference.asVstringTypeReference().orElseThrow()>
         lengthInBits += ${helper.toSerializationExpression(simpleField, helper.intTypeReference, vstringTypeReference.getLengthExpression(), parserArguments)};
             <#else>
+                <#if helper.isVarduintField(simpleField)>
+        lengthInBits += GET_VARUDINT_LENGTH_IN_BITS(get${simpleField.getName()?cap_first}());
+                <#else>
         lengthInBits += ${simpleTypeReference.sizeInBits};
+                </#if>
             </#if>
         <#elseif helper.isEnumField(field)>
         lengthInBits += ${helper.getEnumBaseTypeReference(simpleField.type).sizeInBits};

plc4j/spi/src/main/java/org/apache/plc4x/java/spi/generation/ReadBufferByteBased.java

@@ -311,6 +311,25 @@ public long readUnsignedLong(String logicalName, int bitLength, WithReaderArgs..
                         value += (long) (digit * Math.pow(10, i));
                     }
                     return value;
+                case "VARUDINT":
+                    long result = 0;
+                    int shift = 0;
+                    for (int i = 0; i < 4; i++) {
+                        short b = bi.readShort(true, 8);
+                        // Add the lower 7 bits of b, shifted appropriately.
+                        result = result << shift;
+                        result |= ((long) b & 0x0000007F);
+                        // If the most significant bit is 0, this is the last byte.
+                        if ((b & 0x80) == 0) {
+                            break;
+                        }
+                        shift = 7;
+                        // Ensure we do not exceed the maximum allowed bit length.
+                        if (shift >= bitLength) {
+                            throw new ParseException("var-length-uint exceeds allowed bit length " + bitLength);
+                        }
+                    }
+                    return result;
                 case "default":
                     if (byteOrder == ByteOrder.LITTLE_ENDIAN) {
                         final long longValue = bi.readLong(true, bitLength);

plc4j/spi/src/main/java/org/apache/plc4x/java/spi/generation/StaticHelper.java

@@ -126,4 +126,14 @@ public static int PADCOUNT(Object obj, boolean hasNext) {
         return hasNext ? COUNT(obj) : 0;
     }    
 
+    public static int GET_VARUDINT_LENGTH_IN_BITS(long value) {
+        int curFieldLengthInBits = 0;
+        long temp = value;
+        do {
+            curFieldLengthInBits += 8;
+            temp >>>= 7;
+        } while (temp != 0);
+        return curFieldLengthInBits;
+    }
+
 }

plc4j/spi/src/main/java/org/apache/plc4x/java/spi/generation/WriteBufferByteBased.java

@@ -284,6 +284,31 @@ public void writeUnsignedLong(String logicalName, int bitLength, long value, Wit
                     }
                     break;
                 }
+                case "VARUDINT":
+                    // Check that the provided value fits in the allowed bit length.
+                    long maxValue = (1L << bitLength) - 1;
+                    if (value > maxValue) {
+                        throw new SerializationException("Provided value of " + value + " exceeds the max value of " + maxValue);
+                    }
+                    // Determine the number of 7-bit groups (bytes) required.
+                    int numBytes = 0;
+                    long temp = value;
+                    do {
+                        numBytes++;
+                        temp >>>= 7;
+                    } while (temp != 0);
+
+                    // Write each 7-bit group starting from the most significant.
+                    for (int i = numBytes - 1; i >= 0; i--) {
+                        int shift = i * 7;
+                        int b = (int) ((value >> shift) & 0x7F);
+                        // Set the continuation bit for all but the last (least significant) group.
+                        if (i > 0) {
+                            b |= 0x80;
+                        }
+                        bo.writeByte(false, 8, (byte) b);
+                    }
+                    break;
                 case "default":
                     if (byteOrder == ByteOrder.LITTLE_ENDIAN) {
                         value = Long.reverseBytes(value) >> 32;