You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by cd...@apache.org on 2026/07/15 08:10:14 UTC

(plc4x) branch develop updated: chore: Removed the old code-gen and renamed the new one to replace the old.

This is an automated email from the ASF dual-hosted git repository.

chrisdutz pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git


The following commit(s) were added to refs/heads/develop by this push:
     new 01593f3aa9 chore: Removed the old code-gen and renamed the new one to replace the old.
01593f3aa9 is described below

commit 01593f3aa9ca90c8581a29eef6f31f502cf335d4
Author: Christofer Dutz <ch...@c-ware.de>
AuthorDate: Wed Jul 15 10:09:58 2026 +0200

    chore: Removed the old code-gen and renamed the new one to replace the old.
---
 code-generation/language/java-jp/pom.xml           |  148 --
 ...x.plugins.codegenerator.language.LanguageOutput |   19 -
 code-generation/language/java/pom.xml              |   63 +-
 .../language/java/JavaLanguageOutput.java          |    0
 .../language/java/generators/BaseGenerator.java    |    0
 .../java/generators/ComplexTypeGenerator.java      |    0
 .../java/generators/ConstantsTypeGenerator.java    |    0
 .../language/java/generators/DataIoGenerator.java  |    0
 .../language/java/generators/EnumGenerator.java    |    0
 .../plc4x/language/java/JavaLanguageOutput.java    |  113 --
 .../language/java/JavaLanguageTemplateHelper.java  | 1455 --------------------
 ...x.plugins.codegenerator.language.LanguageOutput |    2 +-
 .../templates/java/complex-type-template.java.ftlh | 1094 ---------------
 .../templates/java/constants-template.java.ftlh    |   84 --
 .../templates/java/data-io-template.java.ftlh      |  739 ----------
 .../templates/java/enum-template.java.ftlh         |  177 ---
 .../src/test/resources/integration-test/pom.xml    |  201 ---
 .../java/test/readwrite/utils/StaticHelper.java    |   90 --
 .../language/java/src/test/resources/settings.xml  |   53 -
 code-generation/language/pom.xml                   |    1 -
 plc4j/drivers/ab-eth/pom.xml                       |    2 +-
 plc4j/drivers/ads/pom.xml                          |    3 +-
 plc4j/drivers/bacnet/pom.xml                       |    3 +-
 plc4j/drivers/c-bus/pom.xml                        |    3 +-
 plc4j/drivers/can/pom.xml                          |    2 +-
 plc4j/drivers/canopen/pom.xml                      |    3 +-
 plc4j/drivers/eip/pom.xml                          |    3 +-
 plc4j/drivers/firmata/pom.xml                      |    3 +-
 plc4j/drivers/iec-60870/pom.xml                    |    3 +-
 plc4j/drivers/knxnetip/pom.xml                     |    3 +-
 plc4j/drivers/modbus/pom.xml                       |    3 +-
 plc4j/drivers/opcua/pom.xml                        |    3 +-
 plc4j/drivers/open-protocol/pom.xml                |    3 +-
 plc4j/drivers/plc4x/pom.xml                        |    3 +-
 plc4j/drivers/profinet-ng/pom.xml                  |    3 +-
 plc4j/drivers/profinet/pom.xml                     |    3 +-
 plc4j/drivers/s7/pom.xml                           |    4 +-
 plc4j/drivers/simulated/pom.xml                    |    3 +-
 plc4j/drivers/slmp/pom.xml                         |    2 +-
 plc4j/drivers/umas/pom.xml                         |    2 +-
 plc4j/transports/cotp/pom.xml                      |    2 +-
 plc4j/transports/socketcan/pom.xml                 |    2 +-
 42 files changed, 63 insertions(+), 4237 deletions(-)

diff --git a/code-generation/language/java-jp/pom.xml b/code-generation/language/java-jp/pom.xml
deleted file mode 100644
index ea01b265fa..0000000000
--- a/code-generation/language/java-jp/pom.xml
+++ /dev/null
@@ -1,148 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you 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
-
-      https://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.
-  -->
-<project xmlns="http://maven.apache.org/POM/4.1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.1.0 http://maven.apache.org/xsd/maven-4.1.0.xsd">
-
-  <parent>
-    <groupId>org.apache.plc4x</groupId>
-    <artifactId>plc4x-code-generation-language</artifactId>
-    <version>1.0.0-SNAPSHOT</version>
-  </parent>
-
-  <artifactId>plc4x-code-generation-language-java-jp</artifactId>
-
-  <name>Code-Generation: Language: Java (JavaPoet)</name>
-  <description>Code generation template for generating Java code (JavaPoet based version for SPI3)</description>
-
-  <properties>
-    <project.build.outputTimestamp>2025-08-02T13:55:11Z</project.build.outputTimestamp>
-  </properties>
-
-  <build>
-    <plugins>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-surefire-plugin</artifactId>
-        <configuration>
-          <skip>true</skip>
-        </configuration>
-      </plugin>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-invoker-plugin</artifactId>
-        <executions>
-          <execution>
-            <id>integration-test</id>
-            <goals>
-              <!-- Install the current project artifacts into the maven local repo, so they can be used in the test -->
-              <goal>install</goal>
-              <!-- Execute the maven builds defines in src/test/resources -->
-              <goal>integration-test</goal>
-              <!-- Checks the results of the maven builds -->
-              <goal>verify</goal>
-            </goals>
-            <configuration>
-              <skipInvocation>${skip-code-generation-tests}</skipInvocation>
-              <debug>true</debug>
-              <!-- Use the "test" scope for filling the tests local repository -->
-              <scope>test</scope>
-              <streamLogsOnFailures>true</streamLogsOnFailures>
-              <localRepositoryPath>${project.build.directory}/local-repo</localRepositoryPath>
-              <projectsDirectory>src/test/resources</projectsDirectory>
-              <cloneProjectsTo>${project.build.directory}/integration-tests</cloneProjectsTo>
-              <settingsFile>src/test/resources/settings.xml</settingsFile>
-              <extraArtifacts>
-                <extraArtifact>org.apache.plc4x.plugins:plc4x-code-generation-language-base:${plc4x-code-generation.version}</extraArtifact>
-                <extraArtifact>org.apache.plc4x.plugins:plc4x-maven-plugin:${plc4x-code-generation.version}</extraArtifact>
-                <extraArtifact>org.apache.plc4x.plugins:plc4x-code-generation-protocol-base:${plc4x-code-generation.version}</extraArtifact>
-                <extraArtifact>org.apache.plc4x.plugins:plc4x-code-generation-types-base:${plc4x-code-generation.version}</extraArtifact>
-              </extraArtifacts>
-              <pomIncludes>
-                <pomInclude>*/pom.xml</pomInclude>
-              </pomIncludes>
-              <mavenOpts>--add-exports jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED</mavenOpts>
-              <!-- The goals we will be executing in the test-projects -->
-              <goals>
-                <goal>test</goal>
-              </goals>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
-    </plugins>
-  </build>
-
-  <dependencies>
-    <!-- PLC4J API -->
-    <dependency>
-      <groupId>org.apache.plc4x</groupId>
-      <artifactId>plc4j-api</artifactId>
-      <version>1.0.0-SNAPSHOT</version>
-    </dependency>
-
-    <!-- Logging -->
-    <dependency>
-      <groupId>org.slf4j</groupId>
-      <artifactId>slf4j-api</artifactId>
-    </dependency>
-
-    <!-- PLC4X Code Generation Dependencies -->
-    <dependency>
-      <groupId>org.apache.plc4x</groupId>
-      <artifactId>plc4x-code-generation-protocol-base-mspec</artifactId>
-      <version>1.0.0-SNAPSHOT</version>
-    </dependency>
-
-    <dependency>
-      <groupId>org.apache.plc4x.plugins</groupId>
-      <artifactId>plc4x-code-generation-types-base</artifactId>
-      <version>${plc4x-code-generation.version}</version>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.plc4x.plugins</groupId>
-      <artifactId>plc4x-code-generation-language-base</artifactId>
-      <version>${plc4x-code-generation.version}</version>
-    </dependency>
-
-    <!-- Just needed for some utility methods -->
-    <dependency>
-      <groupId>org.apache.plc4x</groupId>
-      <artifactId>plc4j-spi-utils</artifactId>
-      <version>1.0.0-SNAPSHOT</version>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.plc4x</groupId>
-      <artifactId>plc4j-spi-buffers-api</artifactId>
-      <version>1.0.0-SNAPSHOT</version>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.plc4x</groupId>
-      <artifactId>plc4j-spi-buffers-byte</artifactId>
-      <version>1.0.0-SNAPSHOT</version>
-    </dependency>
-
-    <!-- https://github.com/palantir/javapoet -->
-    <dependency>
-      <groupId>com.palantir.javapoet</groupId>
-      <artifactId>javapoet</artifactId>
-      <version>0.17.0</version>
-    </dependency>
-  </dependencies>
-
-</project>
diff --git a/code-generation/language/java-jp/src/main/resources/META-INF/services/org.apache.plc4x.plugins.codegenerator.language.LanguageOutput b/code-generation/language/java-jp/src/main/resources/META-INF/services/org.apache.plc4x.plugins.codegenerator.language.LanguageOutput
deleted file mode 100644
index b67edbff5e..0000000000
--- a/code-generation/language/java-jp/src/main/resources/META-INF/services/org.apache.plc4x.plugins.codegenerator.language.LanguageOutput
+++ /dev/null
@@ -1,19 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you 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
-#
-#     https://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.
-#
-org.apache.plc4x.codegeneration.language.java.JavaLanguageOutput
diff --git a/code-generation/language/java/pom.xml b/code-generation/language/java/pom.xml
index 47f9fe9221..2d9310640a 100644
--- a/code-generation/language/java/pom.xml
+++ b/code-generation/language/java/pom.xml
@@ -28,7 +28,7 @@
   <artifactId>plc4x-code-generation-language-java</artifactId>
 
   <name>Code-Generation: Language: Java</name>
-  <description>Code generation template for generating Java code</description>
+  <description>Code generation template for generating Java code (JavaPoet based version for SPI3)</description>
 
   <properties>
     <project.build.outputTimestamp>2025-08-02T13:55:11Z</project.build.outputTimestamp>
@@ -89,12 +89,20 @@
   </build>
 
   <dependencies>
-    <!-- We are using the Freemarker module to generate Java code -->
+    <!-- PLC4J API -->
     <dependency>
       <groupId>org.apache.plc4x</groupId>
-      <artifactId>plc4x-code-generation-language-base-freemarker</artifactId>
+      <artifactId>plc4j-api</artifactId>
       <version>1.0.0-SNAPSHOT</version>
     </dependency>
+
+    <!-- Logging -->
+    <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-api</artifactId>
+    </dependency>
+
+    <!-- PLC4X Code Generation Dependencies -->
     <dependency>
       <groupId>org.apache.plc4x</groupId>
       <artifactId>plc4x-code-generation-protocol-base-mspec</artifactId>
@@ -104,59 +112,36 @@
     <dependency>
       <groupId>org.apache.plc4x.plugins</groupId>
       <artifactId>plc4x-code-generation-types-base</artifactId>
+      <version>${plc4x-code-generation.version}</version>
     </dependency>
-
     <dependency>
-      <groupId>org.freemarker</groupId>
-      <artifactId>freemarker</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.commons</groupId>
-      <artifactId>commons-text</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>com.google.googlejavaformat</groupId>
-      <artifactId>google-java-format</artifactId>
+      <groupId>org.apache.plc4x.plugins</groupId>
+      <artifactId>plc4x-code-generation-language-base</artifactId>
+      <version>${plc4x-code-generation.version}</version>
     </dependency>
 
-    <!-- Make sure the dependencies of the module are built first -->
+    <!-- Just needed for some utility methods -->
     <dependency>
       <groupId>org.apache.plc4x</groupId>
-      <artifactId>plc4j-api</artifactId>
+      <artifactId>plc4j-spi-utils</artifactId>
       <version>1.0.0-SNAPSHOT</version>
-      <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>org.apache.plc4x</groupId>
-      <artifactId>plc4j-spi-buffers-byte</artifactId>
+      <artifactId>plc4j-spi-buffers-api</artifactId>
       <version>1.0.0-SNAPSHOT</version>
-      <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>org.apache.plc4x</groupId>
-      <artifactId>plc4j-transports-tcp</artifactId>
-      <version>1.0.0-SNAPSHOT</version>
-      <scope>test</scope>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.plc4x</groupId>
-      <artifactId>plc4j-utils-test-utils</artifactId>
-      <version>1.0.0-SNAPSHOT</version>
-      <scope>test</scope>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.plc4x</groupId>
-      <artifactId>plc4x-code-generation-protocol-test</artifactId>
+      <artifactId>plc4j-spi-buffers-byte</artifactId>
       <version>1.0.0-SNAPSHOT</version>
-      <scope>test</scope>
     </dependency>
+
+    <!-- https://github.com/palantir/javapoet -->
     <dependency>
-      <groupId>org.apache.plc4x</groupId>
-      <artifactId>plc4x-code-generation-protocol-test</artifactId>
-      <version>1.0.0-SNAPSHOT</version>
-      <classifier>tests</classifier>
-      <type>test-jar</type>
-      <scope>test</scope>
+      <groupId>com.palantir.javapoet</groupId>
+      <artifactId>javapoet</artifactId>
+      <version>0.17.0</version>
     </dependency>
   </dependencies>
 
diff --git a/code-generation/language/java-jp/src/main/java/org/apache/plc4x/codegeneration/language/java/JavaLanguageOutput.java b/code-generation/language/java/src/main/java/org/apache/plc4x/codegeneration/language/java/JavaLanguageOutput.java
similarity index 100%
rename from code-generation/language/java-jp/src/main/java/org/apache/plc4x/codegeneration/language/java/JavaLanguageOutput.java
rename to code-generation/language/java/src/main/java/org/apache/plc4x/codegeneration/language/java/JavaLanguageOutput.java
diff --git a/code-generation/language/java-jp/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/BaseGenerator.java b/code-generation/language/java/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/BaseGenerator.java
similarity index 100%
rename from code-generation/language/java-jp/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/BaseGenerator.java
rename to code-generation/language/java/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/BaseGenerator.java
diff --git a/code-generation/language/java-jp/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/ComplexTypeGenerator.java b/code-generation/language/java/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/ComplexTypeGenerator.java
similarity index 100%
rename from code-generation/language/java-jp/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/ComplexTypeGenerator.java
rename to code-generation/language/java/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/ComplexTypeGenerator.java
diff --git a/code-generation/language/java-jp/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/ConstantsTypeGenerator.java b/code-generation/language/java/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/ConstantsTypeGenerator.java
similarity index 100%
rename from code-generation/language/java-jp/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/ConstantsTypeGenerator.java
rename to code-generation/language/java/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/ConstantsTypeGenerator.java
diff --git a/code-generation/language/java-jp/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/DataIoGenerator.java b/code-generation/language/java/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/DataIoGenerator.java
similarity index 100%
rename from code-generation/language/java-jp/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/DataIoGenerator.java
rename to code-generation/language/java/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/DataIoGenerator.java
diff --git a/code-generation/language/java-jp/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/EnumGenerator.java b/code-generation/language/java/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/EnumGenerator.java
similarity index 100%
rename from code-generation/language/java-jp/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/EnumGenerator.java
rename to code-generation/language/java/src/main/java/org/apache/plc4x/codegeneration/language/java/generators/EnumGenerator.java
diff --git a/code-generation/language/java/src/main/java/org/apache/plc4x/language/java/JavaLanguageOutput.java b/code-generation/language/java/src/main/java/org/apache/plc4x/language/java/JavaLanguageOutput.java
deleted file mode 100644
index aa3b2ddc5e..0000000000
--- a/code-generation/language/java/src/main/java/org/apache/plc4x/language/java/JavaLanguageOutput.java
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you 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
- *
- *   https://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 org.apache.plc4x.language.java;
-
-import com.google.googlejavaformat.java.Formatter;
-import com.google.googlejavaformat.java.FormatterException;
-import freemarker.template.Configuration;
-import freemarker.template.Template;
-import org.apache.commons.io.FileUtils;
-import org.apache.plc4x.plugins.codegenerator.protocol.freemarker.FreemarkerLanguageOutput;
-import org.apache.plc4x.plugins.codegenerator.protocol.freemarker.FreemarkerLanguageTemplateHelper;
-import org.apache.plc4x.plugins.codegenerator.types.definitions.TypeDefinition;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.util.*;
-
-public class JavaLanguageOutput extends FreemarkerLanguageOutput {
-
-    private static final Logger LOGGER = LoggerFactory.getLogger(JavaLanguageOutput.class);
-
-    private final Formatter formatter = new Formatter();
-
-    @Override
-    public String getName() {
-        return "Java";
-    }
-
-    @Override
-    public Set<String> supportedOptions() {
-        return new HashSet<>(Arrays.asList(
-            // Overrides the package name generated.
-            "package",
-            // Generates additional properties to save parser arguments.
-            "generate-properties-for-parser-arguments",
-            // Generates additional properties to save values of reserved fields for the case that the value differs from the expected value.
-            "generate-properties-for-reserved-fields",
-            // Map containing the type-names for external types.
-            "externalTypes"));
-    }
-
-    @Override
-    public List<String> supportedOutputFlavors() {
-        return Arrays.asList("read-write", "read-only", "passive");
-    }
-
-    @Override
-    protected List<Template> getSpecTemplates(Configuration freemarkerConfiguration) {
-        return Collections.emptyList();
-    }
-
-    @Override
-    protected List<Template> getConstantsTemplates(Configuration freemarkerConfiguration) throws IOException {
-        return List.of(freemarkerConfiguration.getTemplate("templates/java/constants-template.java.ftlh"));
-    }
-
-    @Override
-    protected List<Template> getComplexTypeTemplates(Configuration freemarkerConfiguration) throws IOException {
-        return List.of(freemarkerConfiguration.getTemplate("templates/java/complex-type-template.java.ftlh"));
-    }
-
-    @Override
-    protected List<Template> getEnumTypeTemplates(Configuration freemarkerConfiguration) throws IOException {
-        return Collections.singletonList(
-            freemarkerConfiguration.getTemplate("templates/java/enum-template.java.ftlh"));
-    }
-
-    @Override
-    protected List<Template> getDataIoTemplates(Configuration freemarkerConfiguration) throws IOException {
-        return Collections.singletonList(
-            freemarkerConfiguration.getTemplate("templates/java/data-io-template.java.ftlh"));
-    }
-
-    @Override
-    protected FreemarkerLanguageTemplateHelper getHelper(TypeDefinition thisType, String protocolName, String flavorName,
-                                                         Map<String, TypeDefinition> types, Map<String, Object> options) {
-        return new JavaLanguageTemplateHelper(thisType, protocolName, flavorName, types, options);
-    }
-
-    @Override
-    protected void postProcessTemplateOutput(File outputFile) {
-        try {
-            FileUtils.writeStringToFile(
-                outputFile,
-                formatter.formatSourceAndFixImports(
-                    FileUtils.readFileToString(outputFile, StandardCharsets.UTF_8)
-                ),
-                StandardCharsets.UTF_8
-            );
-        } catch (IOException | FormatterException e) {
-            LOGGER.error("Error formatting {}", outputFile, e);
-        }
-    }
-}
diff --git a/code-generation/language/java/src/main/java/org/apache/plc4x/language/java/JavaLanguageTemplateHelper.java b/code-generation/language/java/src/main/java/org/apache/plc4x/language/java/JavaLanguageTemplateHelper.java
deleted file mode 100644
index b541c63cad..0000000000
--- a/code-generation/language/java/src/main/java/org/apache/plc4x/language/java/JavaLanguageTemplateHelper.java
+++ /dev/null
@@ -1,1455 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you 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
- *
- *   https://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 org.apache.plc4x.language.java;
-
-import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.math.NumberUtils;
-import org.apache.commons.text.WordUtils;
-import org.apache.plc4x.plugins.codegenerator.language.mspec.model.terms.DefaultStringLiteral;
-import org.apache.plc4x.plugins.codegenerator.protocol.freemarker.BaseFreemarkerLanguageTemplateHelper;
-import org.apache.plc4x.plugins.codegenerator.protocol.freemarker.FreemarkerException;
-import org.apache.plc4x.plugins.codegenerator.protocol.freemarker.Tracer;
-import org.apache.plc4x.plugins.codegenerator.types.definitions.*;
-import org.apache.plc4x.plugins.codegenerator.types.fields.*;
-import org.apache.plc4x.plugins.codegenerator.types.references.*;
-import org.apache.plc4x.plugins.codegenerator.types.terms.*;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.time.LocalTime;
-import java.util.*;
-import java.util.function.Function;
-
-@SuppressWarnings({"unused", "WeakerAccess"})
-public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelper {
-
-    private final Map<String, Object> options;
-
-    public JavaLanguageTemplateHelper(TypeDefinition thisType, String protocolName, String flavorName, Map<String, TypeDefinition> types,
-                                      Map<String, Object> options) {
-        super(thisType, protocolName, flavorName, types);
-        this.options = options;
-    }
-
-    public String packageName() {
-        return packageName(protocolName, "java", flavorName);
-    }
-
-    public String packageName(String protocolName, String languageName, String languageFlavorName) {
-        return Optional.ofNullable((String) options.get("package")).orElseGet(() ->
-            "org.apache.plc4x." + String.join("", languageName.split("-")) + "." +
-                String.join("", protocolName.split("-")) + "." +
-                String.join("", languageFlavorName.split("-")));
-    }
-
-    @Override
-    public String getLanguageTypeNameForField(Field field) {
-        // If the referenced type is a DataIo type, the value is of type PlcValue.
-        if (field.isPropertyField()) {
-            PropertyField propertyField = field.asPropertyField().orElseThrow(IllegalStateException::new);
-            if (propertyField.getType().isComplexTypeReference()) {
-                ComplexTypeReference complexTypeReference = propertyField.getType().asComplexTypeReference().orElseThrow(IllegalStateException::new);
-                final TypeDefinition typeDefinition = getTypeDefinitions().get(complexTypeReference.getName());
-                if (typeDefinition instanceof DataIoTypeDefinition) {
-                    return "PlcValue";
-                }
-            }
-        }
-        return getLanguageTypeNameForTypeReference(((TypedField) field).getType(), !field.isOptionalField());
-    }
-
-    public String getNonPrimitiveLanguageTypeNameForField(TypedField field) {
-        return getLanguageTypeNameForTypeReference(field.getType(), false);
-    }
-
-    public String getLanguageTypeNameForSpecType(TypeReference typeReference) {
-        return getLanguageTypeNameForTypeReference(typeReference, true);
-    }
-
-    @Override
-    public String getLanguageTypeNameForTypeReference(TypeReference typeReference) {
-        return getLanguageTypeNameForTypeReference(typeReference, false);
-    }
-
-    public String getLanguageTypeNameForTypeReference(TypeReference typeReference, boolean allowPrimitive) {
-        Objects.requireNonNull(typeReference);
-        if (typeReference instanceof ArrayTypeReference) {
-            final ArrayTypeReference arrayTypeReference = (ArrayTypeReference) typeReference;
-            if (arrayTypeReference.getElementTypeReference().isByteBased()) {
-                return getLanguageTypeNameForTypeReference(arrayTypeReference.getElementTypeReference(), allowPrimitive) + "[]";
-            } else {
-                return "List<" + getLanguageTypeNameForTypeReference(arrayTypeReference.getElementTypeReference(), false) + ">";
-            }
-        }
-        // DataIo data-types always have properties of type PlcValue
-        if (typeReference.isDataIoTypeReference()) {
-            return "PlcValue";
-        }
-        if (typeReference.isNonSimpleTypeReference()) {
-            return typeReference.asNonSimpleTypeReference().orElseThrow().getName();
-        }
-        SimpleTypeReference simpleTypeReference = (SimpleTypeReference) typeReference;
-        switch (simpleTypeReference.getBaseType()) {
-            case BIT:
-                return allowPrimitive ? boolean.class.getSimpleName() : Boolean.class.getSimpleName();
-            case BYTE:
-                return allowPrimitive ? byte.class.getSimpleName() : Byte.class.getSimpleName();
-            case UINT:
-                IntegerTypeReference unsignedIntegerTypeReference = (IntegerTypeReference) simpleTypeReference;
-                if (unsignedIntegerTypeReference.getSizeInBits() <= 7) {
-                    return allowPrimitive ? byte.class.getSimpleName() : Byte.class.getSimpleName();
-                }
-                if (unsignedIntegerTypeReference.getSizeInBits() <= 15) {
-                    return allowPrimitive ? short.class.getSimpleName() : Short.class.getSimpleName();
-                }
-                if (unsignedIntegerTypeReference.getSizeInBits() <= 31) {
-                    return allowPrimitive ? int.class.getSimpleName() : Integer.class.getSimpleName();
-                }
-                if (unsignedIntegerTypeReference.getSizeInBits() <= 63) {
-                    return allowPrimitive ? long.class.getSimpleName() : Long.class.getSimpleName();
-                }
-                return BigInteger.class.getSimpleName();
-            case INT:
-                IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
-                if (integerTypeReference.getSizeInBits() <= 8) {
-                    return allowPrimitive ? byte.class.getSimpleName() : Byte.class.getSimpleName();
-                }
-                if (integerTypeReference.getSizeInBits() <= 16) {
-                    return allowPrimitive ? short.class.getSimpleName() : Short.class.getSimpleName();
-                }
-                if (integerTypeReference.getSizeInBits() <= 32) {
-                    return allowPrimitive ? int.class.getSimpleName() : Integer.class.getSimpleName();
-                }
-                if (integerTypeReference.getSizeInBits() <= 64) {
-                    return allowPrimitive ? long.class.getSimpleName() : Long.class.getSimpleName();
-                }
-                return BigInteger.class.getSimpleName();
-            case FLOAT:
-            case UFLOAT:
-                FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
-                int sizeInBits = floatTypeReference.getSizeInBits();
-                if (sizeInBits <= 32) {
-                    return allowPrimitive ? float.class.getSimpleName() : Float.class.getSimpleName();
-                }
-                if (sizeInBits <= 64) {
-                    return allowPrimitive ? double.class.getSimpleName() : Double.class.getSimpleName();
-                }
-                return BigDecimal.class.getSimpleName();
-            case STRING:
-            case VSTRING:
-                return String.class.getSimpleName();
-            case TIME:
-                return LocalTime.class.getSimpleName();
-            case DATE:
-                return LocalDate.class.getSimpleName();
-            case DATETIME:
-                return LocalDateTime.class.getSimpleName();
-
-        }
-        throw new FreemarkerException("Unsupported simple type");
-    }
-
-    public String getPlcValueTypeForTypeReference(TypeReference typeReference) {
-        if (typeReference.isArrayTypeReference() && typeReference.asArrayTypeReference().orElseThrow().getElementTypeReference().isByteBased()) {
-            return "PlcRawByteArray";
-        }
-        if (!(typeReference instanceof SimpleTypeReference)) {
-            return "PlcStruct";
-        }
-        SimpleTypeReference simpleTypeReference = (SimpleTypeReference) typeReference;
-        int sizeInBits = simpleTypeReference.getSizeInBits();
-        switch (simpleTypeReference.getBaseType()) {
-            case BIT:
-                return "PlcBOOL";
-            case BYTE:
-                return "PlcSINT";
-            case UINT:
-                if (sizeInBits <= 8) {
-                    return "PlcUSINT";
-                }
-                if (sizeInBits <= 16) {
-                    return "PlcUINT";
-                }
-                if (sizeInBits <= 32) {
-                    return "PlcUDINT";
-                }
-                if (sizeInBits <= 64) {
-                    return "PlcULINT";
-                }
-                throw new FreemarkerException("Unsupported UINT with bit length " + sizeInBits);
-            case INT:
-                if (sizeInBits <= 8) {
-                    return "PlcSINT";
-                }
-                if (sizeInBits <= 16) {
-                    return "PlcINT";
-                }
-                if (sizeInBits <= 32) {
-                    return "PlcDINT";
-                }
-                if (sizeInBits <= 64) {
-                    return "PlcLINT";
-                }
-                throw new FreemarkerException("Unsupported INT with bit length " + sizeInBits);
-            case FLOAT:
-            case UFLOAT:
-                if (sizeInBits <= 32) {
-                    return "PlcREAL";
-                }
-                if (sizeInBits <= 64) {
-                    return "PlcLREAL";
-                }
-                throw new FreemarkerException("Unsupported REAL with bit length " + sizeInBits);
-            case STRING:
-            case VSTRING:
-                return "PlcSTRING";
-            case TIME:
-            case DATE:
-            case DATETIME:
-                return "PlcTIME";
-        }
-        throw new FreemarkerException("Unsupported simple type");
-    }
-
-    @Override
-    public String getNullValueForTypeReference(TypeReference typeReference) {
-        if (typeReference instanceof SimpleTypeReference) {
-            SimpleTypeReference simpleTypeReference = (SimpleTypeReference) typeReference;
-            switch (simpleTypeReference.getBaseType()) {
-                case BIT:
-                    return "false";
-                case BYTE:
-                    return "0";
-                case UINT:
-                    IntegerTypeReference unsignedIntegerTypeReference = (IntegerTypeReference) simpleTypeReference;
-                    if (unsignedIntegerTypeReference.getSizeInBits() <= 31) {
-                        return "0";
-                    }
-                    if (unsignedIntegerTypeReference.getSizeInBits() <= 63) {
-                        return "0l";
-                    }
-                    return "null";
-                case INT:
-                    IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
-                    if (integerTypeReference.getSizeInBits() <= 32) {
-                        return "0";
-                    }
-                    if (integerTypeReference.getSizeInBits() <= 64) {
-                        return "0l";
-                    }
-                    return "null";
-                case FLOAT:
-                    FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
-                    int sizeInBits = floatTypeReference.getSizeInBits();
-                    if (sizeInBits <= 32) {
-                        return "0.0f";
-                    }
-                    if (sizeInBits <= 64) {
-                        return "0.0";
-                    }
-                    return "null";
-                case STRING:
-                case VSTRING:
-                    return "null";
-            }
-            throw new FreemarkerException("Unmapped base-type" + simpleTypeReference.getBaseType());
-        } else {
-            return "null";
-        }
-    }
-
-    public int getNumBits(SimpleTypeReference simpleTypeReference) {
-        switch (simpleTypeReference.getBaseType()) {
-            case BIT:
-                return 1;
-            case BYTE:
-                return 8;
-            case UINT:
-            case INT:
-                IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
-                return integerTypeReference.getSizeInBits();
-            case FLOAT:
-                FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
-                return floatTypeReference.getSizeInBits();
-            case STRING:
-                StringTypeReference stringTypeReference = (StringTypeReference) simpleTypeReference;
-                return stringTypeReference.getSizeInBits();
-            case VSTRING:
-                throw new IllegalArgumentException("getSizeInBits doesn't work for 'vstring' fields");
-            default:
-                return 0;
-        }
-    }
-
-    @Deprecated
-    @Override
-    public String getReadBufferReadMethodCall(SimpleTypeReference simpleTypeReference, String valueString, TypedField field) {
-        return "/*TODO: migrate me*/" + getReadBufferReadMethodCall("", simpleTypeReference, valueString, field);
-    }
-
-    @Deprecated
-    public String getReadBufferReadMethodCall(String logicalName, SimpleTypeReference simpleTypeReference, String valueString, TypedField field) {
-        switch (simpleTypeReference.getBaseType()) {
-            case BIT:
-                String bitType = "Bit";
-                return "/*TODO: migrate me*/" + "readBuffer.read" + bitType + "(\"" + logicalName + "\")";
-            case BYTE:
-                String byteType = "Byte";
-                return "/*TODO: migrate me*/" + "readBuffer.read" + byteType + "(\"" + logicalName + "\")";
-            case UINT:
-                String unsignedIntegerType;
-                IntegerTypeReference unsignedIntegerTypeReference = (IntegerTypeReference) simpleTypeReference;
-                if (unsignedIntegerTypeReference.getSizeInBits() <= 7) {
-                    unsignedIntegerType = "UnsignedByte";
-                } else if (unsignedIntegerTypeReference.getSizeInBits() <= 15) {
-                    unsignedIntegerType = "UnsignedShort";
-                } else if (unsignedIntegerTypeReference.getSizeInBits() <= 31) {
-                    unsignedIntegerType = "UnsignedInt";
-                } else if (unsignedIntegerTypeReference.getSizeInBits() <= 63) {
-                    unsignedIntegerType = "UnsignedLong";
-                } else {
-                    unsignedIntegerType = "UnsignedBigInteger";
-                }
-                return "/*TODO: migrate me*/" + "readBuffer.read" + unsignedIntegerType + "(\"" + logicalName + "\", " + simpleTypeReference.getSizeInBits() + ")";
-            case INT:
-                String integerType;
-                if (simpleTypeReference.getSizeInBits() <= 8) {
-                    integerType = "SignedByte";
-                } else if (simpleTypeReference.getSizeInBits() <= 16) {
-                    integerType = "Short";
-                } else if (simpleTypeReference.getSizeInBits() <= 32) {
-                    integerType = "Int";
-                } else if (simpleTypeReference.getSizeInBits() <= 64) {
-                    integerType = "Long";
-                } else {
-                    integerType = "BigInteger";
-                }
-                return "/*TODO: migrate me*/" + "readBuffer.read" + integerType + "(\"" + logicalName + "\", " + simpleTypeReference.getSizeInBits() + ")";
-            case FLOAT:
-                String floatType = (simpleTypeReference.getSizeInBits() <= 32) ? "Float" : "Double";
-                return "/*TODO: migrate me*/" + "readBuffer.read" + floatType + "(\"" + logicalName + "\", " + simpleTypeReference.getSizeInBits() + ")";
-            case STRING:
-            case VSTRING:
-                String stringType = "String";
-                final Term encodingTerm = field.getEncoding().orElse(new DefaultStringLiteral("UTF8"));
-                if (!(encodingTerm instanceof StringLiteral)) {
-                    throw new IllegalArgumentException("Encoding must be a quoted string value");
-                }
-                String encoding = ((StringLiteral) encodingTerm).getValue();
-                String length = Integer.toString(simpleTypeReference.getSizeInBits());
-                if (simpleTypeReference.getBaseType() == SimpleTypeReference.SimpleBaseType.VSTRING) {
-                    VstringTypeReference vstringTypeReference = (VstringTypeReference) simpleTypeReference;
-                    length = toParseExpression(field, INT_TYPE_REFERENCE, vstringTypeReference.getLengthExpression(), null);
-                }
-                return "/*TODO: migrate me*/" + "readBuffer.read" + stringType + "(\"" + logicalName + "\", " + length + ", WithOption.WithEncoding(\"" +
-                    encoding + "\"))";
-        }
-        return "/*TODO: migrate me*/" + "";
-    }
-
-    public String getDataReaderCall(TypeReference typeReference) {
-        return getDataReaderCall(typeReference, "enumForValue");
-    }
-
-    public String getDataReaderCall(TypeReference typeReference, String resolverMethod) {
-        if (typeReference.isEnumTypeReference()) {
-            final String languageTypeName = getLanguageTypeNameForTypeReference(typeReference);
-            final SimpleTypeReference enumBaseTypeReference = getEnumBaseTypeReference(typeReference);
-            return "readEnum(" + languageTypeName + "::" + resolverMethod + ", " + getDataReaderCall(enumBaseTypeReference) + ")";
-        } else if (typeReference.isArrayTypeReference()) {
-            final ArrayTypeReference arrayTypeReference = typeReference.asArrayTypeReference().orElseThrow();
-            return getDataReaderCall(arrayTypeReference.getElementTypeReference(), resolverMethod);
-        } else if (typeReference.isSimpleTypeReference()) {
-            SimpleTypeReference simpleTypeReference = typeReference.asSimpleTypeReference().orElseThrow(IllegalStateException::new);
-            return getDataReaderCall(simpleTypeReference);
-        } else if (typeReference.isComplexTypeReference()) {
-            StringBuilder paramsString = new StringBuilder();
-            ComplexTypeReference complexTypeReference = typeReference.asComplexTypeReference().orElseThrow(IllegalStateException::new);
-            ComplexTypeDefinition typeDefinition = complexTypeReference.getTypeDefinition();
-            String parserCallString = getLanguageTypeNameForTypeReference(typeReference);
-            // In case of DataIo we actually need to use the type name and not what above returns.
-            // (In this case the mspec type name and the result type name differ)
-            if (typeReference.isDataIoTypeReference()) {
-                parserCallString = typeReference.asDataIoTypeReference().orElseThrow().getName();
-            }
-            if (typeDefinition.isDiscriminatedChildTypeDefinition()) {
-                parserCallString = "(" + getLanguageTypeNameForTypeReference(typeReference) + ") " + typeDefinition.getParentType().orElseThrow().getName();
-            }
-            List<Term> paramTerms = complexTypeReference.getParams().orElse(Collections.emptyList());
-            for (int i = 0; i < paramTerms.size(); i++) {
-                Term paramTerm = paramTerms.get(i);
-                final TypeReference argumentType = getArgumentType(complexTypeReference, i);
-                paramsString
-                    .append(", (")
-                    .append(getLanguageTypeNameForTypeReference(argumentType, true))
-                    .append(") (")
-                    .append(toParseExpression(null, argumentType, paramTerm, null))
-                    .append(")");
-            }
-            return "readComplex(() -> " + parserCallString + ".staticParse(readBuffer" + paramsString + "), readBuffer)";
-        } else {
-            throw new IllegalStateException("What is this type? " + typeReference);
-        }
-    }
-
-    public String getDataReaderCall(SimpleTypeReference simpleTypeReference) {
-        final int sizeInBits = simpleTypeReference.getSizeInBits();
-        switch (simpleTypeReference.getBaseType()) {
-            case BIT:
-                return "readBoolean(readBuffer)";
-            case BYTE:
-                return "readByte(readBuffer, " + sizeInBits + ")";
-            case UINT:
-                if (sizeInBits <= 7) return "readUnsignedByte(readBuffer, " + sizeInBits + ")";
-                if (sizeInBits <= 15) return "readUnsignedShort(readBuffer, " + sizeInBits + ")";
-                if (sizeInBits <= 31) return "readUnsignedInt(readBuffer, " + sizeInBits + ")";
-                if (sizeInBits <= 63) return "readUnsignedLong(readBuffer, " + sizeInBits + ")";
-                return "readUnsignedBigInteger(readBuffer, " + sizeInBits + ")";
-            case INT:
-                if (sizeInBits <= 8) return "readSignedByte(readBuffer, " + sizeInBits + ")";
-                if (sizeInBits <= 16) return "readSignedShort(readBuffer, " + sizeInBits + ")";
-                if (sizeInBits <= 32) return "readSignedInt(readBuffer, " + sizeInBits + ")";
-                if (sizeInBits <= 64) return "readSignedLong(readBuffer, " + sizeInBits + ")";
-                return "readSignedBigInteger(readBuffer, " + sizeInBits + ")";
-            case FLOAT:
-                if (sizeInBits <= 32) return "readFloat(readBuffer, " + sizeInBits + ")";
-                if (sizeInBits <= 64) return "readDouble(readBuffer, " + sizeInBits + ")";
-                return "readBigDecimal(readBuffer, " + sizeInBits + ")";
-            case STRING:
-                return "readString(readBuffer, " + sizeInBits + ")";
-            case VSTRING:
-                VstringTypeReference vstringTypeReference = (VstringTypeReference) simpleTypeReference;
-                return "readString(readBuffer, " + toParseExpression(null, INT_TYPE_REFERENCE, vstringTypeReference.getLengthExpression(), null) + ")";
-            case TIME:
-                return "readTime(readBuffer)";
-            case DATE:
-                return "readDate(readBuffer)";
-            case DATETIME:
-                return "readDateTime(readBuffer)";
-            default:
-                throw new UnsupportedOperationException("Unsupported type " + simpleTypeReference.getBaseType());
-        }
-    }
-
-    public String getDataWriterCall(TypeReference typeReference, String fieldName) {
-        if (typeReference.isSimpleTypeReference()) {
-            SimpleTypeReference simpleTypeReference = typeReference.asSimpleTypeReference().orElseThrow(IllegalStateException::new);
-            return getDataWriterCall(simpleTypeReference);
-        } else if (typeReference.isArrayTypeReference()) {
-            final ArrayTypeReference arrayTypeReference = typeReference.asArrayTypeReference().orElseThrow();
-            return getDataWriterCall(arrayTypeReference.getElementTypeReference(), fieldName);
-        } else if (typeReference.isComplexTypeReference()) {
-            return "writeComplex(writeBuffer)";
-        } else {
-            throw new IllegalStateException("What is this type? " + typeReference);
-        }
-    }
-
-    public String getEnumDataWriterCall(EnumTypeReference typeReference, String fieldName, String attributeName) {
-        if (!typeReference.isEnumTypeReference()) {
-            throw new IllegalArgumentException("this method should only be called for enum types");
-        }
-        final String languageTypeName = getLanguageTypeNameForTypeReference(typeReference);
-        SimpleTypeReference outputTypeReference;
-        if ("value".equals(attributeName)) {
-            outputTypeReference = getEnumBaseTypeReference(typeReference);
-        } else {
-            outputTypeReference = getEnumFieldSimpleTypeReference(typeReference.asNonSimpleTypeReference().orElseThrow(), attributeName);
-        }
-        return "writeEnum(" + languageTypeName + "::get" + StringUtils.capitalize(attributeName) + ", " + languageTypeName + "::name, " + getDataWriterCall(outputTypeReference, fieldName) + ")";
-    }
-
-    public String getDataWriterCall(SimpleTypeReference simpleTypeReference) {
-        final int sizeInBits = simpleTypeReference.getSizeInBits();
-        switch (simpleTypeReference.getBaseType()) {
-            case BIT:
-                return "writeBoolean(writeBuffer)";
-            case BYTE:
-                return "writeByte(writeBuffer, " + sizeInBits + ")";
-            case UINT:
-                if (sizeInBits <= 7) return "writeUnsignedByte(writeBuffer, " + sizeInBits + ")";
-                if (sizeInBits <= 15) return "writeUnsignedShort(writeBuffer, " + sizeInBits + ")";
-                if (sizeInBits <= 31) return "writeUnsignedInt(writeBuffer, " + sizeInBits + ")";
-                if (sizeInBits <= 63) return "writeUnsignedLong(writeBuffer, " + sizeInBits + ")";
-                return "writeUnsignedBigInteger(writeBuffer, " + sizeInBits + ")";
-            case INT:
-                if (sizeInBits <= 8) return "writeSignedByte(writeBuffer, " + sizeInBits + ")";
-                if (sizeInBits <= 16) return "writeSignedShort(writeBuffer, " + sizeInBits + ")";
-                if (sizeInBits <= 32) return "writeSignedInt(writeBuffer, " + sizeInBits + ")";
-                if (sizeInBits <= 64) return "writeSignedLong(writeBuffer, " + sizeInBits + ")";
-                return "writeSignedBigInteger(writeBuffer, " + sizeInBits + ")";
-            case FLOAT:
-                if (sizeInBits <= 32) return "writeFloat(writeBuffer, " + sizeInBits + ")";
-                if (sizeInBits <= 64) return "writeDouble(writeBuffer, " + sizeInBits + ")";
-                return "writeBigDecimal(writeBuffer, " + sizeInBits + ")";
-            case STRING:
-                return "writeString(writeBuffer, " + sizeInBits + ")";
-            case VSTRING:
-                VstringTypeReference vstringTypeReference = (VstringTypeReference) simpleTypeReference;
-                return "writeString(writeBuffer, " + toParseExpression(null, INT_TYPE_REFERENCE, vstringTypeReference.getLengthExpression(), null) + ")";
-            case TIME:
-                return "writeTime(writeBuffer)";
-            case DATE:
-                return "writeDate(writeBuffer)";
-            case DATETIME:
-                return "writeDateTime(writeBuffer)";
-            default:
-                throw new UnsupportedOperationException("Unsupported type " + simpleTypeReference.getBaseType());
-        }
-    }
-
-    @Deprecated
-    @Override
-    public String getWriteBufferWriteMethodCall(SimpleTypeReference simpleTypeReference, String fieldName, TypedField field) {
-        return "/*TODO: migrate me*/" + getWriteBufferWriteMethodCall("", simpleTypeReference, fieldName, field);
-    }
-
-    @Deprecated
-    public String getWriteBufferWriteMethodCall(String logicalName, SimpleTypeReference simpleTypeReference, String fieldName, TypedField field, String... writerArgs) {
-        String writerArgsString = "";
-        if (writerArgs.length > 0) {
-            writerArgsString += ", " + StringUtils.join(writerArgs, ", ");
-        }
-        switch (simpleTypeReference.getBaseType()) {
-            case BIT:
-                return "/*TODO: migrate me*/" + "writeBuffer.writeBit(\"" + logicalName + "\", (boolean) " + fieldName + "" + writerArgsString + ")";
-            case BYTE:
-                ByteTypeReference byteTypeReference = (ByteTypeReference) simpleTypeReference;
-                return "/*TODO: migrate me*/" + "writeBuffer.writeByte(\"" + logicalName + "\", ((Number) " + fieldName + ").byteValue()" + writerArgsString + ")";
-            case UINT:
-                IntegerTypeReference unsignedIntegerTypeReference = (IntegerTypeReference) simpleTypeReference;
-                if (unsignedIntegerTypeReference.getSizeInBits() <= 7) {
-                    return "/*TODO: migrate me*/" + "writeBuffer.writeUnsignedByte(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ", ((Number) " + fieldName + ").byteValue()" + writerArgsString + ")";
-                }
-                if (unsignedIntegerTypeReference.getSizeInBits() <= 15) {
-                    return "/*TODO: migrate me*/" + "writeBuffer.writeUnsignedShort(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ", ((Number) " + fieldName + ").shortValue()" + writerArgsString + ")";
-                }
-                if (unsignedIntegerTypeReference.getSizeInBits() <= 31) {
-                    return "/*TODO: migrate me*/" + "writeBuffer.writeUnsignedInt(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ", ((Number) " + fieldName + ").intValue()" + writerArgsString + ")";
-                }
-                if (unsignedIntegerTypeReference.getSizeInBits() <= 63) {
-                    return "/*TODO: migrate me*/" + "writeBuffer.writeUnsignedLong(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ", ((Number) " + fieldName + ").longValue()" + writerArgsString + ")";
-                }
-                return "/*TODO: migrate me*/" + "writeBuffer.writeUnsignedBigInteger(\"" + logicalName + "\", " + unsignedIntegerTypeReference.getSizeInBits() + ", (BigInteger) " + fieldName + "" + writerArgsString + ")";
-            case INT:
-                IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
-                if (integerTypeReference.getSizeInBits() <= 8) {
-                    return "/*TODO: migrate me*/" + "writeBuffer.writeSignedByte(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", ((Number) " + fieldName + ").byteValue()" + writerArgsString + ")";
-                }
-                if (integerTypeReference.getSizeInBits() <= 16) {
-                    return "/*TODO: migrate me*/" + "writeBuffer.writeShort(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", ((Number) " + fieldName + ").shortValue()" + writerArgsString + ")";
-                }
-                if (integerTypeReference.getSizeInBits() <= 32) {
-                    return "/*TODO: migrate me*/" + "writeBuffer.writeInt(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", ((Number) " + fieldName + ").intValue()" + writerArgsString + ")";
-                }
-                if (integerTypeReference.getSizeInBits() <= 64) {
-                    return "/*TODO: migrate me*/" + "writeBuffer.writeLong(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", ((Number) " + fieldName + ").longValue()" + writerArgsString + ")";
-                }
-                return "/*TODO: migrate me*/" + "writeBuffer.writeBigInteger(\"" + logicalName + "\", " + integerTypeReference.getSizeInBits() + ", BigInteger.valueOf( " + fieldName + ")" + writerArgsString + ")";
-            case FLOAT:
-            case UFLOAT:
-                FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
-                if (floatTypeReference.getSizeInBits() <= 32) {
-                    return "/*TODO: migrate me*/" + "writeBuffer.writeFloat(\"" + logicalName + "\", " + floatTypeReference.getSizeInBits() + "," + fieldName + "" + writerArgsString + ")";
-                } else if (floatTypeReference.getSizeInBits() <= 64) {
-                    return "/*TODO: migrate me*/" + "writeBuffer.writeDouble(\"" + logicalName + "\", " + floatTypeReference.getSizeInBits() + "," + fieldName + "" + writerArgsString + ")";
-                } else {
-                    throw new RuntimeException("Unsupported float type");
-                }
-            case STRING:
-            case VSTRING:
-                final Term encodingTerm = field.getEncoding().orElse(new DefaultStringLiteral("UTF8"));
-                if (!(encodingTerm instanceof StringLiteral)) {
-                    throw new RuntimeException("Encoding must be a quoted string value");
-                }
-                String encoding = ((StringLiteral) encodingTerm).getValue();
-                String length = Integer.toString(simpleTypeReference.getSizeInBits());
-                if (simpleTypeReference.getBaseType() == SimpleTypeReference.SimpleBaseType.VSTRING) {
-                    VstringTypeReference vstringTypeReference = (VstringTypeReference) simpleTypeReference;
-                    length = toSerializationExpression(field, INT_TYPE_REFERENCE, vstringTypeReference.getLengthExpression(), thisType.getParserArguments().orElse(Collections.emptyList()));
-                }
-                return "/*TODO: migrate me*/" + "writeBuffer.writeString(\"" + logicalName + "\", " + length + ", (String) " + fieldName + "" + writerArgsString + ", WithOption.WithEncoding(\"" + encoding + "\"))";
-        }
-        throw new FreemarkerException("Unmapped basetype" + simpleTypeReference.getBaseType());
-    }
-
-    public boolean isRawByteArray(DiscriminatedComplexTypeDefinition currentCase) {
-        Optional<Field> valueFieldOptional = currentCase.getFields().stream().filter(field -> field.isNamedField() && field.asNamedField().orElseThrow().getName().equals("value")).findFirst();
-        if (valueFieldOptional.isPresent()) {
-            Field valueField = valueFieldOptional.get();
-            if (valueField.isTypedField()) {
-                TypedField typedField = valueField.asTypedField().orElseThrow();
-                return typedField.getType().isArrayTypeReference() && typedField.getType().asArrayTypeReference().orElseThrow().getElementTypeReference().isByteBased();
-            }
-        }
-        return false;
-    }
-
-    public String getDataIoPropertyValue(PropertyField propertyField) {
-        TypeReference propertyFieldType = propertyField.getType();
-        if (propertyFieldType.isSimpleTypeReference()) {
-            SimpleTypeReference simpleTypeReference = propertyFieldType.asSimpleTypeReference().orElseThrow();
-            switch (propertyField.getName()) {
-                case "value":
-                    return "_value.get" + getLanguageTypeNameForTypeReference(simpleTypeReference) + "()";
-                case "year":
-                    return "_value.getDate().getYear()";
-                case "month":
-                    return "_value.getDate().getMonthValue()";
-                case "day":
-                case "dayOfMonth":
-                    return "_value.getDate().getDayOfMonth()";
-                case "dayOfWeek":
-                    return "_value.getDate().getDayOfWeek().getValue()";
-                case "hour", "hours":
-                    return "_value.getTime().getHour()";
-                case "minutes":
-                    return "_value.getTime().getMinute()";
-                case "seconds":
-                    return "_value.getTime().getSecond()";
-                case "secondsSinceEpoch":
-                    return "_value.getDateTime().toEpochSecond(ZoneOffset.UTC)";
-                case "centiseconds":
-                    return "(_value.getDuration().toMillis() / 10)";
-                case "milliseconds":
-                    return "_value.getDuration().toMillis()";
-                case "millisecondsOfSecond":
-                    return "_value.getTime().get(ChronoField.MILLI_OF_SECOND)";
-                case "millisecondsSinceMidnight":
-                    if (simpleTypeReference.getSizeInBits() <= 63) {
-                        return "_value.getTime().getLong(ChronoField.MILLI_OF_DAY)";
-                    } else {
-                        return "BigInteger.valueOf(_value.getTime().getLong(ChronoField.MILLI_OF_DAY))";
-                    }
-                case "nanoseconds":
-                    if (simpleTypeReference.getSizeInBits() <= 63) {
-                        return "_value.getDuration().toNanos()";
-                    } else {
-                        return "BigInteger.valueOf(_value.getDuration().toNanos())";
-                    }
-                case "nanosecondsSinceMidnight":
-                    if (simpleTypeReference.getSizeInBits() <= 63) {
-                        return "_value.getTime().getLong(ChronoField.NANO_OF_DAY)";
-                    } else {
-                        return "BigInteger.valueOf(_value.getTime().getLong(ChronoField.NANO_OF_DAY))";
-                    }
-                case "nanosecondsOfSecond":
-                    if (simpleTypeReference.getSizeInBits() <= 63) {
-                        return "_value.getTime().getLong(ChronoField.NANO_OF_SECOND)";
-                    } else {
-                        return "BigInteger.valueOf(_value.getTime().getLong(ChronoField.NANO_OF_SECOND))";
-                    }
-                case "nanosecondsSinceEpoch":
-                    return "BigInteger.valueOf(_value.getDateTime().toEpochSecond(ZoneOffset.UTC)).multiply(BigInteger.valueOf(1000000000)).add(BigInteger.valueOf(_value.getDateTime().getNano()))";
-                default:
-                    throw new UnsupportedOperationException(String.format("Unsupported field name %s.", propertyField.getName()));
-            }
-        }
-        throw new UnsupportedOperationException("Non Simple types not yet supported.");
-    }
-
-    public String getReservedValue(ReservedField reservedField) {
-        final String languageTypeName = getLanguageTypeNameForTypeReference(reservedField.getType(), true);
-        if ("BigInteger".equals(languageTypeName)) {
-            return "BigInteger.valueOf(" + reservedField.getReferenceValue() + ")";
-        } else {
-            return "(" + languageTypeName + ") " + reservedField.getReferenceValue();
-        }
-    }
-
-    /**
-     * @param field           this generally only is needed in order to access field attributes such as encoding etc.
-     * @param resultType      the type the resulting expression should have
-     * @param term            the term representing the expression
-     * @param parserArguments any parser arguments, which could be referenced in expressions (Needed for getting the type)
-     * @return Java code which does the things defined in 'term'
-     */
-    public String toParseExpression(Field field, TypeReference resultType, Term term, List<Argument> parserArguments) {
-        Tracer tracer = Tracer.start("toParseExpression");
-        return tracer + toExpression(field, resultType, term, variableLiteral -> tracer.dive("variableExpressionGenerator") + toVariableParseExpression(field, resultType, variableLiteral, parserArguments));
-    }
-
-    /**
-     * @param field               this generally only is needed in order to access field attributes such as encoding etc.
-     * @param resultType          the type the resulting expression should have
-     * @param term                the term representing the expression
-     * @param serializerArguments any serializer arguments, which could be referenced in expressions (Needed for getting the type)
-     * @return Java code which does the things defined in 'term'
-     */
-    public String toSerializationExpression(Field field, TypeReference resultType, Term term, List<Argument> serializerArguments) {
-        Tracer tracer = Tracer.start("toSerializationExpression");
-        return tracer + toExpression(field, resultType, term, variableLiteral -> tracer.dive("variableExpressionGenerator") + toVariableSerializationExpression(field, resultType, variableLiteral, serializerArguments));
-    }
-
-    private String toExpression(Field field, TypeReference resultType, Term term, Function<VariableLiteral, String> variableExpressionGenerator) {
-        Tracer tracer = Tracer.start("toExpression");
-        if (term == null) {
-            return tracer + "";
-        }
-        if (term instanceof Literal) {
-            return toLiteralTermExpression(field, resultType, (Literal) term, variableExpressionGenerator, tracer);
-        } else if (term instanceof UnaryTerm) {
-            return toUnaryTermExpression(field, resultType, (UnaryTerm) term, variableExpressionGenerator, tracer);
-        } else if (term instanceof BinaryTerm) {
-            return toBinaryTermExpression(field, resultType, (BinaryTerm) term, variableExpressionGenerator, tracer);
-        } else if (term instanceof TernaryTerm) {
-            return toTernaryTermExpression(field, resultType, (TernaryTerm) term, variableExpressionGenerator, tracer);
-        } else {
-            throw new RuntimeException("Unsupported Term type " + term.getClass().getName() + ". Actual type " + resultType);
-        }
-    }
-
-    private String toLiteralTermExpression(Field field, TypeReference resultType, Literal literal, Function<VariableLiteral, String> variableExpressionGenerator, Tracer tracer) {
-        tracer = tracer.dive("literal term instanceOf");
-        if (literal instanceof NullLiteral) {
-            tracer = tracer.dive("null literal instanceOf");
-            return tracer + "null";
-        } else if (literal instanceof BooleanLiteral) {
-            tracer = tracer.dive("boolean literal instanceOf");
-            return tracer + Boolean.toString(((BooleanLiteral) literal).getValue());
-        } else if (literal instanceof NumericLiteral) {
-            tracer = tracer.dive("numeric literal instanceOf");
-            final String numberString = ((NumericLiteral) literal).getNumber().toString();
-            if (resultType.isIntegerTypeReference()) {
-                final IntegerTypeReference integerTypeReference = resultType.asIntegerTypeReference().orElseThrow(RuntimeException::new);
-                if (integerTypeReference.getBaseType() == SimpleTypeReference.SimpleBaseType.UINT && integerTypeReference.getSizeInBits() >= 32) {
-                    tracer = tracer.dive("uint >= 32bit");
-                    return tracer + numberString + "L";
-                } else if (integerTypeReference.getBaseType() == SimpleTypeReference.SimpleBaseType.INT && integerTypeReference.getSizeInBits() > 32) {
-                    tracer = tracer.dive("int > 32bit");
-                    return tracer + numberString + "L";
-                }
-            } else if (resultType.isFloatTypeReference()) {
-                final FloatTypeReference floatTypeReference = resultType.asFloatTypeReference().orElseThrow(RuntimeException::new);
-                if (floatTypeReference.getSizeInBits() <= 32) {
-                    tracer = tracer.dive("float < 32bit");
-                    return tracer + numberString + "F";
-                }
-            }
-            return tracer + numberString;
-        } else if (literal instanceof HexadecimalLiteral) {
-            tracer = tracer.dive("hexadecimal literal instanceOf");
-            final String hexString = ((HexadecimalLiteral) literal).getHexString();
-            if (resultType.isIntegerTypeReference()) {
-                final IntegerTypeReference integerTypeReference = resultType.asIntegerTypeReference().orElseThrow(RuntimeException::new);
-                if (integerTypeReference.getBaseType() == SimpleTypeReference.SimpleBaseType.UINT && integerTypeReference.getSizeInBits() >= 32) {
-                    tracer = tracer.dive("uint >= 32bit");
-                    return tracer + hexString + "L";
-                } else if (integerTypeReference.getBaseType() == SimpleTypeReference.SimpleBaseType.INT && integerTypeReference.getSizeInBits() > 32) {
-                    tracer = tracer.dive("int > 32bit");
-                    return tracer + hexString + "L";
-                }
-            }
-            return tracer + hexString;
-        } else if (literal instanceof StringLiteral) {
-            tracer = tracer.dive("string literal instanceOf");
-            return tracer + "\"" + ((StringLiteral) literal).getValue() + "\"";
-        } else if (literal instanceof VariableLiteral) {
-            tracer = tracer.dive("variable literal instanceOf");
-            VariableLiteral variableLiteral = (VariableLiteral) literal;
-            if ("curPos".equals(((VariableLiteral) literal).getName())) {
-                return "(positionAware.getPos() - startPos)";
-            }
-            // If this literal references an Enum type, then we have to output it differently.
-            if (getTypeDefinitions().get(variableLiteral.getName()) instanceof EnumTypeDefinition) {
-                tracer = tracer.dive("enum definition instanceOf");
-                VariableLiteral enumDefinitionChild = variableLiteral.getChild()
-                    .orElseThrow(() -> new RuntimeException("enum definitions should have childs"));
-                return tracer + variableLiteral.getName() + "." + enumDefinitionChild.getName() +
-                    enumDefinitionChild.getChild().map(child -> "." + toVariableExpressionRest(field, resultType, child)).orElse("");
-            } else {
-                return tracer + variableExpressionGenerator.apply(variableLiteral);
-            }
-        } else {
-            throw new RuntimeException("Unsupported Literal type " + literal.getClass().getName());
-        }
-    }
-
-    private String toUnaryTermExpression(Field field, TypeReference resultType, UnaryTerm unaryTerm, Function<VariableLiteral, String> variableExpressionGenerator, Tracer tracer) {
-        tracer = tracer.dive("unary term instanceOf");
-        Term a = unaryTerm.getA();
-        switch (unaryTerm.getOperation()) {
-            case "!":
-                tracer = tracer.dive("case !");
-                if ((resultType != getAnyTypeReference()) && !resultType.isBooleanTypeReference()) {
-                    throw new IllegalArgumentException("'!(...)' expression requires boolean type. Actual type " + resultType);
-                }
-                return tracer + "!(" + toExpression(field, resultType, a, variableExpressionGenerator) + ")";
-            case "-":
-                tracer = tracer.dive("case -");
-                if ((resultType != getAnyTypeReference()) && !resultType.isIntegerTypeReference() && !resultType.isFloatTypeReference()) {
-                    throw new IllegalArgumentException("'-(...)' expression requires integer or floating-point type. Actual type " + resultType);
-                }
-                return tracer + "-(" + toExpression(field, resultType, a, variableExpressionGenerator) + ")";
-            case "()":
-                tracer = tracer.dive("case ()");
-                return tracer + "(" + toExpression(field, resultType, a, variableExpressionGenerator) + ")";
-            default:
-                throw new RuntimeException("Unsupported unary operation type " + unaryTerm.getOperation() + ". Actual type " + resultType);
-        }
-    }
-
-    private String toBinaryTermExpression(Field field, TypeReference resultType, BinaryTerm binaryTerm, Function<VariableLiteral, String> variableExpressionGenerator, Tracer tracer) {
-        tracer = tracer.dive("binary term instanceOf");
-        Term a = binaryTerm.getA();
-        Term b = binaryTerm.getB();
-        String operation = binaryTerm.getOperation();
-        switch (operation) {
-            case "^": {
-                tracer = tracer.dive(operation);
-                if ((resultType != getAnyTypeReference()) && !resultType.isIntegerTypeReference() && !resultType.isFloatTypeReference()) {
-                    throw new IllegalArgumentException("'A^B' expression requires numeric result type. Actual type " + resultType);
-                }
-                return tracer + "Math.pow((" + toExpression(field, resultType, a, variableExpressionGenerator) + "), (" + toExpression(field, resultType, b, variableExpressionGenerator) + "))";
-            }
-            case "*":
-            case "/":
-            case "%":
-            case "+":
-            case "-": {
-                tracer = tracer.dive(operation);
-                if ((resultType != getAnyTypeReference()) && !resultType.isIntegerTypeReference() && !resultType.isFloatTypeReference()) {
-                    throw new IllegalArgumentException("'A" + operation + "B' expression requires numeric result type. Actual type " + resultType);
-                }
-                return tracer + "(" + toExpression(field, resultType, a, variableExpressionGenerator) + ") " + operation + " (" + toExpression(field, resultType, b, variableExpressionGenerator) + ")";
-            }
-            case ">>":
-            case "<<": {
-                tracer = tracer.dive(operation);
-                return tracer + "(" + toExpression(field, resultType, a, variableExpressionGenerator) + ") " + operation + " (" + toExpression(field, INT_TYPE_REFERENCE, b, variableExpressionGenerator) + ")";
-            }
-            case ">=":
-            case "<=":
-            case ">":
-            case "<":
-            case "==":
-            case "!=":
-                if ((resultType != getAnyTypeReference()) && !resultType.isBooleanTypeReference()) {
-                    throw new IllegalArgumentException("'A" + operation + "B' expression requires boolean result type. Actual type " + resultType);
-                }
-                // TODO: Try to infer the types of the arguments in this case
-                return tracer + "(" + toExpression(field, ANY_TYPE_REFERENCE, a, variableExpressionGenerator) + ") " + operation + " (" + toExpression(field, ANY_TYPE_REFERENCE, b, variableExpressionGenerator) + ")";
-            case "&&":
-            case "||":
-                if ((resultType != getAnyTypeReference()) && !resultType.isBooleanTypeReference()) {
-                    throw new IllegalArgumentException("'A" + operation + "B' expression requires boolean result type. Actual type " + resultType);
-                }
-                return tracer + "(" + toExpression(field, resultType, a, variableExpressionGenerator) + ") " + operation + " (" + toExpression(field, resultType, b, variableExpressionGenerator) + ")";
-            case "&":
-            case "|":
-                if ((resultType != getAnyTypeReference()) && !resultType.isIntegerTypeReference() && !resultType.isByteTypeReference()) {
-                    throw new IllegalArgumentException("'A" + operation + "B' expression requires byte or integer result type. Actual type " + resultType);
-                }
-                return tracer + "(" + toExpression(field, resultType, a, variableExpressionGenerator) + ") " + operation + " (" + toExpression(field, resultType, b, variableExpressionGenerator) + ")";
-            default:
-                throw new IllegalArgumentException("Unsupported ternary operation type " + operation);
-        }
-    }
-
-    private String toTernaryTermExpression(Field field, TypeReference resultType, TernaryTerm ternaryTerm, Function<VariableLiteral, String> variableExpressionGenerator, Tracer tracer) {
-        tracer = tracer.dive("ternary term instanceOf");
-        if ("if".equals(ternaryTerm.getOperation())) {
-            Term a = ternaryTerm.getA();
-            Term b = ternaryTerm.getB();
-            Term c = ternaryTerm.getC();
-            return tracer +
-                "(" +
-                "(" + toExpression(field, BOOL_TYPE_REFERENCE, a, variableExpressionGenerator) + ") ? " +
-                toExpression(field, resultType, b, variableExpressionGenerator) + " : " +
-                toExpression(field, resultType, c, variableExpressionGenerator) + "" +
-                ")";
-        } else {
-            throw new IllegalArgumentException("Unsupported ternary operation type " + ternaryTerm.getOperation() + ". Actual type " + resultType);
-        }
-    }
-
-    public String toVariableEnumAccessExpression(VariableLiteral variableLiteral) {
-        return variableLiteral.getName();
-    }
-
-    private String toVariableParseExpression(Field field, TypeReference resultType, VariableLiteral variableLiteral, List<Argument> parserArguments) {
-        Tracer tracer = Tracer.start("toVariableParseExpression");
-        // CAST expressions are special as we need to add a ".class" to the second parameter in Java.
-        if ("CAST".equals(variableLiteral.getName())) {
-            return toCastVariableParseExpression(field, resultType, variableLiteral, parserArguments, tracer);
-        }
-        // Special handling for ByteOrder enums (Built in enums)
-        else if ("BIG_ENDIAN".equals(variableLiteral.getName())) {
-            return "ByteOrder.BIG_ENDIAN";
-        } else if ("LITTLE_ENDIAN".equals(variableLiteral.getName())) {
-            return "ByteOrder.LITTLE_ENDIAN";
-        }
-        // If we're referencing an implicit field, we need to handle that differently.
-        else if (isVariableLiteralImplicitField(variableLiteral)) { // If we are accessing implicit fields, we need to rely on a local variable instead.
-            return toImplicitVariableParseExpression(field, resultType, variableLiteral, tracer);
-        }
-        // Call a static function in the drivers StaticHelper
-        else if ("STATIC_CALL".equals(variableLiteral.getName())) {
-            return toStaticCallParseExpression(field, resultType, variableLiteral, parserArguments, tracer);
-        }
-        // Call a built-in global static function
-        else if (variableLiteral.getName().equals(variableLiteral.getName().toUpperCase())) { // All uppercase names are not fields, but utility methods.
-            return toFunctionCallParseExpression(field, resultType, variableLiteral, parserArguments, tracer);
-        }
-        // The synthetic checksumRawData is a local field and should not be accessed as bean property.
-        boolean isParserArg = "readBuffer".equals(variableLiteral.getName());
-        boolean isTypeArg = "_type".equals(variableLiteral.getName());
-        if (!isParserArg && !isTypeArg && parserArguments != null) {
-            for (Argument serializerArgument : parserArguments) {
-                if (serializerArgument.getName().equals(variableLiteral.getName())) {
-                    isParserArg = true;
-                    break;
-                }
-            }
-        }
-        if (isParserArg) {
-            tracer = tracer.dive("parser arg");
-            return tracer + variableLiteral.getName() + variableLiteral.getChild().map(child -> "." + toVariableExpressionRest(field, resultType, child)).orElse("");
-        } else if (isTypeArg) {
-            tracer = tracer.dive("type arg");
-            String part = variableLiteral.getChild().map(VariableLiteral::getName).orElse("");
-            switch (part) {
-                case "name":
-                    return tracer + "\"" + field.getTypeName() + "\"";
-                case "length":
-                    return tracer + "\"" + ((SimpleTypeReference) field).getSizeInBits() + "\"";
-                case "encoding":
-                    String encoding = ((StringLiteral) field.getEncoding().orElse(new DefaultStringLiteral("UTF8"))).getValue();
-                    return tracer + "\"" + encoding + "\"";
-                default:
-                    return tracer + "";
-            }
-        } else {
-            String indexAddon = "";
-            if (variableLiteral.getIndex().isPresent()) {
-                indexAddon = ".get(" + variableLiteral.getIndex().orElseThrow() + ")";
-            }
-            return tracer + variableLiteral.getName() + indexAddon + variableLiteral.getChild().map(child -> "." + toVariableExpressionRest(field, resultType, child)).orElse("");
-        }
-    }
-
-    private String toCastVariableParseExpression(Field field, TypeReference resultType, VariableLiteral variableLiteral, List<Argument> parserArguments, Tracer tracer) {
-        tracer = tracer.dive("CAST");
-        List<Term> arguments = variableLiteral.getArgs().orElseThrow(() -> new RuntimeException("A Cast expression needs arguments"));
-        if (arguments.size() != 2) {
-            throw new RuntimeException("A CAST expression expects exactly two arguments.");
-        }
-        VariableLiteral firstArgument = arguments.get(0).asLiteral()
-            .orElseThrow(() -> new RuntimeException("First argument should be a literal"))
-            .asVariableLiteral()
-            .orElseThrow(() -> new RuntimeException("First argument should be a Variable literal"));
-        StringLiteral typeArgument = arguments.get(1).asLiteral().orElseThrow(() -> new RuntimeException("Second argument should be a String literal"))
-            .asStringLiteral()
-            .orElseThrow(() -> new RuntimeException("Second argument should be a String literal"));
-        String sb = "CAST" + "(" +
-            toVariableParseExpression(field, ANY_TYPE_REFERENCE, firstArgument, parserArguments) +
-            ", " +
-            typeArgument.getValue() + ".class)";
-        return tracer + sb + variableLiteral.getChild().map(child -> "." + toVariableExpressionRest(field, resultType, child)).orElse("");
-    }
-
-    private String toImplicitVariableParseExpression(Field field, TypeReference resultType, VariableLiteral variableLiteral, Tracer tracer) {
-        tracer = tracer.dive("implicit");
-        return tracer + variableLiteral.getName();
-    }
-
-    private String toStaticCallParseExpression(Field field, TypeReference resultType, VariableLiteral variableLiteral, List<Argument> parserArguments, Tracer tracer) {
-        tracer = tracer.dive("STATIC_CALL");
-        List<Term> arguments = variableLiteral.getArgs().orElseThrow(() -> new RuntimeException("A STATIC_CALL expression needs arguments"));
-        if (arguments.size() < 1) {
-            throw new RuntimeException("A STATIC_CALL expression expects at least one argument.");
-        }
-        // TODO: make it as static import with a emitImport so if a static call is present a "utils" package must be present in the import
-        StringBuilder sb = new StringBuilder();
-        sb.append(packageName()).append(".utils.StaticHelper.");
-        // Get the class and method name
-        String methodName = arguments.get(0).asLiteral()
-            .orElseThrow(() -> new RuntimeException("First argument should be a literal"))
-            .asStringLiteral()
-            .orElseThrow(() -> new RuntimeException("Expecting the first argument of a 'STATIC_CALL' to be a StringLiteral")).
-            getValue();
-        sb.append(methodName).append("(");
-        for (int i = 1; i < arguments.size(); i++) {
-            Term arg = arguments.get(i);
-            if (i > 1) {
-                sb.append(", ");
-            }
-            sb.append(toParseExpression(field, ANY_TYPE_REFERENCE, arg, parserArguments));
-           /*if (arg instanceof VariableLiteral) {
-                VariableLiteral variableLiteralArg = (VariableLiteral) arg;
-                // "readBuffer" is the default name of the reader argument which is always available.
-                boolean isParserArg = "readBuffer".equals(variableLiteralArg.getName());
-                boolean isTypeArg = "_type".equals(variableLiteralArg.getName());
-                if (!isParserArg && !isTypeArg && parserArguments != null) {
-                    for (Argument parserArgument : parserArguments) {
-                        if (parserArgument.getName().equals(variableLiteralArg.getName())) {
-                            isParserArg = true;
-                            break;
-                        }
-                    }
-                }
-                if (isParserArg) {
-                    sb.append(variableLiteralArg.getName()).append(variableLiteralArg.getChild().map(child -> "." + toVariableExpressionRest(child)).orElse(""));
-                } else if (isTypeArg) {// We have to manually evaluate the type information at code-generation time.
-                    String part = variableLiteralArg.getChild().map(VariableLiteral::getName).orElse("");
-                    switch (part) {
-                        case "name":
-                            sb.append("\"").append(field.getTypeName()).append("\"");
-                            break;
-                        case "length":
-                            sb.append("\"").append(((SimpleTypeReference) field).getSizeInBits()).append("\"");
-                            break;
-                        case "encoding":
-                            String encoding = ((StringLiteral) field.getEncoding().orElse(new DefaultStringLiteral("UTF8"))).getValue();
-                            sb.append("\"").append(encoding).append("\"");
-                            break;
-                    }
-                } else {
-                    sb.append(toVariableParseExpression(field, variableLiteralArg, null));
-                }
-            } else if (arg instanceof StringLiteral) {
-                sb.append(((StringLiteral) arg).getValue());
-            }*/
-        }
-        sb.append(")");
-        if (variableLiteral.getIndex().isPresent()) {
-            // TODO: If this is a byte typed field, this needs to be an array accessor instead.
-            sb.append(".get(").append(variableLiteral.getIndex().orElseThrow()).append(")");
-        }
-        return tracer + sb.toString();
-    }
-
-    private String toFunctionCallParseExpression(Field field, TypeReference resultType, VariableLiteral variableLiteral, List<Argument> parserArguments, Tracer tracer) {
-        tracer = tracer.dive("FunctionCall");
-        StringBuilder sb = new StringBuilder(variableLiteral.getName());
-        Optional<List<Term>> args = variableLiteral.getArgs();
-        if (args.isPresent()) {
-            sb.append("(");
-            boolean firstArg = true;
-            for (Term arg : args.get()) {
-                if (!firstArg) {
-                    sb.append(", ");
-                }
-                // TODO: Try to infer the type of the argument ...
-                sb.append(toParseExpression(field, ANY_TYPE_REFERENCE, arg, parserArguments));
-                firstArg = false;
-            }
-            sb.append(")");
-        }
-        if (variableLiteral.getIndex().isPresent()) {
-            // TODO: If this is a byte typed field, this needs to be an array accessor instead.
-            sb.append(".get(").append(variableLiteral.getIndex().orElseThrow()).append(")");
-        }
-        return tracer + sb.toString() + variableLiteral.getChild().map(child -> "." + toVariableExpressionRest(field, resultType, child)).orElse("");
-    }
-
-    private String toVariableSerializationExpression(Field field, TypeReference resultType, VariableLiteral variableLiteral, List<Argument> serialzerArguments) {
-        Tracer tracer = Tracer.start("variable serialization expression");
-        if ("STATIC_CALL".equals(variableLiteral.getName())) {
-            return toStaticCallSerializationExpression(field, resultType, variableLiteral, serialzerArguments, tracer);
-        }
-        // All uppercase names are not fields, but utility methods.
-        else if (variableLiteral.getName().equals(variableLiteral.getName().toUpperCase())) {
-            return toGlobalFunctionCallSerializationExpression(field, resultType, variableLiteral, serialzerArguments, tracer);
-        } else if (isVariableLiteralImplicitField(variableLiteral)) { // If we are accessing implicit fields, we need to rely on a local variable instead.
-            tracer = tracer.dive("implicit field");
-            final ImplicitField referencedImplicitField = getReferencedImplicitField(variableLiteral);
-            return tracer + toSerializationExpression(referencedImplicitField, referencedImplicitField.getType(), getReferencedImplicitField(variableLiteral).getSerializeExpression(), serialzerArguments);
-        } else if (isVariableLiteralVirtualField(variableLiteral)) {
-            tracer = tracer.dive("virtual field");
-            return tracer + toVariableExpressionRest(field, resultType, variableLiteral);
-        }
-        // The synthetic checksumRawData is a local field and should not be accessed as bean property.
-        boolean isSerializerArg = "writeBuffer".equals(variableLiteral.getName()) || "checksumRawData".equals(variableLiteral.getName()) || "_value".equals(variableLiteral.getName()) || "element".equals(variableLiteral.getName()) || "size".equals(variableLiteral.getName());
-        boolean isTypeArg = "_type".equals(variableLiteral.getName());
-        if (!isSerializerArg && !isTypeArg && serialzerArguments != null) {
-            for (Argument serializerArgument : serialzerArguments) {
-                if (serializerArgument.getName().equals(variableLiteral.getName())) {
-                    isSerializerArg = true;
-                    break;
-                }
-            }
-        }
-        if (isSerializerArg) {
-            tracer = tracer.dive("serializer arg");
-            return tracer + variableLiteral.getName() + variableLiteral.getChild().map(child -> "." + toVariableExpressionRest(field, resultType, child)).orElse("");
-        } else if (isTypeArg) {
-            tracer = tracer.dive("type arg");
-            String part = variableLiteral.getChild().map(VariableLiteral::getName).orElse("");
-            switch (part) {
-                case "name":
-                    return tracer + "\"" + field.getTypeName() + "\"";
-                case "length":
-                    return tracer + "\"" + ((SimpleTypeReference) field).getSizeInBits() + "\"";
-                case "encoding":
-                    String encoding = ((StringLiteral) field.getEncoding().orElse(new DefaultStringLiteral("UTF8"))).getValue();
-                    return tracer + "\"" + encoding + "\"";
-                default:
-                    return tracer + "";
-            }
-        } else {
-            return tracer + toVariableExpressionRest(field, resultType, variableLiteral);
-        }
-    }
-
-    private String toGlobalFunctionCallSerializationExpression(Field field, TypeReference resultType, VariableLiteral variableLiteral, List<Argument> serialzerArguments, Tracer tracer) {
-        tracer = tracer.dive("GLOBAL_FUNCTION_CALL");
-        StringBuilder sb = new StringBuilder(variableLiteral.getName());
-        Optional<List<Term>> args = variableLiteral.getArgs();
-        if (args.isPresent()) {
-            sb.append("(");
-            boolean firstArg = true;
-            for (Term arg : args.get()) {
-                if (!firstArg) {
-                    sb.append(", ");
-                }
-                sb.append(toSerializationExpression(field, ANY_TYPE_REFERENCE, arg, serialzerArguments));
-                firstArg = false;
-                /*if (arg instanceof VariableLiteral) {
-                    VariableLiteral va = (VariableLiteral) arg;
-                    boolean isSerializerArg = "readBuffer".equals(va.getName()) || "writeBuffer".equals(va.getName());
-                    boolean isTypeArg = "_type".equals(va.getName());
-                    if (!isSerializerArg && !isTypeArg && serialzerArguments != null) {
-                        for (Argument serializerArgument : serialzerArguments) {
-                            if (serializerArgument.getName().equals(va.getName())) {
-                                isSerializerArg = true;
-                                break;
-                            }
-                        }
-                    }
-                    if (isSerializerArg) {
-                        sb.append(va.getName()).append(va.getChild().map(child -> "." + toVariableExpressionRest(child)).orElse(""));
-                    } else if (isTypeArg) {
-                        String part = va.getChild().map(VariableLiteral::getName).orElse("");
-                        switch (part) {
-                            case "name":
-                                sb.append("\"").append(field.getTypeName()).append("\"");
-                                break;
-                            case "length":
-                                sb.append("\"").append(((SimpleTypeReference) field).getSizeInBits()).append("\"");
-                                break;
-                            case "encoding":
-                                String encoding = ((StringLiteral) field.getEncoding().orElse(new DefaultStringLiteral("UTF8"))).getValue();
-                                sb.append("\"").append(encoding).append("\"");
-                                break;
-                        }
-                    } else {
-                        sb.append(toVariableSerializationExpression(field, va, serialzerArguments));
-                    }
-                } else if (arg instanceof StringLiteral) {
-                    sb.append(((StringLiteral) arg).getValue());
-                }*/
-            }
-            sb.append(")");
-        }
-        return tracer + sb.toString();
-    }
-
-    private String toStaticCallSerializationExpression(Field field, TypeReference resultType, VariableLiteral variableLiteral, List<Argument> serialzerArguments, Tracer tracer) {
-        tracer = tracer.dive("STATIC_CALL");
-        StringBuilder sb = new StringBuilder();
-        List<Term> arguments = variableLiteral.getArgs().orElseThrow(() -> new RuntimeException("A STATIC_CALL expression needs arguments"));
-        if (arguments.size() < 1) {
-            throw new RuntimeException("A STATIC_CALL expression expects at least one argument.");
-        }
-        // TODO: make it as static import with a emitImport so if a static call is present a "utils" package must be present in the import
-        sb.append(packageName()).append(".utils.StaticHelper.");
-        // Get the class and method name
-        String methodName = arguments.get(0).asLiteral()
-            .orElseThrow(() -> new RuntimeException("First argument should be a literal"))
-            .asStringLiteral()
-            .orElseThrow(() -> new RuntimeException("Expecting the first argument of a 'STATIC_CALL' to be a StringLiteral")).
-            getValue();
-        //methodName = methodName.substring(1, methodName.length() - 1);
-        sb.append(methodName).append("(");
-        for (int i = 1; i < arguments.size(); i++) {
-            Term arg = arguments.get(i);
-            if (i > 1) {
-                sb.append(", ");
-            }
-            sb.append(toSerializationExpression(field, ANY_TYPE_REFERENCE, arg, serialzerArguments));
-            /*if (arg instanceof VariableLiteral) {
-                VariableLiteral va = (VariableLiteral) arg;
-                // "readBuffer" and "_value" are always available in every parser.
-                boolean isSerializerArg = "readBuffer".equals(va.getName()) || "writeBuffer".equals(va.getName()) || "_value".equals(va.getName()) || "element".equals(va.getName());
-                boolean isTypeArg = "_type".equals(va.getName());
-                if (!isSerializerArg && !isTypeArg && serialzerArguments != null) {
-                    for (Argument serializerArgument : serialzerArguments) {
-                        if (serializerArgument.getName().equals(va.getName())) {
-                            isSerializerArg = true;
-                            break;
-                        }
-                    }
-                }
-                if (isSerializerArg) {
-                    sb.append(va.getName()).append(va.getChild().map(child -> "." + toVariableExpressionRest(child)).orElse(""));
-                } else if (isTypeArg) {
-                    String part = va.getChild().map(VariableLiteral::getName).orElse("");
-                    switch (part) {
-                        case "name":
-                            sb.append("\"").append(field.getTypeName()).append("\"");
-                            break;
-                        case "length":
-                            sb.append("\"").append(((SimpleTypeReference) field).getSizeInBits()).append("\"");
-                            break;
-                        case "encoding":
-                            String encoding = ((StringLiteral) field.getEncoding().orElse(new DefaultStringLiteral("UTF8"))).getValue();
-                            sb.append("\"").append(encoding).append("\"");
-                            break;
-                    }
-                } else {
-                    sb.append(toVariableSerializationExpression(field, va, serialzerArguments));
-                }
-            } else if (arg instanceof StringLiteral) {
-                sb.append(((StringLiteral) arg).getValue());
-            }*/
-        }
-        sb.append(")");
-        return tracer + sb.toString();
-    }
-
-    private String toVariableExpressionRest(Field field, TypeReference resultType, VariableLiteral variableLiteral) {
-        Tracer tracer = Tracer.start("variable expression rest");
-        // length is kind of a keyword in mspec, so we shouldn't be naming variables length. if we ask for the length of a object we can just return length().
-        // This way we can get the length of a string when serializing
-        String variableLiteralName = variableLiteral.getName();
-        if (variableLiteralName.equals("length")) {
-            tracer = tracer.dive("length");
-            return tracer + variableLiteralName + "()" + ((variableLiteral.getIndex().isPresent() ? ".get(" + variableLiteral.getIndex().orElseThrow() + ")" : "") +
-                variableLiteral.getChild().map(child -> "." + toVariableExpressionRest(field, resultType, child)).orElse(""));
-        }
-        return tracer + "get" + WordUtils.capitalize(variableLiteralName) + "()" + ((variableLiteral.getIndex().isPresent() ? ".get(" + variableLiteral.getIndex().orElseThrow() + ")" : "") +
-            variableLiteral.getChild().map(child -> "." + toVariableExpressionRest(field, resultType, child)).orElse(""));
-    }
-
-    public String getSizeInBits(ComplexTypeDefinition complexTypeDefinition, List<Argument> parserArguments) {
-        int sizeInBits = 0;
-        StringBuilder sb = new StringBuilder();
-        for (Field field : complexTypeDefinition.getFields()) {
-            if (field instanceof ArrayField) {
-                ArrayField arrayField = (ArrayField) field;
-                final SimpleTypeReference type = (SimpleTypeReference) arrayField.getType();
-                switch (arrayField.getLoopType()) {
-                    case COUNT:
-                        sb.append("(").append(toSerializationExpression(null, INT_TYPE_REFERENCE, arrayField.getLoopExpression(), parserArguments)).append(" * ").append(type.getSizeInBits()).append(") + ");
-                        break;
-                    case LENGTH:
-                        sb.append("(").append(toSerializationExpression(null, INT_TYPE_REFERENCE, arrayField.getLoopExpression(), parserArguments)).append(" * 8) + ");
-                        break;
-                    case TERMINATED:
-                        // No terminated.
-                        break;
-                }
-            } else if (field instanceof TypedField) {
-                TypedField typedField = (TypedField) field;
-                final TypeReference type = typedField.getType();
-                if (field instanceof ManualField) {
-                    ManualField manualField = (ManualField) field;
-                    sb.append("(").append(toSerializationExpression(null, INT_TYPE_REFERENCE, manualField.getLengthExpression(), parserArguments)).append(") + ");
-                } else if (type instanceof SimpleTypeReference) {
-                    SimpleTypeReference simpleTypeReference = (SimpleTypeReference) type;
-                    if (simpleTypeReference instanceof VstringTypeReference) {
-                        sb.append(toSerializationExpression(null, INT_TYPE_REFERENCE, ((VstringTypeReference) simpleTypeReference).getLengthExpression(), parserArguments)).append(" + ");
-                    } else {
-                        sizeInBits += simpleTypeReference.getSizeInBits();
-                    }
-                }
-            }
-        }
-        return sb.toString() + sizeInBits;
-    }
-
-    public boolean requiresCurPos() {
-        if (thisType instanceof ComplexTypeDefinition) {
-            ComplexTypeDefinition complexTypeDefinition = (ComplexTypeDefinition) this.thisType;
-            for (Field curField : complexTypeDefinition.getFields()) {
-                if (requiresVariable(curField, "curPos")) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    public boolean requiresStartPos() {
-        if (thisType instanceof ComplexTypeDefinition) {
-            ComplexTypeDefinition complexTypeDefinition = (ComplexTypeDefinition) this.thisType;
-            for (Field curField : complexTypeDefinition.getFields()) {
-                if (requiresVariable(curField, "startPos")) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    public boolean requiresVariable(Field curField, String variable) {
-        if (curField.isArrayField()) {
-            ArrayField arrayField = (ArrayField) curField;
-            if (arrayField.getLoopExpression().contains(variable)) {
-                return true;
-            }
-        } else if (curField.isOptionalField()) {
-            OptionalField optionalField = (OptionalField) curField;
-            if (optionalField.getConditionExpression().isPresent() && optionalField.getConditionExpression().orElseThrow(IllegalStateException::new).contains(variable)) {
-                return true;
-            }
-        }
-        return curField.asTypedField()
-            .map(typedField -> typedField.getType().asNonSimpleTypeReference()
-                .map(nonSimpleTypeReference -> nonSimpleTypeReference.getParams()
-                    .map(params -> params.stream()
-                        .anyMatch(param -> param.contains(variable))
-                    )
-                    .orElse(false)
-                )
-                .orElse(false)
-            )
-            .orElse(false);
-    }
-
-    public String escapeValue(TypeReference typeReference, String valueString) {
-        if (valueString == null) {
-            return null;
-        }
-        if (typeReference instanceof SimpleTypeReference) {
-            SimpleTypeReference simpleTypeReference = (SimpleTypeReference) typeReference;
-            switch (simpleTypeReference.getBaseType()) {
-                case UINT:
-                case INT:
-                    // If it's a one character string and is numeric, output it as char.
-                    if (!NumberUtils.isParsable(valueString) && (valueString.length() == 1)) {
-                        return "'" + valueString + "'";
-                    }
-                    break;
-                case STRING:
-                case VSTRING:
-                    return "\"" + valueString + "\"";
-            }
-        }
-        return valueString;
-    }
-
-    public String getFieldOptions(TypedField field, List<Argument> parserArguments) {
-        StringBuilder sb = new StringBuilder();
-        field.getEncoding().ifPresent(term -> {
-            final String encoding = toParseExpression(field, field.getType(), term, parserArguments);
-            sb.append(", WithOption.WithEncoding(").append(encoding).append(")");
-        });
-
-        field.getByteOrder().ifPresent(term -> {
-            final String byteOrder = toParseExpression(field, field.getType(), term, parserArguments);
-            sb.append(", WithOption.WithByteOrder(").append(byteOrder).append(")");
-        });
-
-        field.getAttribute("nullBytesHex").ifPresent(term -> {
-            final String nullBytesHex = toParseExpression(field, field.getType(), term, parserArguments);
-            sb.append(", WithOption.WithNullBytesHex(\"").append(nullBytesHex).append("\")");
-        });
-        return sb.toString();
-    }
-
-    public boolean isBigIntegerSource(Term term) {
-        boolean isBigInteger = term.asLiteral()
-            .flatMap(LiteralConversions::asVariableLiteral)
-            .flatMap(VariableLiteral::getChild)
-            .map(Term.class::cast)
-            .map(this::isBigIntegerSource)
-            .orElse(false);
-        return isBigInteger || term.asLiteral()
-            .flatMap(LiteralConversions::asVariableLiteral)
-            .map(VariableLiteral::getTypeReference)
-            .flatMap(TypeReferenceConversions::asIntegerTypeReference)
-            .map(integerTypeReference -> integerTypeReference.getSizeInBits() >= 64)
-            .orElse(false);
-    }
-
-    public boolean needsLongMarker(Optional<SimpleTypeReference> baseTypeReference) {
-        return baseTypeReference.isPresent() && baseTypeReference.get().isIntegerTypeReference() && baseTypeReference.get().asIntegerTypeReference().orElseThrow().getSizeInBits() >= 32;
-    }
-
-    public boolean isGeneratePropertiesForParserArguments() {
-        return options.getOrDefault("generate-properties-for-parser-arguments", "false").equals("true");
-    }
-
-    public boolean isGeneratePropertiesForReservedFields() {
-        return options.getOrDefault("generate-properties-for-reserved-fields", "false").equals("true");
-    }
-
-    public String getExternalTypeImports() {
-        StringBuilder imports = new StringBuilder();
-        if (options.containsKey("externalTypes")) {
-            Object externalTypes = options.get("externalTypes");
-            if (externalTypes instanceof Map) {
-                Map<String, Object> externalTypesMap = (Map<String, Object>) externalTypes;
-                for (String mspecTypeName : externalTypesMap.keySet()) {
-                    Object obj = externalTypesMap.get(mspecTypeName);
-                    if (obj instanceof String) {
-                        imports.append("import ").append(obj).append(";\n");
-                    } else {
-                        throw new IllegalArgumentException("Type definition for " + mspecTypeName + " is invalid");
-                    }
-                }
-            }
-        }
-        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;
-    }
-
-    public boolean isVardintField(Field field) {
-        Optional<Term> encoding = field.getEncoding();
-        if (encoding.isPresent()) {
-            String encodingName = encoding.get().asLiteral().orElseThrow().asStringLiteral().orElseThrow().getValue();
-            return encodingName.equalsIgnoreCase("VARDINT");
-        }
-        return false;
-    }
-
-    public String toJDoc(String comment) {
-        StringBuilder sb = new StringBuilder();
-        sb.append("/**\n");
-        for (String line : StringUtils.split(comment, "\n")) {
-            switch (line) {
-                case "/**":
-                case "/*":
-                case "*/":
-                    continue;
-            }
-            line = StringUtils.removeStart(line, "*");
-            line = StringUtils.removeStart(line, " *");
-            line = StringUtils.removeStart(line, "//");
-            line = StringUtils.removeStart(line, "/*");
-            line = StringUtils.removeEnd(line, "*/");
-            sb.append(" * ").append(line).append("\n");
-        }
-        sb.append(" */\n");
-        return sb.toString();
-    }
-
-}
diff --git a/code-generation/language/java/src/main/resources/META-INF/services/org.apache.plc4x.plugins.codegenerator.language.LanguageOutput b/code-generation/language/java/src/main/resources/META-INF/services/org.apache.plc4x.plugins.codegenerator.language.LanguageOutput
index c81df0bb29..b67edbff5e 100644
--- a/code-generation/language/java/src/main/resources/META-INF/services/org.apache.plc4x.plugins.codegenerator.language.LanguageOutput
+++ b/code-generation/language/java/src/main/resources/META-INF/services/org.apache.plc4x.plugins.codegenerator.language.LanguageOutput
@@ -16,4 +16,4 @@
 # specific language governing permissions and limitations
 # under the License.
 #
-org.apache.plc4x.language.java.JavaLanguageOutput
+org.apache.plc4x.codegeneration.language.java.JavaLanguageOutput
diff --git a/code-generation/language/java/src/main/resources/templates/java/complex-type-template.java.ftlh b/code-generation/language/java/src/main/resources/templates/java/complex-type-template.java.ftlh
deleted file mode 100644
index efd4444ae0..0000000000
--- a/code-generation/language/java/src/main/resources/templates/java/complex-type-template.java.ftlh
+++ /dev/null
@@ -1,1094 +0,0 @@
-<#--
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you 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
-
-      https://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.
--->
-<#-- Prevent freemarker from escaping stuff -->
-<#outputformat "undefined">
-<#-- Declare the name and type of variables passed in to the template -->
-<#-- @ftlvariable name="languageName" type="java.lang.String" -->
-<#-- @ftlvariable name="protocolName" type="java.lang.String" -->
-<#-- @ftlvariable name="outputFlavor" type="java.lang.String" -->
-<#-- @ftlvariable name="helper" type="org.apache.plc4x.language.java.JavaLanguageTemplateHelper" -->
-<#-- @ftlvariable name="tracer" type="org.apache.plc4x.plugins.codegenerator.protocol.freemarker.Tracer" -->
-<#-- @ftlvariable name="type" type="org.apache.plc4x.plugins.codegenerator.types.definitions.ComplexTypeDefinition" -->
-<#-- Declare the name and type of variables declared locally inside the template -->
-${helper.packageName(protocolName, languageName, outputFlavor)?replace(".", "/")}/${type.name}.java
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you 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
- *
- *   https://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 ${helper.packageName(protocolName, languageName, outputFlavor)};
-
-import static org.apache.plc4x.java.spi.generation.StaticHelper.*;
-import static org.apache.plc4x.java.spi.codegen.io.DataReaderFactory.*;
-import static org.apache.plc4x.java.spi.codegen.io.DataWriterFactory.*;
-import static org.apache.plc4x.java.spi.codegen.fields.FieldReaderFactory.*;
-import static org.apache.plc4x.java.spi.codegen.fields.FieldWriterFactory.*;
-
-import org.apache.plc4x.java.spi.codegen.*;
-import org.apache.plc4x.java.spi.codegen.io.*;
-import org.apache.plc4x.java.spi.codegen.fields.*;
-import org.apache.plc4x.java.api.exceptions.*;
-import org.apache.plc4x.java.spi.generation.*;
-import org.apache.plc4x.java.api.value.*;
-
-import java.time.*;
-import java.util.*;
-import java.math.BigInteger;
-${helper.getExternalTypeImports()}
-
-// Code generated by code-generation. DO NOT EDIT.
-
-<#-- TODO: the code below implies that parserArguments will be null if not present... not pretty  -->
-<#if type.parserArguments.isPresent()><#assign parserArguments=type.allParserArguments.orElseThrow()></#if>
-<#if type.comment.isPresent()>${helper.toJDoc(type.comment.get())+"\n"}</#if>public<#if type.isDiscriminatedParentTypeDefinition()> abstract</#if> class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if><#if type.parentType.isPresent()> extends ${type.parentType.orElseThrow().name}</#if> implements Message {
-
-<#--
-    If this is a discriminated child type, we need to generate methods for accessing it's discriminator
-    values, as if they were normal java properties.
--->
-<#if type.isDiscriminatedChildTypeDefinition()>
-    <#assign discriminatedChildType = type.asDiscriminatedComplexTypeDefinition().orElseThrow()>
-    // Accessors for discriminator values.
-    <#list discriminatedChildType.getDiscriminatorMap() as discriminatorName, discriminatorValue>
-    <#-- If the discriminator name matches that of another field, suppress the methods generation -->
-        <#if !discriminatedChildType.isNonDiscriminatorField(discriminatorName)><#--&& !discriminatedChildType.isParserArgument(discriminatorName)-->
-            <#assign discriminatorType = helper.getDiscriminatorTypes(discriminatedChildType.parentType.orElseThrow())[discriminatorName]>
-    public ${helper.getLanguageTypeNameForTypeReference(discriminatorType)} get${discriminatorName?cap_first}() {
-            <#if discriminatorValue?? && !helper.isWildcard(discriminatorValue)>
-                <#if discriminatorType.isEnumTypeReference()>
-        return ${helper.getLanguageTypeNameForTypeReference(discriminatorType)}.${helper.toParseExpression(null, discriminatorType, discriminatorValue, parserArguments)};
-                <#else>
-        return (${helper.getLanguageTypeNameForTypeReference(discriminatorType, true)}) ${helper.toParseExpression(null, discriminatorType, discriminatorValue, parserArguments)};
-                </#if>
-            <#else>
-        return ${helper.getNullValueForTypeReference(discriminatorType)};
-            </#if>
-    }
-        </#if>
-    </#list>
-</#if>
-<#--
-    If this is a discriminated parent type, we need to generate the abstract methods for accessing it's
-    discriminator values instead.
--->
-<#if type.isDiscriminatedParentTypeDefinition()>
-    <#assign discriminatedParentType = type>
-    <#-- @ftlvariable name="discriminatedParentType" type="org.apache.plc4x.plugins.codegenerator.types.definitions.ComplexTypeDefinition" -->
-    // Abstract accessors for discriminator values.
-    <#list helper.discriminatorTypes as discriminatorName, discriminatorType>
-        <#-- If the discriminator name matches that of another field, suppress the methods generation -->
-        <#if !type.isNonDiscriminatorField(discriminatorName)><#-- && !type.isParserArgument(discriminatorName)-->
-    public abstract ${helper.getLanguageTypeNameForTypeReference(discriminatorType)} get${discriminatorName?cap_first}();
-        </#if>
-    </#list>
-</#if>
-<#-- If the current type contains "const" fields, generate some java constants for holing their values -->
-<#if type.constFields?has_content>
-
-    // Constant values.
-    <#list type.constFields as field>
-    <#if field.comment.isPresent()>${helper.toJDoc(field.comment.get())+"\n"}</#if>public static final ${helper.getLanguageTypeNameForTypeReference(field.type)} ${field.name?upper_case} = ${helper.toParseExpression(field, field.type, field.referenceValue, parserArguments)};
-    </#list>
-</#if>
-<#-- Property fields are fields that require a property in the pojo -->
-<#if type.propertyFields?has_content>
-
-    // Properties.
-    <#list type.propertyFields as field>
-    <#if field.comment.isPresent()>${helper.toJDoc(field.comment.get())+"\n"}</#if>protected final ${helper.getLanguageTypeNameForTypeReference(field.type, !field.isOptionalField())} ${field.name};
-    </#list>
-</#if>
-<#-- This list contains a list of parser arguments, that are not being used as variables for discriminator expressions in typeSwitches -->
-<#if helper.isGeneratePropertiesForParserArguments()>
-    <#if parserArguments?has_content>
-        <#assign filteredParserArguments=parserArguments?filter(arg -> !type.isDiscriminatorField(arg.name) && !type.getPropertyFieldFromThisOrParentByName(arg.name).isPresent())>
-    </#if>
-
-    <#if filteredParserArguments?has_content>
-
-    // Arguments.
-        <#list filteredParserArguments as parserArgument>
-    protected final ${helper.getLanguageTypeNameForTypeReference(parserArgument.type)} ${parserArgument.name};
-        </#list>
-    </#if>
-</#if>
-<#if helper.isGeneratePropertiesForReservedFields()>
-    <#assign reservedFields=type.getFields()?filter(f->f.isReservedField())>
-    <#if reservedFields?has_content>
-    // Reserved Fields
-        <#list reservedFields as reservedField>
-    private ${helper.getLanguageTypeNameForTypeReference(reservedField.asReservedField().orElseThrow().type, false)} reservedField${reservedField?index};
-        </#list>
-    </#if>
-</#if>
-
-    <#-- getAllPropertyFields() returns not only the property fields of this type but also of it's parents -->
-    <@compress single_line=true>
-    public ${type.name}(
-        <#assign needsSeparator = false>
-        <#list type.getAllPropertyFields() as field>
-            <#assign needsSeparator = true>
-            ${helper.getLanguageTypeNameForField(field)} ${field.name}
-            <#sep>, </#sep>
-        </#list>
-        <#if helper.isGeneratePropertiesForParserArguments()>
-            <#if filteredParserArguments?has_content>
-                <#if needsSeparator>, </#if>
-                <#list filteredParserArguments as parserArgument>
-                    ${helper.getLanguageTypeNameForTypeReference(parserArgument.type)} ${parserArgument.name}<#sep>, </#sep>
-                </#list>
-            </#if>
-        </#if>
-        ) {
-    </...@compress>
-
-    <@compress single_line=true>
-        super(
-        <#assign needsSeparator = false>
-        <#if type.parentPropertyFields?has_content>
-            <#list type.parentPropertyFields as parentField>
-                <#assign needsSeparator = true>
-                ${parentField.name}<#sep>, </#sep>
-            </#list>
-        </#if>
-        <#if helper.isGeneratePropertiesForParserArguments()>
-            <#if type.parentType.isPresent() && type.parentType.orElseThrow().allParserArguments.isPresent()>
-                <#assign filteredParentParserArguments = type.parentType.orElseThrow().allParserArguments.orElseThrow()?filter(arg -> !type.parentType.orElseThrow().asComplexTypeDefinition().orElseThrow().isDiscriminatorField(arg.name))>
-                <#if filteredParentParserArguments?has_content>
-                    <#if needsSeparator>, </#if>
-                    <#list filteredParentParserArguments as parserArgument>
-                        ${parserArgument.name}<#sep>, </#sep>
-                    </#list>
-                </#if>
-            </#if>
-        </#if>
-        );
-    </...@compress>
-
-<#list type.propertyFields as field>
-        this.${field.name} = ${field.name};
-</#list>
-<#if helper.isGeneratePropertiesForParserArguments()>
-    <#if filteredParserArguments?has_content>
-        <#list filteredParserArguments as parserArgument>
-            this.${parserArgument.name} = ${parserArgument.name};
-        </#list>
-    </#if>
-</#if>
-    }
-
-<#list type.abstractFields as field>
-    <#if field.comment.isPresent()>${helper.toJDoc(field.comment.get())+"\n"}</#if>public abstract ${helper.getLanguageTypeNameForField(field)} get${field.asNamedField().orElseThrow().name?cap_first}();
-
-</#list>
-<#list type.propertyFields as field>
-    <#if field.comment.isPresent()>${helper.toJDoc(field.comment.get())+"\n"}</#if>public ${helper.getLanguageTypeNameForField(field)} get${field.name?cap_first}() {
-        return ${field.name};
-    }
-
-</#list>
-<#list type.virtualFields as field>
-    <#if field.comment.isPresent()>${helper.toJDoc(field.comment.get())+"\n"}</#if>public ${helper.getLanguageTypeNameForField(field)} get${field.name?cap_first}() {
-        <#if helper.getLanguageTypeNameForField(field) = 'String'>
-        return ${helper.getLanguageTypeNameForField(field)}.valueOf(${helper.toSerializationExpression(field, field.type, field.valueExpression, parserArguments)});
-        <#--elseif helper.getLanguageTypeNameForField(field) = 'BigInteger' && !helper.isBigIntegerSource(field.valueExpression)-->
-        <#elseif helper.getLanguageTypeNameForField(field) = 'BigInteger'>
-        Object o = ${helper.toSerializationExpression(field, field.type, field.valueExpression, parserArguments)};
-        if (o instanceof BigInteger)
-            return (BigInteger) o;
-        return BigInteger.valueOf(((Number)o).longValue());
-        <#else>
-        return (${helper.getLanguageTypeNameForField(field)}) (${helper.toSerializationExpression(field, field.type, field.valueExpression, parserArguments)});
-        </#if>
-    }
-
-</#list>
-<#list type.constFields as field>
-    <#if field.comment.isPresent()>${helper.toJDoc(field.comment.get())+"\n"}</#if>public ${helper.getLanguageTypeNameForField(field)} get${field.name?cap_first}() {
-        return ${field.name?upper_case};
-    }
-
-</#list>
-
-    <#if outputFlavor != "passive">
-<#if type.isDiscriminatedParentTypeDefinition()>
-    protected abstract void serialize${type.name?cap_first}Child(WriteBuffer writeBuffer) throws SerializationException;
-
-</#if>
-<#if type.isDiscriminatedChildTypeDefinition()>
-    @Override
-    protected void serialize${type.parentType.orElseThrow().name}Child(WriteBuffer writeBuffer) throws SerializationException {
-<#else>
-    public void serialize(WriteBuffer writeBuffer) throws SerializationException {
-</#if>
-        PositionAware positionAware = writeBuffer;
-        <#if helper.hasFieldOfType("unknown")>
-            throw new SerializationException("Unknown field not serializable");
-        <#else>
-            boolean _lastItem = ThreadLocalHelper.lastItemThreadLocal.get();
-            <#if helper.requiresStartPos() || helper.requiresCurPos()>
-            int startPos = positionAware.getPos();
-            </#if>
-            writeBuffer.pushContext("${type.name}");
-            <#assign reservedFieldIndex=0>
-            <#list type.fields as field>
-                <#switch field.typeName>
-                    <#case "array">
-                        <#assign arrayField = field.asArrayField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Array Field (${arrayField.name})
-                        <#if arrayField.type.elementTypeReference.isByteBased()>
-                        writeByteArrayField("${namedField.name}", ${namedField.name}, writeByteArray(writeBuffer, 8)${helper.getFieldOptions(typedField, parserArguments)});
-                        <#elseif arrayField.type.elementTypeReference.isSimpleTypeReference()>
-                        writeSimpleTypeArrayField("${namedField.name}", ${namedField.name}, ${helper.getDataWriterCall(arrayField.type.elementTypeReference, namedField.name)}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#elseif arrayField.type.elementTypeReference.isEnumTypeReference()>
-                        writeSimpleTypeArrayField("${namedField.name}", ${namedField.name}, ${helper.getEnumDataWriterCall(arrayField.type.elementTypeReference.asEnumTypeReference().orElseThrow(), namedField.name, "value")}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#else>
-                        writeComplexTypeArrayField("${namedField.name}", ${namedField.name}, writeBuffer${helper.getFieldOptions(typedField, parserArguments)});
-                        </#if>
-                        <#break>
-                    <#case "checksum">
-                        <#assign checksumField = field.asChecksumField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Checksum Field (checksum) (Calculated)
-                        writeChecksumField("${namedField.name}", (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(checksumField, checksumField.type, checksumField.checksumExpression, parserArguments)}), ${helper.getDataWriterCall(typedField.type, namedField.name)}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "const">
-                        <#assign constField = field.asConstField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Const Field (${constField.name})
-                        <#if typedField.type.isEnumTypeReference()>writeConstField("${constField.name}", ${namedField.name?upper_case}.getValue(), ${helper.getDataWriterCall(helper.getEnumBaseTypeReference(typedField.type), namedField.name)}${helper.getFieldOptions(typedField, parserArguments)});<#else>writeConstField("${constField.name}", ${namedField.name?upper_case}, ${helper.getDataWriterCall(typedField.type, namedField.name)}${helper.getFieldOptions(typedField, parserArguments)});</#if>
-                        <#break>
-                    <#case "discriminator">
-                        <#assign discriminatorField = field.asDiscriminatorField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Discriminator Field (${discriminatorField.name}) (Used as input to a switch field)
-                        <#if typedField.type.isEnumTypeReference()>writeDiscriminatorEnumField("${namedField.name}", "${helper.getLanguageTypeNameForField(field)}", get${discriminatorField.name?cap_first}(), ${helper.getEnumDataWriterCall(typedField.type.asEnumTypeReference().orElseThrow(), namedField.name, "value")}${helper.getFieldOptions(typedField, parserArguments)});<#else>writeDiscriminatorField("${namedField.name}", get${discriminatorField.name?cap_first}(), ${helper.getDataWriter [...]
-                        <#break>
-                    <#case "enum">
-                        <#assign enumField = field.asEnumField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Enum field (${namedField.name})
-                        writeEnumField("${namedField.name}", "${helper.getLanguageTypeNameForField(field)}", ${namedField.name}, ${helper.getEnumDataWriterCall(typedField.type.asEnumTypeReference().orElseThrow(), namedField.name, enumField.fieldName)}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "implicit">
-                        <#assign implicitField = field.asImplicitField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Implicit Field (${implicitField.name}) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
-                        <#-- Implicit field values might be used in expressions, in order to avoid problems, we generate a temporary variable with the given name. -->
-                        ${helper.getLanguageTypeNameForField(field)} ${implicitField.name} = (${helper.getLanguageTypeNameForField(field)}) (${helper.toSerializationExpression(implicitField, implicitField.type, implicitField.serializeExpression, parserArguments)});
-                        writeImplicitField("${namedField.name}", ${implicitField.name}, ${helper.getDataWriterCall(typedField.type, namedField.name)}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "manualArray">
-                        <#assign manualArrayField = field.asManualArrayField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Manual Array Field (${manualArrayField.name})
-                        writeManualArrayField("${namedField.name}", ${namedField.name}, (${helper.getLanguageTypeNameForTypeReference(manualArrayField.type.elementTypeReference)} _value) -> ${helper.toParseExpression(manualArrayField, manualArrayField.type.elementTypeReference, manualArrayField.serializeExpression, parserArguments)}, writeBuffer${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "manual">
-                        <#assign manualField = field.asManualField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Manual Field (${manualField.name})
-                        writeManualField("${namedField.name}", () -> ${helper.toParseExpression(manualField, manualField.type, manualField.serializeExpression, parserArguments)}, writeBuffer${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "optional">
-                        <#assign optionalField = field.asOptionalField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Optional Field (${optionalField.name}) (Can be skipped, if the value is null)
-                        <#if optionalField.type.isEnumTypeReference()>
-                            writeOptionalEnumField("${optionalField.name}", "${helper.getLanguageTypeNameForField(field)}", ${optionalField.name}, ${helper.getEnumDataWriterCall(optionalField.type.asEnumTypeReference().orElseThrow(), optionalField.name, "value")}<#if optionalField.conditionExpression.present>, ${helper.toSerializationExpression(optionalField, helper.boolTypeReference, optionalField.conditionExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, par [...]
-                        <#elseif optionalField.type.isDataIoTypeReference()>
-                            writeOptionalField("${optionalField.name}", ${optionalField.name}, writeDataIO(writeBuffer, (wb, val) -> ${optionalField.type.asComplexTypeReference().orElseThrow().name}.staticSerialize(wb, val<#if optionalField.type.asComplexTypeReference().orElseThrow().params?has_content>, <#list optionalField.type.asComplexTypeReference().orElseThrow().params.orElseThrow() as param>${helper.toParseExpression(optionalField, helper.anyTypeReference, param, parserArguments)} [...]
-                        <#else>
-                            writeOptionalField("${optionalField.name}", ${optionalField.name}, ${helper.getDataWriterCall(typedField.type, optionalField.name)}<#if helper.isGeneratePropertiesForParserArguments() && optionalField.conditionExpression.present>, ${helper.toSerializationExpression(optionalField, helper.boolTypeReference, optionalField.conditionExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, parserArguments)});
-                        </#if>
-                        <#break>
-                    <#case "padding">
-                        <#assign paddingField = field.asPaddingField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-
-                        // Padding Field (padding)
-                        writePaddingField("padding", (int) (${helper.toParseExpression(paddingField, helper.intTypeReference, paddingField.paddingCondition, parserArguments)}), (${helper.getLanguageTypeNameForField(field)}) ${helper.toSerializationExpression(paddingField, paddingField.type, paddingField.paddingValue, parserArguments)}, ${helper.getDataWriterCall(typedField.type, "padding")}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "reserved">
-                        <#assign reservedField = field.asReservedField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-
-                        // Reserved Field (reserved)
-                        writeReservedField("reserved", <#if helper.isGeneratePropertiesForReservedFields()>reservedField${reservedFieldIndex}!=null?reservedField${reservedFieldIndex}:</#if>${helper.getReservedValue(reservedField)}, ${helper.getDataWriterCall(typedField.type, "reserved")}${helper.getFieldOptions(typedField, parserArguments)});<#assign reservedFieldIndex=reservedFieldIndex+1>
-                        <#break>
-                    <#case "simple">
-                        <#assign simpleField = field.asSimpleField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Simple Field (${namedField.name})
-                        <#if typedField.type.isEnumTypeReference()>
-                            writeSimpleEnumField("${simpleField.name}", "${helper.getLanguageTypeNameForField(field)}", ${simpleField.name}, ${helper.getEnumDataWriterCall(simpleField.type.asEnumTypeReference().orElseThrow(), simpleField.name, "value")}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#elseif simpleField.type.isDataIoTypeReference()>
-                            writeSimpleField("${simpleField.name}", ${simpleField.name}, new DataWriterDataIoDefault(writeBuffer, (wb, val) -> ${simpleField.type.asComplexTypeReference().orElseThrow().name}.staticSerialize(wb, val<#if simpleField.type.asComplexTypeReference().orElseThrow().params?has_content>, <#list simpleField.type.asComplexTypeReference().orElseThrow().params.orElseThrow() as param>${helper.toParseExpression(simpleField, helper.anyTypeReference, param, parserArguments [...]
-                        <#else>
-                            writeSimpleField("${simpleField.name}", ${simpleField.name}, ${helper.getDataWriterCall(typedField.type, simpleField.name)}${helper.getFieldOptions(typedField, parserArguments)});</#if>
-                        <#break>
-                    <#case "switch">
-                        <#assign switchField = field.asSwitchField().orElseThrow()>
-
-                        // Switch field (Serialize the sub-type)
-                        serialize${type.name?cap_first}Child(writeBuffer);
-                        <#break>
-                    <#case "virtual">
-                        <#assign virtualField = field.asVirtualField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Virtual field (doesn't serialize anything, just makes the value available)
-                        ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = get${namedField.name?cap_first}();
-                        writeBuffer.writeVirtual("${namedField.name}", ${namedField.name});
-                        <#break>
-                </#switch>
-            </#list>
-
-            writeBuffer.popContext("${type.name}");
-        </#if>
-        }
-    </#if>
-
-    @Override
-    public int getLengthInBytes() {
-        return (int) Math.ceil((float) getLengthInBits() / 8.0);
-    }
-
-    @Override
-    public int getLengthInBits() {
-        int lengthInBits = <#if type.parentType.isPresent()>super.getLengthInBits()<#else>0</#if>;
-        ${type.name} _value  = this;
-        boolean _lastItem = ThreadLocalHelper.lastItemThreadLocal.get();
-    <#list type.fields as field>
-<#switch field.typeName>
-    <#case "array">
-        <#assign arrayField = field.asArrayField().orElseThrow()>
-        <#assign arrayElementTypeReference = arrayField.type.asArrayTypeReference().orElseThrow().getElementTypeReference()>
-
-        // Array field
-        if(${arrayField.name} != null) {
-        <#if arrayElementTypeReference.isSimpleTypeReference()>
-            <#assign simpleTypeReference = arrayElementTypeReference.asSimpleTypeReference().orElseThrow()>
-            <#if helper.isVarduintField(arrayField)>
-            for(${helper.getLanguageTypeNameForTypeReference(simpleTypeReference, false)} _val : get${arrayField.getName()?cap_first}()) {
-                lengthInBits += GET_VARDUINT_LENGTH_IN_BITS(_val);
-            }
-            <#elseif helper.isVardintField(arrayField)>
-            for(${helper.getLanguageTypeNameForTypeReference(simpleTypeReference, false)} _val : get${arrayField.getName()?cap_first}()) {
-                lengthInBits += GET_VARDINT_LENGTH_IN_BITS(_val);
-            }
-            <#else>
-            lengthInBits += ${simpleTypeReference.sizeInBits} * ${arrayField.name}.<#if arrayElementTypeReference.isByteBased()>length<#else>size()</#if>;
-            </#if>
-        <#elseif arrayElementTypeReference.isEnumTypeReference()>
-            <#assign enumgTypeReference = arrayElementTypeReference.asEnumTypeReference().orElseThrow()>
-            lengthInBits += ${enumgTypeReference.getBaseTypeReference().orElseThrow().sizeInBits} * ${arrayField.name}.<#if arrayElementTypeReference.isByteBased()>length<#else>size()</#if>;
-        <#elseif arrayField.isCountArrayField()>
-            int i=0;
-            <#assign nonSimpleTypeReference = arrayElementTypeReference.asNonSimpleTypeReference().orElseThrow()>
-            for(${nonSimpleTypeReference.name} element : ${arrayField.name}) {
-                ThreadLocalHelper.lastItemThreadLocal.set(++i >= ${arrayField.name}.size());
-                lengthInBits += element.getLengthInBits();
-            }
-        <#else>
-            for(Message element : ${arrayField.name}) {
-                lengthInBits += element.getLengthInBits();
-            }
-        </#if>
-        }
-        <#break>
-    <#case "checksum">
-        <#assign checksumField = field.asChecksumField().orElseThrow()>
-        <#assign typedField = field.asTypedField().orElseThrow()>
-        <#assign simpleTypeReference = typedField.type.asSimpleTypeReference().orElseThrow()>
-
-        // Checksum Field (checksum)
-        lengthInBits += ${simpleTypeReference.sizeInBits};
-        <#break>
-    <#case "const">
-        <#assign constField = field.asConstField().orElseThrow()>
-        <#assign typedField = field.asTypedField().orElseThrow()>
-
-        // Const Field (${constField.name})
-        <#if typedField.type.isSimpleTypeReference()>
-        <#assign simpleTypeReference = typedField.type.asSimpleTypeReference().orElseThrow()>
-        lengthInBits += ${simpleTypeReference.sizeInBits};
-        <#else>
-        lengthInBits += ${helper.getEnumBaseTypeReference(typedField.type).sizeInBits};
-        </#if>
-        <#break>
-    <#case "discriminator">
-        <#assign discriminatorField = field.asDiscriminatorField().orElseThrow()>
-
-        // Discriminator Field (${discriminatorField.name})
-        <#if discriminatorField.type.isSimpleTypeReference()>
-            <#assign simpleTypeReference = discriminatorField.type.asSimpleTypeReference().orElseThrow()>
-            <#if simpleTypeReference.isVstringTypeReference()>
-                <#assign vstringTypeReference = simpleTypeReference.asVstringTypeReference().orElseThrow()>
-        lengthInBits += ${helper.toSerializationExpression(discriminatorField, helper.intTypeReference, vstringTypeReference.getLengthExpression(), parserArguments)};
-            <#else>
-        lengthInBits += ${simpleTypeReference.sizeInBits};
-            </#if>
-        <#elseif helper.isEnumField(field)>
-            lengthInBits += ${helper.getEnumBaseTypeReference(discriminatorField.type).sizeInBits};
-        <#else>
-            lengthInBits += ${discriminatorField.name}.getLengthInBits();
-        </#if>
-        <#break>
-    <#case "enum">
-        <#assign enumField = field.asEnumField().orElseThrow()>
-
-        // Enum Field (${enumField.name})
-        lengthInBits += ${helper.getEnumBaseTypeReference(enumField.type).sizeInBits};
-        <#break>
-    <#case "implicit">
-        <#assign implicitField = field.asImplicitField().orElseThrow()>
-        <#assign simpleTypeReference = implicitField.type.asSimpleTypeReference().orElseThrow()>
-
-        // Implicit Field (${implicitField.name})
-        lengthInBits += ${simpleTypeReference.sizeInBits};
-        <#break>
-    <#case "manualArray">
-        <#assign manualArrayField = field.asManualArrayField().orElseThrow()>
-        <#assign arrayElementTypeReference = manualArrayField.type.asArrayTypeReference().orElseThrow().getElementTypeReference()>
-
-        // Manual Array Field (${manualArrayField.name})
-        lengthInBits += ${helper.toParseExpression(manualArrayField, helper.intTypeReference, manualArrayField.lengthExpression, parserArguments)} * 8;
-        <#break>
-    <#case "manual">
-        <#assign manualField = field.asManualField().orElseThrow()>
-
-        // Manual Field (${manualField.name})
-        lengthInBits += ${helper.toParseExpression(manualField, helper.intTypeReference, manualField.lengthExpression, parserArguments)};
-        <#break>
-    <#case "optional">
-        <#assign optionalField = field.asOptionalField().orElseThrow()>
-        <#assign nullBytesHex = optionalField.getNullBytesHex()>
-
-        // Optional Field (${optionalField.name})<#if nullBytesHex.isEmpty()>
-        if(${optionalField.name} != null) {</#if>
-        <#if optionalField.type.isSimpleTypeReference()>
-            <#assign simpleTypeReference = optionalField.type.asSimpleTypeReference().orElseThrow()>
-            <#if simpleTypeReference.isVstringTypeReference()>
-                <#assign vstringTypeReference = simpleTypeReference.asVstringTypeReference().orElseThrow()>
-            lengthInBits += ${helper.toSerializationExpression(optionalField, helper.intTypeReference, vstringTypeReference.getLengthExpression(), parserArguments)};
-            <#else>
-            lengthInBits += ${simpleTypeReference.sizeInBits};
-            </#if>
-        <#elseif helper.isEnumField(field)>
-            lengthInBits += ${helper.getEnumBaseTypeReference(optionalField.type).sizeInBits};
-        <#elseif optionalField.type.isDataIoTypeReference()>
-            lengthInBits += ${optionalField.type.asComplexTypeReference().orElseThrow().name}.getLengthInBits(${optionalField.name}<#if optionalField.type.asComplexTypeReference().orElseThrow().params?has_content>, <#list optionalField.type.asComplexTypeReference().orElseThrow().params.orElseThrow() as param>${helper.toParseExpression(optionalField, helper.anyTypeReference, param, parserArguments)}<#sep>, </#sep></#list></#if>);
-        <#else>
-            lengthInBits += ${optionalField.name}.getLengthInBits();
-        </#if>
-        <#if nullBytesHex.isEmpty()>}</#if>
-        <#break>
-    <#case "padding">
-        <#assign paddingField = field.asPaddingField().orElseThrow()>
-        <#assign simpleTypeReference = paddingField.type.asSimpleTypeReference().orElseThrow()>
-
-        // Padding Field (padding)
-        <#-- We're replacing the "lastItem" with 'false' here as the item itself can't know if it is the last -->
-        int _timesPadding = (int) (${helper.toParseExpression(paddingField, helper.intTypeReference, paddingField.paddingCondition, parserArguments)});
-        while (_timesPadding-- > 0) {
-            lengthInBits += ${simpleTypeReference.sizeInBits};
-        }
-        <#break>
-    <#case "reserved">
-        <#assign reservedField = field.asReservedField().orElseThrow()>
-        <#assign simpleTypeReference = reservedField.type.asSimpleTypeReference().orElseThrow()>
-
-        // Reserved Field (reserved)
-        lengthInBits += ${simpleTypeReference.sizeInBits};
-        <#break>
-    <#case "simple">
-        <#assign simpleField = field.asSimpleField().orElseThrow()>
-
-        // Simple field (${simpleField.name})
-        <#if simpleField.type.isSimpleTypeReference()>
-            <#assign simpleTypeReference = simpleField.type.asSimpleTypeReference().orElseThrow()>
-            <#if simpleTypeReference.isVstringTypeReference()>
-                <#assign vstringTypeReference = simpleTypeReference.asVstringTypeReference().orElseThrow()>
-        lengthInBits += ${helper.toSerializationExpression(simpleField, helper.intTypeReference, vstringTypeReference.getLengthExpression(), parserArguments)};
-            <#else>
-                <#if helper.isVarduintField(simpleField)>
-        lengthInBits += GET_VARDUINT_LENGTH_IN_BITS(get${simpleField.getName()?cap_first}());
-                <#elseif helper.isVardintField(simpleField)>
-        lengthInBits += GET_VARDINT_LENGTH_IN_BITS(get${simpleField.getName()?cap_first}());
-                <#else>
-        lengthInBits += ${simpleTypeReference.sizeInBits};
-                </#if>
-            </#if>
-        <#elseif helper.isEnumField(field)>
-        lengthInBits += ${helper.getEnumBaseTypeReference(simpleField.type).sizeInBits};
-        <#elseif simpleField.type.isDataIoTypeReference()>
-        lengthInBits += ${simpleField.type.asComplexTypeReference().orElseThrow().name}.getLengthInBits(${simpleField.name}<#if simpleField.type.asComplexTypeReference().orElseThrow().params?has_content>, <#list simpleField.type.asComplexTypeReference().orElseThrow().params.orElseThrow() as param>${helper.toParseExpression(simpleField, helper.anyTypeReference, param, parserArguments)}<#sep>, </#sep></#list></#if>);
-        <#else>
-        lengthInBits += ${simpleField.name}.getLengthInBits();
-        </#if>
-        <#break>
-    <#case "switch">
-        <#assign switchField = field.asSwitchField().orElseThrow()>
-
-        // Length of sub-type elements will be added by sub-type...
-        <#break>
-    <#case "unknown">
-        <#assign unknownField = field.asUnknownField().orElseThrow()>
-        <#assign simpleTypeReference = unknownField.type.asSimpleTypeReference().orElseThrow()>
-
-        // Unknown field
-        lengthInBits += ${simpleTypeReference.sizeInBits};
-        <#break>
-    <#case "virtual">
-        <#assign virtualField = field.asVirtualField().orElseThrow()>
-
-        // A virtual field doesn't have any in- or output.
-        <#break>
-</#switch>
-</#list>
-
-        return lengthInBits;
-    }
-
-<#-- Here come the actual parse and serialize methods that actually do the parsing and serlaizing -->
-    <#assign hasParserArguments=parserArguments?has_content/>
-    <#assign parserArgumentList><#if hasParserArguments><#list parserArguments as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type, false)} ${parserArgument.name}<#sep>, </#sep></#list></#if></#assign>
-    public static <#if type.isDiscriminatedChildTypeDefinition()>${type.parentType.orElseThrow().name}Builder staticParse${type.parentType.orElseThrow().name}Builder<#else>${type.name} staticParse</#if>(ReadBuffer readBuffer<#if hasParserArguments>, ${parserArgumentList}</#if>) throws ParseException {
-        readBuffer.pullContext("${type.name}");
-        PositionAware positionAware = readBuffer;
-        <#if helper.requiresStartPos() || helper.requiresCurPos()>
-        int startPos = positionAware.getPos();
-        int curPos;
-        </#if>
-        boolean _lastItem = ThreadLocalHelper.lastItemThreadLocal.get();
-    <#assign reservedFieldIndex=0>
-    <#list type.fields as field>
-        <#switch field.typeName>
-            <#case "array">
-                <#assign arrayField = field.asArrayField().orElseThrow()>
-                <#assign typedField = field.asTypedField().orElseThrow()>
-                <#assign namedField = field.asNamedField().orElseThrow()>
-                <#assign arrayElementTypeReference = arrayField.type.asArrayTypeReference().orElseThrow().getElementTypeReference()>
-
-                <#if arrayElementTypeReference.isByteBased()>
-                    <#if !field.isCountArrayField() && !field.isLengthArrayField()>${helper.fail("array fields of type byte only support 'count' and 'length' loop-types.")}</#if>
-    byte[] ${namedField.name} = readBuffer.readByteArray("${namedField.name}", Math.toIntExact(${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)});
-                <#else>
-                <#-- If this is a count array, we can directly initialize an array with the given size -->
-                    <#if field.isCountArrayField()>
-    ${helper.getNonPrimitiveLanguageTypeNameForField(arrayField)} ${arrayField.name} = readCountArrayField("${arrayField.name}", ${helper.getDataReaderCall(arrayField.type)}, ${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)}${helper.getFieldOptions(typedField, parserArguments)});
-                    <#-- In all other cases do we have to work with a list, that is later converted to an array -->
-                    <#else>
-                    <#-- For a length array, we read data till the read position of the buffer reaches a given position -->
-                        <#if field.isLengthArrayField()>
-    ${helper.getNonPrimitiveLanguageTypeNameForField(arrayField)} ${arrayField.name} = readLengthArrayField("${arrayField.name}", ${helper.getDataReaderCall(arrayField.type)}, ${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#-- A terminated array keeps on reading data as long as the termination expression evaluates to false -->
-                        <#elseif field.isTerminatedArrayField()>
-    ${helper.getNonPrimitiveLanguageTypeNameForField(arrayField)} ${arrayField.name} = readTerminatedArrayField("${arrayField.name}", ${helper.getDataReaderCall(arrayField.type)}, () -> ((boolean) (${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)}))${helper.getFieldOptions(typedField, parserArguments)});
-                        </#if>
-                    </#if>
-                </#if>
-                <#break>
-            <#case "assert">
-                <#assign assertField = field.asAssertField().orElseThrow()>
-                <#assign typedField = field.asTypedField().orElseThrow()>
-                <#assign namedField = field.asNamedField().orElseThrow()>
-
-    ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}, (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(assertField, assertField.type, assertField.conditionExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)});
-                <#break>
-            <#case "checksum">
-                <#assign checksumField = field.asChecksumField().orElseThrow()>
-                <#assign typedField = field.asTypedField().orElseThrow()>
-                <#assign namedField = field.asNamedField().orElseThrow()>
-
-    ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}, (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(checksumField, checksumField.type, checksumField.checksumExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)});
-                <#break>
-            <#case "const">
-                <#assign constField = field.asConstField().orElseThrow()>
-                <#assign typedField = field.asTypedField().orElseThrow()>
-                <#assign namedField = field.asNamedField().orElseThrow()>
-
-    ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}, ${type.name}.${namedField.name?upper_case}${helper.getFieldOptions(typedField, parserArguments)});
-                <#break>
-            <#case "discriminator">
-                <#assign discriminatorField = field.asDiscriminatorField().orElseThrow()>
-                <#assign typedField = field.asTypedField().orElseThrow()>
-                <#assign namedField = field.asNamedField().orElseThrow()>
-
-                <#if typedField.type.isEnumTypeReference()>
-    ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = readDiscriminatorEnumField("${namedField.name}", "${typedField.type.asEnumTypeReference().orElseThrow().typeDefinition.name}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)});
-                <#else>
-    ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)});
-                </#if>
-                <#break>
-            <#case "enum">
-                <#assign enumField = field.asEnumField().orElseThrow()>
-                <#assign typedField = field.asTypedField().orElseThrow()>
-                <#assign namedField = field.asNamedField().orElseThrow()>
-
-    ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", "${enumField.type.asNonSimpleTypeReference().orElseThrow().typeDefinition.name}", readEnum(${enumField.type.asNonSimpleTypeReference().orElseThrow().typeDefinition.name}::firstEnumForField${enumField.fieldName?cap_first}, ${helper.getDataReaderCall(helper.getEnumFieldTypeReference(enumField.type, enumField.fieldName))})${helper.getFieldOptions(typedField, parse [...]
-                <#break>
-            <#case "implicit">
-                <#assign implicitField = field.asImplicitField().orElseThrow()>
-                <#assign typedField = field.asTypedField().orElseThrow()>
-                <#assign namedField = field.asNamedField().orElseThrow()>
-
-    ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)});
-                <#break>
-            <#case "manualArray">
-                <#assign manualArrayField = field.asManualArrayField().orElseThrow()>
-                <#assign typedField = field.asTypedField().orElseThrow()>
-                <#assign namedField = field.asNamedField().orElseThrow()>
-                <#assign arrayElementTypeReference = manualArrayField.type.asArrayTypeReference().orElseThrow().getElementTypeReference()>
-
-                <#if arrayElementTypeReference.isByteBased()>
-                    byte[] ${namedField.name} = readManualByteArrayField("${namedField.name}", readBuffer, (byte[] _values) -> (boolean) (${helper.toParseExpression(manualArrayField, helper.boolTypeReference, manualArrayField.loopExpression, parserArguments)}), () -> (byte) (${helper.toParseExpression(manualArrayField, manualArrayField.type, manualArrayField.parseExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)});
-                <#else>
-                    ${helper.getNonPrimitiveLanguageTypeNameForField(manualArrayField)} ${namedField.name} = readManualArrayField("${namedField.name}", readBuffer, (${helper.getNonPrimitiveLanguageTypeNameForField(manualArrayField)} _values) -> (boolean) (${helper.toParseExpression(manualArrayField, helper.boolTypeReference, manualArrayField.loopExpression, parserArguments)}), () -> (${helper.getLanguageTypeNameForTypeReference(manualArrayField.type.elementTypeReference)}) (${helper.toPa [...]
-                </#if>
-                <#break>
-            <#case "manual">
-                <#assign manualField = field.asManualField().orElseThrow()>
-                <#assign typedField = field.asTypedField().orElseThrow()>
-                <#assign namedField = field.asNamedField().orElseThrow()>
-
-                ${helper.getLanguageTypeNameForField(field)} ${manualField.name} = readManualField("${namedField.name}", readBuffer, () -> (${helper.getLanguageTypeNameForField(manualField)}) (${helper.toParseExpression(manualField, manualField.type, manualField.parseExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)});
-                <#break>
-            <#case "optional">
-                <#assign optionalField = field.asOptionalField().orElseThrow()>
-                <#assign typedField = field.asTypedField().orElseThrow()>
-                <#assign namedField = field.asNamedField().orElseThrow()>
-
-                ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}<#if optionalField.conditionExpression.present>, ${helper.toParseExpression(optionalField, helper.boolTypeReference, optionalField.conditionExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, parserArguments)});
-                <#break>
-            <#case "padding">
-                <#assign paddingField = field.asPaddingField().orElseThrow()>
-                <#assign typedField = field.asTypedField().orElseThrow()>
-                <#assign simpleTypeReference = paddingField.type.asSimpleTypeReference().orElseThrow()>
-
-                read${field.typeName?cap_first}Field(${helper.getDataReaderCall(typedField.type)}, (int) (${helper.toParseExpression(paddingField, paddingField.type, paddingField.paddingCondition, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)});
-                <#break>
-            <#case "reserved">
-                <#assign reservedField = field.asReservedField().orElseThrow()>
-                <#assign typedField = field.asTypedField().orElseThrow()>
-
-                ${helper.getLanguageTypeNameForTypeReference(reservedField.type, false)} reservedField${reservedFieldIndex}<#assign reservedFieldIndex=reservedFieldIndex+1> = read${field.typeName?cap_first}Field("reserved", ${helper.getDataReaderCall(typedField.type)}, ${helper.getReservedValue(reservedField)}${helper.getFieldOptions(typedField, parserArguments)});
-                <#break>
-            <#case "simple">
-                <#assign simpleField = field.asSimpleField().orElseThrow()>
-                <#assign typedField = field.asTypedField().orElseThrow()>
-                <#assign namedField = field.asNamedField().orElseThrow()>
-
-                ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = <#if typedField.type.isEnumTypeReference()>readEnumField("${namedField.name}", "${helper.getLanguageTypeNameForField(field)}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)});<#else>read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)});</#if>
-                <#break>
-            <#case "switch">
-                <#assign switchField = field.asSwitchField().orElseThrow()>
-
-                // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
-                ${type.name}Builder builder = null;
-                <#list switchField.cases as case>
-                    <@compress single_line=true>
-                        <#if case.discriminatorValueTerms?has_content>
-                            if(
-                            <#list case.discriminatorValueTerms as discriminatorValueTerm>
-                                <#if helper.isWildcard(discriminatorValueTerm)>
-                                    true
-                                <#else>
-                                    <#assign discriminatorExpression=switchField.discriminatorExpressions[discriminatorValueTerm?index].asLiteral().orElseThrow().asVariableLiteral().orElseThrow()>
-                                    <#assign discriminatorType=helper.getDiscriminatorTypes()[discriminatorExpression.discriminatorName]>
-                                    EvaluationHelper.equals(
-                                    ${helper.toParseExpression(switchField, discriminatorType, discriminatorExpression, parserArguments)},
-                                    <#if discriminatorType.isEnumTypeReference()>
-                                        ${helper.getLanguageTypeNameForTypeReference(discriminatorType)}.${helper.toParseExpression(switchField, discriminatorType, discriminatorValueTerm, parserArguments)}
-                                    <#else>
-                                        (${helper.getLanguageTypeNameForTypeReference(discriminatorType, true)}) ${helper.toParseExpression(switchField, discriminatorType, discriminatorValueTerm, parserArguments)}
-                                    </#if>
-                                    )
-                                </#if>
-                                <#sep> && </#sep>
-                            </#list>
-                            )
-                        </#if>{
-                    </...@compress>
-                    <@compress single_line=true>
-                        <#assign hasCaseParseArguments=case.allParserArguments.isPresent() && case.allParserArguments.orElseThrow()?has_content>
-                        <#assign caseParseArguments><#if hasCaseParseArguments><#list case.allParserArguments.orElseThrow() as parserArgument>${parserArgument.name}<#sep>, </#sep></#list></#if></#assign>
-                        builder = ${case.name}.staticParse${type.name}Builder(readBuffer<#if hasCaseParseArguments>, ${tracer.dive("case parse arguments")} ${caseParseArguments}</#if>);
-                    </...@compress>
-                    }<#sep> else </#sep>
-                </#list>
-                if (builder == null) {
-                    throw new ParseException("Unsupported case for discriminated type"<#if switchField.getDiscriminatorExpressions()?has_content>+" parameters ["<#list switchField.getDiscriminatorExpressions() as discriminatorExpression>+"${discriminatorExpression.stringRepresentation()}="+${helper.toParseExpression(null, null, discriminatorExpression, parserArguments)}<#sep>+" "</#sep></#list>+"]"</#if>);
-                }
-                <#break>
-            <#case "unknown">
-                <#assign unknownField = field.asUnknownField().orElseThrow()>
-                <#assign typedField = field.asTypedField().orElseThrow()>
-
-                read${field.typeName?cap_first}Field("unknown", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)});
-                <#break>
-            <#case "virtual">
-                <#assign virtualField = field.asVirtualField().orElseThrow()>
-                <#assign typedField = field.asTypedField().orElseThrow()>
-                <#assign namedField = field.asNamedField().orElseThrow()>
-                ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getLanguageTypeNameForField(field)}.class, ${helper.toParseExpression(virtualField, virtualField.type, virtualField.valueExpression, parserArguments)}${helper.getFieldOptions(typedField, parserArguments)});
-                <#break>
-            <#case "validation">
-                <#assign validationField = field.asValidationField().orElseThrow()>
-                // Validation
-                if (!(${helper.toParseExpression(validationField, helper.boolTypeReference, validationField.getValidationExpression(), null)})) {
-                    <#assign errorType="ParseValidationException">
-                    <#if !validationField.shouldFail()><#assign errorType="ParseAssertException"></#if>
-                    throw new ${errorType}(${validationField.getDescription().orElse("\"Validation failed\"")});
-                }
-                <#break>
-            <#case "peek">
-                <#assign peekField = field.asPeekField().orElseThrow()>
-                <#assign typedField = field.asTypedField().orElseThrow()>
-                <#assign namedField = field.asNamedField().orElseThrow()>
-
-                ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}<#if peekField.offsetExpression.present>, ${helper.toParseExpression(peekField, helper.boolTypeReference, peekField.offsetExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, parserArguments)});
-                <#break>
-        </#switch>
-    </#list>
-
-    readBuffer.closeContext("${type.name}");
-    // Create the instance
-    <#if type.isDiscriminatedChildTypeDefinition()>
-        return new ${type.name}BuilderImpl(
-        <#assign needsSeparator = false>
-        <#list type.propertyFields as field>
-            <#assign needsSeparator = true>
-            ${field.name}<#sep>, </#sep>
-        </#list>
-        <#if helper.isGeneratePropertiesForParserArguments()>
-            <#if filteredParserArguments?has_content>
-                <#if needsSeparator><#assign needsSeparator = false>, </#if>
-                <#list filteredParserArguments as arg>
-                    <#assign needsSeparator = true>
-                    ${arg.name}<#sep>, </#sep>
-                </#list>
-            </#if>
-        </#if>
-        <#if helper.isGeneratePropertiesForReservedFields()>
-            <#if reservedFields?has_content>
-                <#if needsSeparator><#assign needsSeparator = false>, </#if>
-                <#list reservedFields as reservedField>
-                    <#assign needsSeparator = true>
-                    reservedField${reservedField?index}<#sep>, </#sep>
-                </#list>
-            </#if>
-        </#if>
-        <#if type.parentType.isPresent() && type.isDiscriminatedChildTypeDefinition() && type.isDiscriminatedParentTypeDefinition()>
-            <#if needsSeparator>, </#if>
-            builder
-        </#if>
-        );
-    <#elseif type.isDiscriminatedParentTypeDefinition()>
-        ${type.name} _${type.name?uncap_first} = builder.build(
-        <#list type.propertyFields as field>
-            ${field.name}<#sep>, </#sep>
-        </#list>
-        <#if helper.isGeneratePropertiesForParserArguments()>
-            <#if filteredParserArguments?has_content>
-                <#if type.propertyFields?has_content>, </#if>
-                <#list filteredParserArguments as arg>
-                    ${arg.name}<#sep>, </#sep>
-                </#list>
-            </#if>
-        </#if>
-        );
-        <#if helper.isGeneratePropertiesForReservedFields()>
-            <#list reservedFields as reservedField>
-        _${type.name?uncap_first}.reservedField${reservedField?index} = reservedField${reservedField?index};
-            </#list>
-        </#if>
-        return _${type.name?uncap_first};
-    <#else>
-        ${type.name} _${type.name?uncap_first};
-        _${type.name?uncap_first} = new ${type.name}(
-        <#list type.propertyFields as field>
-            ${field.name}<#sep>, </#sep>
-        </#list>
-        <#if helper.isGeneratePropertiesForParserArguments()>
-            <#if filteredParserArguments?has_content>
-                <#if type.propertyFields?has_content>, </#if>
-                <#list filteredParserArguments as arg>
-                    ${arg.name}<#sep>, </#sep>
-                </#list>
-            </#if>
-        </#if>
-        );
-        <#if helper.isGeneratePropertiesForReservedFields()>
-            <#list reservedFields as reservedField>
-            _${type.name?uncap_first}.reservedField${reservedField?index} = reservedField${reservedField?index};
-            </#list>
-        </#if>
-        return _${type.name?uncap_first};
-    </#if>
-    }
-
-    <#if type.isDiscriminatedParentTypeDefinition()>
-        public interface ${type.name}Builder {
-            ${type.name} build(
-        <#assign needsSeparator = false>
-        <#if type.parentType.isPresent() && type.isDiscriminatedChildTypeDefinition() && type.isDiscriminatedParentTypeDefinition()>
-            <#list type.parentType.orElseThrow().asComplexTypeDefinition().orElseThrow().allPropertyFields as field>
-                <#assign needsSeparator = true>
-                ${helper.getLanguageTypeNameForField(field)} ${field.name}<#sep>, </#sep>
-            </#list>
-        </#if>
-        <#if type.propertyFields?has_content>
-            <#if needsSeparator><#assign needsSeparator = false>, </#if>
-            <#list type.propertyFields as field>
-                <#assign needsSeparator = true>
-                ${helper.getLanguageTypeNameForField(field)} ${field.name}<#sep>, </#sep>
-            </#list>
-        </#if>
-        <#if helper.isGeneratePropertiesForParserArguments()>
-            <#if filteredParserArguments?has_content>
-                <#if needsSeparator>, </#if>
-                <#list filteredParserArguments as arg>
-                    ${helper.getLanguageTypeNameForTypeReference(arg.type)} ${arg.name}<#sep>, </#sep>
-                </#list>
-            </#if>
-        </#if>
-        );
-        }
-
-    </#if>
-    <#if type.isDiscriminatedChildTypeDefinition()>
-        public static class ${type.name}BuilderImpl implements ${type.parentType.orElseThrow().name}.${type.parentType.orElseThrow().name}Builder {
-        <#if type.propertyFields?has_content>
-            <#list type.propertyFields as field>
-        private final ${helper.getLanguageTypeNameForField(field)} ${field.name};
-            </#list>
-        </#if>
-        <#if helper.isGeneratePropertiesForParserArguments()>
-            <#if filteredParserArguments?has_content>
-                <#list filteredParserArguments as arg>
-            private final ${helper.getLanguageTypeNameForTypeReference(arg.type)} ${arg.name};
-                </#list>
-            </#if>
-        </#if>
-        <#if helper.isGeneratePropertiesForReservedFields()>
-            <#list reservedFields as reservedField>
-            private final ${helper.getLanguageTypeNameForTypeReference(reservedField.asTypedField().orElseThrow().type, false)} reservedField${reservedField?index};
-            </#list>
-        </#if>
-        <#if type.parentType.isPresent() && type.isDiscriminatedChildTypeDefinition() && type.isDiscriminatedParentTypeDefinition()>
-        private final ${type.name}Builder builder;
-        </#if>
-
-        public ${type.name}BuilderImpl(
-        <#assign needsSeparator = false>
-        <#list type.propertyFields as field>
-            <#assign needsSeparator = true>
-            ${helper.getLanguageTypeNameForField(field)} ${field.name}<#sep>, </#sep>
-        </#list>
-        <#if helper.isGeneratePropertiesForParserArguments()>
-            <#if filteredParserArguments?has_content>
-                <#if needsSeparator><#assign needsSeparator = false>, </#if>
-                <#list filteredParserArguments as arg>
-                    <#assign needsSeparator = true>
-                    ${helper.getLanguageTypeNameForTypeReference(arg.type)} ${arg.name}<#sep>, </#sep>
-                </#list>
-            </#if>
-        </#if>
-        <#if helper.isGeneratePropertiesForReservedFields()>
-            <#if reservedFields?has_content>
-                <#if needsSeparator><#assign needsSeparator = false>, </#if>
-                <#list reservedFields as reservedField>
-                    <#assign needsSeparator = true>
-                    ${helper.getLanguageTypeNameForTypeReference(reservedField.asTypedField().orElseThrow().type, false)} reservedField${reservedField?index}<#sep>, </#sep>
-                </#list>
-            </#if>
-        </#if>
-        <#if type.parentType.isPresent() && type.isDiscriminatedChildTypeDefinition() && type.isDiscriminatedParentTypeDefinition()>
-            <#if needsSeparator><#assign needsSeparator = false>, </#if>
-            ${type.name}Builder builder
-        </#if>
-        ) {
-        <#list type.propertyFields as field>
-            this.${field.name} = ${field.name};
-        </#list>
-        <#if helper.isGeneratePropertiesForParserArguments()>
-            <#if filteredParserArguments?has_content>
-                <#list filteredParserArguments as arg>
-                    this.${arg.name} = ${arg.name};
-                </#list>
-            </#if>
-        </#if>
-        <#if helper.isGeneratePropertiesForReservedFields()>
-            <#list reservedFields as reservedField>
-                this.reservedField${reservedField?index} = reservedField${reservedField?index};
-            </#list>
-        </#if>
-        <#if type.parentType.isPresent() && type.isDiscriminatedChildTypeDefinition() && type.isDiscriminatedParentTypeDefinition()>
-            this.builder = builder;
-        </#if>
-        }
-
-        public ${type.name} build(
-        <#assign needsSeparator = false>
-        <#list type.parentType.orElseThrow().asComplexTypeDefinition().orElseThrow().allPropertyFields as field>
-            <#assign needsSeparator = true>
-            ${helper.getLanguageTypeNameForField(field)} ${field.name}<#sep>, </#sep>
-        </#list>
-        <#if helper.isGeneratePropertiesForParserArguments()>
-            <#if filteredParentParserArguments?has_content>
-                <#if needsSeparator>, </#if>
-                <#list filteredParentParserArguments as arg>
-                    ${helper.getLanguageTypeNameForTypeReference(arg.type)} ${arg.name}<#sep>, </#sep>
-                </#list>
-            </#if>
-        </#if>
-        ) {
-        <#if type.parentType.isPresent() && type.isDiscriminatedChildTypeDefinition() && type.isDiscriminatedParentTypeDefinition()>
-            return builder.build(
-            <#assign needsSeparator = false>
-            <#list type.parentType.orElseThrow().asComplexTypeDefinition().orElseThrow().allPropertyFields as field>
-                <#assign needsSeparator = true>
-                ${field.name}<#sep>, </#sep>
-            </#list>
-            <#if type.propertyFields?has_content>
-                <#if needsSeparator><#assign needsSeparator = false>, </#if>
-                <#list type.propertyFields as field>
-                    <#assign needsSeparator = true>
-                    ${field.name}<#sep>, </#sep>
-                </#list>
-            </#if>
-            <#if helper.isGeneratePropertiesForParserArguments()>
-                <#if filteredParserArguments?has_content>
-                    <#if needsSeparator>, </#if>
-                    <#list filteredParserArguments as arg>
-                        ${arg.name}<#sep>, </#sep>
-                    </#list>
-                </#if>
-            </#if>
-            );
-        <#else>
-            ${type.name} ${type.name?uncap_first} = new ${type.name}(
-            <#list type.allPropertyFields as field>
-                ${field.name}<#sep>, </#sep>
-            </#list>
-            <#if helper.isGeneratePropertiesForParserArguments()>
-                <#if filteredParserArguments?has_content>
-                    <#if type.allPropertyFields?has_content>, </#if>
-                    <#list filteredParserArguments as arg>
-                        ${arg.name}<#sep>, </#sep>
-                    </#list>
-                </#if>
-            </#if>
-            );
-            <#if helper.isGeneratePropertiesForReservedFields()>
-                <#list reservedFields as reservedField>
-                    ${type.name?uncap_first}.reservedField${reservedField?index} = reservedField${reservedField?index};
-                </#list>
-            </#if>
-            return ${type.name?uncap_first};
-        </#if>
-        }
-    }
-
-    </#if>
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) {
-            return true;
-        }
-        if (!(o instanceof ${type.name})) {
-            return false;
-        }
-        ${type.name} that = (${type.name}) o;
-        return
-            <#if type.propertyFields?has_content>
-            <#list type.propertyFields as field>
-            (get${field.name?cap_first}() == that.get${field.name?cap_first}()) &&
-            </#list>
-            </#if>
-            <#if type.parentType.isPresent()>
-            super.equals(that) &&
-            </#if>
-            true;
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(
-            <#if type.parentType.isPresent()>
-            super.hashCode()<#if type.propertyFields?has_content>,</#if>
-            </#if>
-            <#if type.propertyFields?has_content>
-            <#list type.propertyFields as field>
-            get${field.name?cap_first}()<#sep>,</#sep>
-            </#list>
-            </#if>
-        );
-    }
-
-    @Override
-    public String toString() {
-        WriteBufferBoxBased writeBufferBoxBased = new WriteBufferBoxBased(true, true);
-        try {
-            writeBufferBoxBased.writeSerializable(this);
-        } catch (SerializationException e) {
-            throw new RuntimeException(e);
-        }
-        return "\n" + writeBufferBoxBased.getBox().toString()+ "\n";
-    }
-}
-</#outputformat>
\ No newline at end of file
diff --git a/code-generation/language/java/src/main/resources/templates/java/constants-template.java.ftlh b/code-generation/language/java/src/main/resources/templates/java/constants-template.java.ftlh
deleted file mode 100644
index 66d0562191..0000000000
--- a/code-generation/language/java/src/main/resources/templates/java/constants-template.java.ftlh
+++ /dev/null
@@ -1,84 +0,0 @@
-<#--
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you 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
-
-      https://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.
--->
-<#-- Prevent freemarker from escaping stuff -->
-<#outputformat "undefined">
-<#-- Declare the name and type of variables passed in to the template -->
-<#-- @ftlvariable name="languageName" type="java.lang.String" -->
-<#-- @ftlvariable name="protocolName" type="java.lang.String" -->
-<#-- @ftlvariable name="outputFlavor" type="java.lang.String" -->
-<#-- @ftlvariable name="helper" type="org.apache.plc4x.language.java.JavaLanguageTemplateHelper" -->
-<#-- @ftlvariable name="tracer" type="org.apache.plc4x.plugins.codegenerator.protocol.freemarker.Tracer" -->
-<#-- @ftlvariable name="type" type="org.apache.plc4x.plugins.codegenerator.types.definitions.ComplexTypeDefinition" -->
-<#-- Declare the name and type of variables declared locally inside the template -->
-${helper.packageName(protocolName, languageName, outputFlavor)?replace(".", "/")}/${type.name}.java
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you 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
- *
- *   https://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 ${helper.packageName(protocolName, languageName, outputFlavor)};
-
-import static org.apache.plc4x.java.spi.generation.StaticHelper.*;
-import static org.apache.plc4x.java.spi.codegen.io.DataReaderFactory.*;
-import static org.apache.plc4x.java.spi.codegen.io.DataWriterFactory.*;
-import static org.apache.plc4x.java.spi.codegen.fields.FieldReaderFactory.*;
-import static org.apache.plc4x.java.spi.codegen.fields.FieldWriterFactory.*;
-
-import org.apache.plc4x.java.spi.codegen.*;
-import org.apache.plc4x.java.spi.codegen.io.*;
-import org.apache.plc4x.java.spi.codegen.fields.*;
-import org.apache.plc4x.java.api.exceptions.*;
-import org.apache.plc4x.java.spi.generation.*;
-import org.apache.plc4x.java.api.value.*;
-
-import java.time.*;
-import java.util.*;
-import java.math.BigInteger;
-${helper.getExternalTypeImports()}
-
-// Code generated by code-generation. DO NOT EDIT.
-
-<#-- TODO: the code below implies that parserArguments will be null if not present... not pretty  -->
-<#if type.parserArguments.isPresent()><#assign parserArguments=type.allParserArguments.orElseThrow()></#if>
-public class ${type.name} {
-
-<#-- If the current type contains "const" fields, generate some java constants for holing their values -->
-<#if type.constFields?has_content>
-
-    // Constant values.
-    <#list type.constFields as field>
-    public static final ${helper.getLanguageTypeNameForTypeReference(field.type)} ${field.name?upper_case} = ${helper.toParseExpression(field, field.type, field.referenceValue, parserArguments)};
-    </#list>
-</#if>
-
-}
-</#outputformat>
\ No newline at end of file
diff --git a/code-generation/language/java/src/main/resources/templates/java/data-io-template.java.ftlh b/code-generation/language/java/src/main/resources/templates/java/data-io-template.java.ftlh
deleted file mode 100644
index dbfe68167c..0000000000
--- a/code-generation/language/java/src/main/resources/templates/java/data-io-template.java.ftlh
+++ /dev/null
@@ -1,739 +0,0 @@
-<#--
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you 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
-
-      https://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.
--->
-<#-- Prevent freemarker from escaping stuff -->
-<#outputformat "undefined">
-<#-- Declare the name and type of variables passed in to the template -->
-<#-- @ftlvariable name="languageName" type="java.lang.String" -->
-<#-- @ftlvariable name="protocolName" type="java.lang.String" -->
-<#-- @ftlvariable name="outputFlavor" type="java.lang.String" -->
-<#-- @ftlvariable name="helper" type="org.apache.plc4x.language.java.JavaLanguageTemplateHelper" -->
-<#-- @ftlvariable name="tracer" type="org.apache.plc4x.plugins.codegenerator.protocol.freemarker.Tracer" -->
-<#-- @ftlvariable name="type" type="org.apache.plc4x.plugins.codegenerator.types.definitions.ComplexTypeDefinition" -->
-${helper.packageName(protocolName, languageName, outputFlavor)?replace(".", "/")}/${type.name}.java
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you 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
- *
- *   https://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 ${helper.packageName(protocolName, languageName, outputFlavor)};
-
-import static org.apache.plc4x.java.spi.generation.StaticHelper.*;
-import static org.apache.plc4x.java.spi.codegen.io.DataReaderFactory.*;
-import static org.apache.plc4x.java.spi.codegen.io.DataWriterFactory.*;
-import static org.apache.plc4x.java.spi.codegen.fields.FieldReaderFactory.*;
-import static org.apache.plc4x.java.spi.codegen.fields.FieldWriterFactory.*;
-
-import org.apache.plc4x.java.spi.codegen.*;
-import org.apache.plc4x.java.spi.codegen.io.*;
-import org.apache.plc4x.java.spi.codegen.fields.*;
-import org.apache.plc4x.java.api.exceptions.*;
-import org.apache.plc4x.java.spi.generation.*;
-import org.apache.plc4x.java.spi.values.*;
-import org.apache.plc4x.java.api.value.*;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.math.BigInteger;
-import java.time.*;
-import java.time.temporal.ChronoField;
-import java.util.*;
-import java.util.function.Supplier;
-import java.util.stream.Collectors;
-${helper.getExternalTypeImports()}
-
-// Code generated by code-generation. DO NOT EDIT.
-
-<#-- TODO: the code below implies that parserArguments will be null if not present... not pretty  -->
-<#if type.parserArguments.isPresent()><#assign parserArguments=type.parserArguments.orElseThrow()></#if>
-public class ${type.name} {
-
-    private static final Logger LOGGER = LoggerFactory.getLogger(${type.name}.class);
-    <#assign hasParserArguments=parserArguments?has_content/>
-    <#assign parserArgumentList><#if hasParserArguments><#list parserArguments as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type, false)} ${parserArgument.name}<#sep>, </#sep></#list></#if></#assign>
-    public static PlcValue staticParse(ReadBuffer readBuffer<#if hasParserArguments>, ${parserArgumentList}</#if>) throws ParseException {
-        <#assign defaultCaseOutput=false>
-        <#assign dataIoTypeDefinition=type.asDataIoTypeDefinition().orElseThrow()>
-        <#list dataIoTypeDefinition.switchField.orElseThrow().cases as case>
-            <#--
-                Output the if-expression for this case
-            -->
-            <@compress single_line=true>
-                <#if case.discriminatorValueTerms?has_content>
-                    if(
-                    <#list case.discriminatorValueTerms as discriminatorValueTerm>
-                        <#if helper.isWildcard(discriminatorValueTerm)>
-                            true
-                        <#else>
-                            <#assign switchField=dataIoTypeDefinition.switchField.orElseThrow()>
-                            <#assign discriminatorExpression=switchField.discriminatorExpressions[discriminatorValueTerm?index].asLiteral().orElseThrow().asVariableLiteral().orElseThrow()>
-                            <#assign discriminatorType=helper.getDiscriminatorTypes()[discriminatorExpression.discriminatorName]>
-                            EvaluationHelper.equals(
-                            ${helper.toParseExpression(switchField, discriminatorType, discriminatorExpression, parserArguments)},
-                            <#if discriminatorType.isEnumTypeReference()>
-                                ${helper.getLanguageTypeNameForTypeReference(discriminatorType)}.${helper.toParseExpression(switchField, discriminatorType, discriminatorValueTerm, parserArguments)}
-                            <#else>
-                                (${helper.getLanguageTypeNameForTypeReference(discriminatorType, true)}) ${helper.toParseExpression(switchField, discriminatorType, discriminatorValueTerm, parserArguments)}
-                            </#if>
-                            )
-                        </#if>
-                        <#sep> && </#sep>
-                    </#list>
-                    )
-                <#else>
-                    <#assign defaultCaseOutput=true>
-                </#if>{ // ${case.name}
-            </...@compress>
-            <#--
-                Output the body of this case
-            -->
-            <#assign reservedFieldIndex=0>
-            <#assign valueDefined=false>
-            <#list case.fields as field>
-                <#if field.isNamedField()>
-                    <#assign namedField = field.asNamedField().orElseThrow()>
-                    <#if namedField.name == "value">
-                        <#assign valueDefined=true>
-                    </#if>
-                </#if>
-                <#switch field.typeName>
-                    <#case "array">
-                        <#assign arrayField = field.asArrayField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-                        <#assign arrayElementTypeReference = arrayField.type.asArrayTypeReference().orElseThrow().getElementTypeReference()>
-
-                        <#if arrayElementTypeReference.isByteBased()>
-                            <#if !field.isCountArrayField() && !field.isLengthArrayField()>
-                                throw new ParseException("array fields of type byte only support 'count' and 'length' loop-types.");
-                            </#if>
-                            byte[] ${namedField.name} = readBuffer.readByteArray("${namedField.name}", Math.toIntExact(${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)});
-                        <#else>
-                        <#-- If this is a count array, we can directly initialize an array with the given size -->
-                            <#if field.isCountArrayField()>
-                                ${helper.getNonPrimitiveLanguageTypeNameForField(arrayField)} _${arrayField.name} = readCountArrayField("${arrayField.name}", ${helper.getDataReaderCall(arrayField.type)}, ${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)}${helper.getFieldOptions(typedField, parserArguments)});
-                                List<PlcValue> value = new ArrayList<>(_value.size());
-                                for (${helper.getLanguageTypeNameForTypeReference(arrayElementTypeReference, true)} _item : _value) {
-                                    value.add(new ${helper.getPlcValueTypeForTypeReference(arrayElementTypeReference)}(_item));
-                                }
-                            <#-- In all other cases do we have to work with a list, that is later converted to an array -->
-                            <#else>
-                            <#-- For a length array, we read data till the read position of the buffer reaches a given position -->
-                                <#if field.isLengthArrayField()>
-                                    ${helper.getNonPrimitiveLanguageTypeNameForField(arrayField)} ${arrayField.name} = readLengthArrayField("${arrayField.name}", ${helper.getDataReaderCall(arrayField.type)}, ${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)}${helper.getFieldOptions(typedField, parserArguments)});
-                                <#-- A terminated array keeps on reading data as long as the termination expression evaluates to false -->
-                                <#elseif field.isTerminatedArrayField()>
-                                    ${helper.getNonPrimitiveLanguageTypeNameForField(arrayField)} ${arrayField.name} = readTerminatedArrayField("${arrayField.name}", ${helper.getDataReaderCall(arrayField.type)}, () -> ((boolean) (${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)}))${helper.getFieldOptions(typedField, parserArguments)});
-                                </#if>
-                            </#if>
-                        </#if>
-                        <#break>
-                    <#case "assert">
-                        <#assign assertField = field.asAssertField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}, (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(assertField, assertField.type, assertField.conditionExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "checksum">
-                        <#assign checksumField = field.asChecksumField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}, (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(checksumField, checksumField.type, checksumField.checksumExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "const">
-                        <#assign constField = field.asConstField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}, ${type.name}.${namedField.name?upper_case}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "discriminator">
-                        <#assign discriminatorField = field.asDiscriminatorField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "enum">
-                        <#assign enumField = field.asEnumField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", "${enumField.type.asNonSimpleTypeReference().orElseThrow().typeDefinition.name}", readEnum(${enumField.type.asNonSimpleTypeReference().orElseThrow().typeDefinition.name}::firstEnumForField${enumField.fieldName?cap_first}, ${helper.getDataReaderCall(helper.getEnumFieldTypeReference(enumField.type, enumField.fieldName))})${helper.getFieldOptio [...]
-                        <#break>
-                    <#case "implicit">
-                        <#assign implicitField = field.asImplicitField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "manualArray">
-                        <#assign manualArrayField = field.asManualArrayField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-                        <#assign arrayElementTypeReference = manualArrayField.type.asArrayTypeReference().orElseThrow().getElementTypeReference()>
-
-                        <#if arrayElementTypeReference.isByteBased()>
-                            byte[] ${namedField.name} = readManualByteArrayField("${namedField.name}", readBuffer, (byte[] _values) -> (boolean) (${helper.toParseExpression(manualArrayField, helper.boolTypeReference, manualArrayField.loopExpression, parserArguments)}), () -> (byte) (${helper.toParseExpression(manualArrayField, manualArrayField.type, manualArrayField.parseExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)});
-                        <#else>
-                            ${helper.getNonPrimitiveLanguageTypeNameForField(manualArrayField)} ${namedField.name} = readManualArrayField("${namedField.name}", readBuffer, (${helper.getNonPrimitiveLanguageTypeNameForField(manualArrayField)} _values) -> (boolean) (${helper.toParseExpression(manualArrayField, helper.boolTypeReference, manualArrayField.loopExpression, parserArguments)}), () -> (${helper.getLanguageTypeNameForTypeReference(manualArrayField.type.elementTypeReference)}) (${hel [...]
-                        </#if>
-                        <#break>
-                    <#case "manual">
-                        <#assign manualField = field.asManualField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        ${helper.getLanguageTypeNameForField(field)} ${manualField.name} = readManualField("${namedField.name}", readBuffer, () -> (${helper.getLanguageTypeNameForField(manualField)}) (${helper.toParseExpression(manualField, manualField.type, manualField.parseExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "optional">
-                        <#assign optionalField = field.asOptionalField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}<#if optionalField.conditionExpression.present>, ${helper.toParseExpression(optionalField, helper.boolTypeReference, optionalField.conditionExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "padding">
-                        <#assign paddingField = field.asPaddingField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign simpleTypeReference = paddingField.type.asSimpleTypeReference().orElseThrow()>
-
-                        read${field.typeName?cap_first}Field(${helper.getDataReaderCall(typedField.type)}, (int) (${helper.toParseExpression(paddingField, paddingField.type, paddingField.paddingCondition, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "reserved">
-                        <#assign reservedField = field.asReservedField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-
-                        ${helper.getLanguageTypeNameForTypeReference(reservedField.type, false)} reservedField${reservedFieldIndex}<#assign reservedFieldIndex=reservedFieldIndex+1> = read${field.typeName?cap_first}Field("reserved", ${helper.getDataReaderCall(typedField.type)}, ${helper.getReservedValue(reservedField)}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "simple">
-                        <#assign simpleField = field.asSimpleField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = <#if typedField.type.isEnumTypeReference()>readEnumField("${namedField.name}", "${helper.getLanguageTypeNameForField(field)}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)});<#else>read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)});</#if>
-                        <#break>
-                    <#case "unknown">
-                        <#assign unknownField = field.asUnknownField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-
-                        read${field.typeName?cap_first}Field("unknown", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "virtual">
-                        <#assign virtualField = field.asVirtualField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-                        ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getLanguageTypeNameForField(field)}.class, ${helper.toParseExpression(virtualField, virtualField.type, virtualField.valueExpression, parserArguments)}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "validation">
-                        <#assign validationField = field.asValidationField().orElseThrow()>
-                        // Validation
-                        if (!(${helper.toParseExpression(validationField, helper.boolTypeReference, validationField.getValidationExpression(), null)})) {
-                        <#assign errorType="ParseValidationException">
-                        <#if !validationField.shouldFail()><#assign errorType="ParseAssertException"></#if>
-                        throw new ${errorType}(${validationField.getDescription().orElse("\"Validation failed\"")});
-                        }
-                        <#break>
-                    <#case "peek">
-                        <#assign peekField = field.asPeekField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}<#if peekField.offsetExpression.present>, ${helper.toParseExpression(peekField, helper.boolTypeReference, peekField.offsetExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                </#switch>
-            </#list>
-            <#switch case.name>
-                <#case "TIME">
-                    <#if helper.hasFieldsWithNames(case.fields, "milliseconds")>
-                        return PlcTIME.ofMilliseconds(milliseconds);
-                    </#if>
-                    <#break>
-                <#case "LTIME">
-                    <#if helper.hasFieldsWithNames(case.fields, "nanoseconds")>
-                        return PlcLTIME.ofNanoseconds(nanoseconds);
-                    </#if>
-                    <#break>
-                <#case "DATE">
-                    <#if helper.hasFieldsWithNames(case.fields, "secondsSinceEpoch")>
-                        return PlcDATE.ofSecondsSinceEpoch(secondsSinceEpoch);
-                    <#elseif helper.hasFieldsWithNames(case.fields, "daysSinceEpoch")>
-                        return PlcDATE.ofDaysSinceEpoch(daysSinceEpoch);
-                    <#elseif helper.hasFieldsWithNames(case.fields, "daysSinceSiemensEpoch")>
-                        return PlcDATE.ofDaysSinceSiemensEpoch(daysSinceSiemensEpoch);
-                    </#if>
-                    <#break>
-                <#case "LDATE">
-                    <#if helper.hasFieldsWithNames(case.fields, "nanosecondsSinceEpoch")>
-                        return PlcLDATE.ofNanosecondsSinceEpoch(nanosecondsSinceEpoch);
-                    </#if>
-                    <#break>
-                <#case "TIME_OF_DAY">
-                    <#if helper.hasFieldsWithNames(case.fields, "millisecondsSinceMidnight")>
-                        return PlcTIME_OF_DAY.ofMillisecondsSinceMidnight(millisecondsSinceMidnight);
-                    </#if>
-                    <#break>
-                <#case "LTIME_OF_DAY">
-                    <#if helper.hasFieldsWithNames(case.fields, "nanosecondsSinceMidnight")>
-                        return PlcLTIME_OF_DAY.ofNanosecondsSinceMidnight(nanosecondsSinceMidnight);
-                    </#if>
-                    <#break>
-                <#case "DATE_AND_TIME">
-                    <#if helper.hasFieldsWithNames(case.fields, "year", "month", "day", "hour", "minutes", "seconds", "millisecondsOfSecond")>
-                        return PlcDATE_AND_TIME.ofSegments(year, (month == 0) ? 1 : month, (day == 0) ? 1 : day, hour, minutes, seconds, millisecondsOfSecond * 1000000);
-                    <#elseif helper.hasFieldsWithNames(case.fields, "secondsSinceEpoch")>
-                        return PlcDATE_AND_TIME.ofSecondsSinceEpoch(secondsSinceEpoch);
-                    </#if>
-                    <#break>
-                <#case "DATE_AND_LTIME">
-                    <#if helper.hasFieldsWithNames(case.fields, "nanosecondsSinceEpoch")>
-                        return PlcDATE_AND_LTIME.ofNanosecondsSinceEpoch(nanosecondsSinceEpoch);
-                    <#elseif helper.hasFieldsWithNames(case.fields, "year", "month", "day", "hour", "minutes", "seconds", "nanosecondsOfSecond")>
-                        return PlcDATE_AND_LTIME.ofSegments(year, (month == 0) ? 1 : month, (day == 0) ? 1 : day, hour, minutes, seconds, nanosecondsOfSecond);
-                    </#if>
-                    <#break>
-                <#case "LDATE_AND_TIME">
-                    <#if helper.hasFieldsWithNames(case.fields, "nanosecondsSinceEpoch")>
-                        return PlcLDATE_AND_TIME.ofNanosecondsSinceEpoch(nanosecondsSinceEpoch);
-                    </#if>
-                    <#break>
-                <#case "Struct">
-
-                    Map<String, PlcValue> _map = new HashMap<>();
-                    <#list case.fields as field>
-                        <#if field.isNamedField()>
-                            <#assign namedField=field.asNamedField().orElseThrow()>
-                            <#assign typedField=field.asTypedField().orElseThrow()>
-                            _map.put("${namedField.name}", new ${helper.getPlcValueTypeForTypeReference(typedField.type)}(${namedField.name}));
-                        </#if>
-                    </#list>
-                    return new PlcStruct(_map);
-                    <#break>
-                <#case "List">
-                    <#if helper.isRawByteArray(case)>
-                        return new PlcRawByteArray(value);
-                    <#else>
-                        return new PlcList(value);
-                    </#if>
-                    <#break>
-                <#default>
-                    return new Plc${case.name}(value);
-            </#switch>
-            }<#sep> else </#sep>
-        </#list>
-        <#if !defaultCaseOutput>
-            return null;
-        </#if>
-    }
-
-    public static int getLengthInBytes(PlcValue _value<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type, false)} ${parserArgument.name}<#sep>, </#sep></#list></#if>) {
-        return (int) Math.ceil((float) getLengthInBits(_value<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${parserArgument.name}<#sep>, </#sep></#list></#if>) / 8.0);
-    }
-
-    public static int getLengthInBits(PlcValue _value<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type, false)} ${parserArgument.name}<#sep>, </#sep></#list></#if>) {
-        int lengthInBits = 0;
-        <#assign dataIoTypeDefinition=type.asDataIoTypeDefinition().orElseThrow()>
-        <#list dataIoTypeDefinition.switchField.orElseThrow().cases as case>
-            <#--
-                Output the if-expression for this case
-            -->
-            <@compress single_line=true>
-                <#if case.discriminatorValueTerms?has_content>
-                    if(
-                    <#list case.discriminatorValueTerms as discriminatorValueTerm>
-                        <#if helper.isWildcard(discriminatorValueTerm)>
-                            true
-                        <#else>
-                            <#assign switchField=dataIoTypeDefinition.switchField.orElseThrow()>
-                            <#assign discriminatorExpression=switchField.discriminatorExpressions[discriminatorValueTerm?index].asLiteral().orElseThrow().asVariableLiteral().orElseThrow()>
-                            <#assign discriminatorType=helper.getDiscriminatorTypes()[discriminatorExpression.discriminatorName]>
-                            EvaluationHelper.equals(
-                            ${helper.toParseExpression(switchField, discriminatorType, discriminatorExpression, parserArguments)},
-                            <#if discriminatorType.isEnumTypeReference()>
-                                ${helper.getLanguageTypeNameForTypeReference(discriminatorType)}.${helper.toParseExpression(switchField, discriminatorType, discriminatorValueTerm, parserArguments)}
-                            <#else>
-                                (${helper.getLanguageTypeNameForTypeReference(discriminatorType, true)}) ${helper.toParseExpression(switchField, discriminatorType, discriminatorValueTerm, parserArguments)}
-                            </#if>
-                            )
-                        </#if>
-                        <#sep> && </#sep>
-                    </#list>
-                    )
-                </#if>{ // ${case.name}
-            </...@compress>
-            <#--
-                Calculate the size of the current type.
-            -->
-            <#list case.fields as field>
-                <#switch field.typeName>
-                    <#case "array">
-                        <#assign arrayField = field.asArrayField().orElseThrow()>
-                        <#assign arrayElementTypeReference = arrayField.type.asArrayTypeReference().orElseThrow().getElementTypeReference()>
-
-                        // Array field
-                        if(_value != null) {
-                        <#if arrayElementTypeReference.isSimpleTypeReference()>
-                            <#assign simpleTypeReference = arrayElementTypeReference.asSimpleTypeReference().orElseThrow()>
-                            lengthInBits += ${simpleTypeReference.sizeInBits} * _value.<#if arrayElementTypeReference.isByteBased()>getRaw().length<#else>getList().size()</#if>;
-                        <#elseif arrayField.isCountArrayField()>
-                            int i=0;
-                            <#assign nonSimpleTypeReference = arrayElementTypeReference.asNonSimpleTypeReference().orElseThrow()>
-                            for(${nonSimpleTypeReference.name} element : ${arrayField.name}) {
-                            ThreadLocalHelper.lastItemThreadLocal.set(++i >= ${arrayField.name}.size());
-                            lengthInBits += element.getLengthInBits();
-                            }
-                        <#else>
-                            for(Message element : ${arrayField.name}) {
-                            lengthInBits += element.getLengthInBits();
-                            }
-                        </#if>
-                        }
-                        <#break>
-                    <#case "checksum">
-                        <#assign checksumField = field.asChecksumField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign simpleTypeReference = typedField.type.asSimpleTypeReference().orElseThrow()>
-
-                        // Checksum Field (checksum)
-                        lengthInBits += ${simpleTypeReference.sizeInBits};
-                        <#break>
-                    <#case "const">
-                        <#assign constField = field.asConstField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-
-                        // Const Field (${constField.name})
-                        <#if typedField.type.isSimpleTypeReference()>
-                            <#assign simpleTypeReference = typedField.type.asSimpleTypeReference().orElseThrow()>
-                            lengthInBits += ${simpleTypeReference.sizeInBits};
-                        <#else>
-                            lengthInBits += ${helper.getEnumBaseTypeReference(typedField.type).sizeInBits};
-                        </#if>
-                        <#break>
-                    <#case "discriminator">
-                        <#assign discriminatorField = field.asDiscriminatorField().orElseThrow()>
-
-                        // Discriminator Field (${discriminatorField.name})
-                        <#if discriminatorField.type.isSimpleTypeReference()>
-                            <#assign simpleTypeReference = discriminatorField.type.asSimpleTypeReference().orElseThrow()>
-                            <#if simpleTypeReference.isVstringTypeReference()>
-                                <#assign vstringTypeReference = simpleTypeReference.asVstringTypeReference().orElseThrow()>
-                                lengthInBits += ${helper.toSerializationExpression(discriminatorField, helper.intTypeReference, vstringTypeReference.getLengthExpression(), parserArguments)};
-                            <#else>
-                                lengthInBits += ${simpleTypeReference.sizeInBits};
-                            </#if>
-                        <#elseif helper.isEnumField(field)>
-                            lengthInBits += ${helper.getEnumBaseTypeReference(discriminatorField.type).sizeInBits};
-                        <#else>
-                            lengthInBits += ${discriminatorField.name}.getLengthInBits();
-                        </#if>
-                        <#break>
-                    <#case "enum">
-                        <#assign enumField = field.asEnumField().orElseThrow()>
-
-                        // Enum Field (${enumField.name})
-                        lengthInBits += ${helper.getEnumBaseTypeReference(enumField.type).sizeInBits};
-                        <#break>
-                    <#case "implicit">
-                        <#assign implicitField = field.asImplicitField().orElseThrow()>
-                        <#assign simpleTypeReference = implicitField.type.asSimpleTypeReference().orElseThrow()>
-
-                        // Implicit Field (${implicitField.name})
-                        lengthInBits += ${simpleTypeReference.sizeInBits};
-                        <#break>
-                    <#case "manualArray">
-                        <#assign manualArrayField = field.asManualArrayField().orElseThrow()>
-                        <#assign arrayElementTypeReference = manualArrayField.type.asArrayTypeReference().orElseThrow().getElementTypeReference()>
-
-                        // Manual Array Field (${manualArrayField.name})
-                        lengthInBits += ${helper.toParseExpression(manualArrayField, helper.intTypeReference, manualArrayField.lengthExpression, parserArguments)} * 8;
-                        <#break>
-                    <#case "manual">
-                        <#assign manualField = field.asManualField().orElseThrow()>
-
-                        // Manual Field (${manualField.name})
-                        lengthInBits += ${helper.toParseExpression(manualField, helper.intTypeReference, manualField.lengthExpression, parserArguments)};
-                        <#break>
-                    <#case "optional">
-                        <#assign optionalField = field.asOptionalField().orElseThrow()>
-                        <#assign nullBytesHex = optionalField.getNullBytesHex()>
-
-                        // Optional Field (${optionalField.name})<#if nullBytesHex.isEmpty()>
-                        if(${optionalField.name} != null) {</#if>
-                        <#if optionalField.type.isSimpleTypeReference()>
-                            <#assign simpleTypeReference = optionalField.type.asSimpleTypeReference().orElseThrow()>
-                            <#if simpleTypeReference.isVstringTypeReference()>
-                                <#assign vstringTypeReference = simpleTypeReference.asVstringTypeReference().orElseThrow()>
-                                lengthInBits += ${helper.toSerializationExpression(optionalField, helper.intTypeReference, vstringTypeReference.getLengthExpression(), parserArguments)};
-                            <#else>
-                                lengthInBits += ${simpleTypeReference.sizeInBits};
-                            </#if>
-                        <#elseif helper.isEnumField(field)>
-                            lengthInBits += ${helper.getEnumBaseTypeReference(optionalField.type).sizeInBits};
-                        <#elseif optionalField.type.isDataIoTypeReference()>
-                            lengthInBits += ${optionalField.type.asComplexTypeReference().orElseThrow().name}.getLengthInBits(${optionalField.name}<#if optionalField.type.asComplexTypeReference().orElseThrow().params?has_content>, <#list optionalField.type.asComplexTypeReference().orElseThrow().params.orElseThrow() as param>${helper.toParseExpression(optionalField, helper.anyTypeReference, param, parserArguments)}<#sep>, </#sep></#list></#if>);
-                        <#else>
-                            lengthInBits += ${optionalField.name}.getLengthInBits();
-                        </#if>
-                        <#if nullBytesHex.isEmpty()>}</#if>
-                        <#break>
-                    <#case "padding">
-                        <#assign paddingField = field.asPaddingField().orElseThrow()>
-                        <#assign simpleTypeReference = paddingField.type.asSimpleTypeReference().orElseThrow()>
-
-                        // Padding Field (padding)
-                    <#-- We're replacing the "lastItem" with 'false' here as the item itself can't know if it is the last -->
-                        int _timesPadding = (int) (${helper.toParseExpression(paddingField, helper.intTypeReference, paddingField.paddingCondition, parserArguments)});
-                        while (_timesPadding-- > 0) {
-                        lengthInBits += ${simpleTypeReference.sizeInBits};
-                        }
-                        <#break>
-                    <#case "reserved">
-                        <#assign reservedField = field.asReservedField().orElseThrow()>
-                        <#assign simpleTypeReference = reservedField.type.asSimpleTypeReference().orElseThrow()>
-
-                        // Reserved Field (reserved)
-                        lengthInBits += ${simpleTypeReference.sizeInBits};
-                        <#break>
-                    <#case "simple">
-                        <#assign simpleField = field.asSimpleField().orElseThrow()>
-
-                        // Simple field (${simpleField.name})
-                        <#if simpleField.type.isSimpleTypeReference()>
-                            <#assign simpleTypeReference = simpleField.type.asSimpleTypeReference().orElseThrow()>
-                            <#if simpleTypeReference.isVstringTypeReference()>
-                                <#assign vstringTypeReference = simpleTypeReference.asVstringTypeReference().orElseThrow()>
-                                lengthInBits += ${helper.toSerializationExpression(simpleField, helper.intTypeReference, vstringTypeReference.getLengthExpression(), parserArguments)};
-                            <#else>
-                                lengthInBits += ${simpleTypeReference.sizeInBits};
-                            </#if>
-                        <#elseif helper.isEnumField(field)>
-                            lengthInBits += ${helper.getEnumBaseTypeReference(simpleField.type).sizeInBits};
-                        <#elseif simpleField.type.isDataIoTypeReference()>
-                            lengthInBits += ${simpleField.type.asComplexTypeReference().orElseThrow().name}.getLengthInBits(${simpleField.name}<#if simpleField.type.asComplexTypeReference().orElseThrow().params?has_content>, <#list simpleField.type.asComplexTypeReference().orElseThrow().params.orElseThrow() as param>${helper.toParseExpression(simpleField, helper.anyTypeReference, param, parserArguments)}<#sep>, </#sep></#list></#if>);
-                        <#else>
-                            lengthInBits += ${simpleField.name}.getLengthInBits();
-                        </#if>
-                        <#break>
-                    <#case "switch">
-                        <#assign switchField = field.asSwitchField().orElseThrow()>
-
-                        // Length of sub-type elements will be added by sub-type...
-                        <#break>
-                    <#case "unknown">
-                        <#assign unknownField = field.asUnknownField().orElseThrow()>
-                        <#assign simpleTypeReference = unknownField.type.asSimpleTypeReference().orElseThrow()>
-
-                        // Unknown field
-                        lengthInBits += ${simpleTypeReference.sizeInBits};
-                        <#break>
-                    <#case "virtual">
-                        <#assign virtualField = field.asVirtualField().orElseThrow()>
-
-                        // A virtual field doesn't have any in- or output.
-                        <#break>
-                </#switch>
-            </#list>
-            }<#sep> else </#sep>
-        </#list>
-
-        return lengthInBits;
-    }
-
-    public static void staticSerialize(WriteBuffer writeBuffer, PlcValue _value<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type, false)} ${parserArgument.name}<#sep>, </#sep></#list></#if>) throws SerializationException {
-        staticSerialize(writeBuffer, _value<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${parserArgument.name}<#sep>, </#sep></#list></#if>, ByteOrder.BIG_ENDIAN);
-    }
-
-    public static void staticSerialize(WriteBuffer writeBuffer, PlcValue _value<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type, false)} ${parserArgument.name}<#sep>, </#sep></#list></#if>, ByteOrder byteOrder) throws SerializationException {
-        <#list dataIoTypeDefinition.switchField.orElseThrow().cases as case>
-            <#--
-                Output the if-expression for this case
-            -->
-            <@compress single_line=true>
-                <#if case.discriminatorValueTerms?has_content>
-                    if(
-                    <#list case.discriminatorValueTerms as discriminatorValueTerm>
-                        <#if helper.isWildcard(discriminatorValueTerm)>
-                            true
-                        <#else>
-                            <#assign switchField=dataIoTypeDefinition.switchField.orElseThrow()>
-                            <#assign discriminatorExpression=switchField.discriminatorExpressions[discriminatorValueTerm?index].asLiteral().orElseThrow().asVariableLiteral().orElseThrow()>
-                            <#assign discriminatorType=helper.getDiscriminatorTypes()[discriminatorExpression.discriminatorName]>
-                            EvaluationHelper.equals(
-                            ${helper.toParseExpression(switchField, discriminatorType, discriminatorExpression, parserArguments)},
-                            <#if discriminatorType.isEnumTypeReference()>
-                                ${helper.getLanguageTypeNameForTypeReference(discriminatorType)}.${helper.toParseExpression(switchField, discriminatorType, discriminatorValueTerm, parserArguments)}
-                            <#else>
-                                (${helper.getLanguageTypeNameForTypeReference(discriminatorType, true)}) ${helper.toParseExpression(switchField, discriminatorType, discriminatorValueTerm, parserArguments)}
-                            </#if>
-                            )
-                        </#if>
-                        <#sep> && </#sep>
-                    </#list>
-                    )
-                </#if>{ // ${case.name}
-            </...@compress>
-            <#--
-                Output the body of this case
-            -->
-            <#if case.name == "Struct">
-                // Output something here ...
-            <#else>
-            <#list case.fields as field>
-                <#switch field.typeName>
-                    <#case "array">
-                        <#assign arrayField = field.asArrayField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Array Field (${arrayField.name})
-                        <#if arrayField.type.elementTypeReference.isByteBased()>
-                            writeByteArrayField("${namedField.name}", _value.getRaw(), writeByteArray(writeBuffer, 8)${helper.getFieldOptions(typedField, parserArguments)});
-                        <#elseif arrayField.type.elementTypeReference.isSimpleTypeReference()>
-                            writeSimpleTypeArrayField("${namedField.name}", _value.getList().stream().map(PlcValue::get${helper.getLanguageTypeNameForTypeReference(arrayField.type.elementTypeReference.asSimpleTypeReference().orElseThrow())}).collect(Collectors.toList()), ${helper.getDataWriterCall(arrayField.type.elementTypeReference, namedField.name)}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#else>
-                            writeComplexTypeArrayField("${namedField.name}", _value, writeBuffer${helper.getFieldOptions(typedField, parserArguments)});
-                        </#if>
-                        <#break>
-                    <#case "checksum">
-                        <#assign checksumField = field.asChecksumField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Checksum Field (checksum) (Calculated)
-                        writeChecksumField("${namedField.name}", (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(checksumField, checksumField.type, checksumField.checksumExpression, parserArguments)}), ${helper.getDataWriterCall(typedField.type, namedField.name)}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "const">
-                        <#assign constField = field.asConstField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Const Field (${constField.name})
-                        <#if typedField.type.isEnumTypeReference()>writeConstField("${constField.name}", ${namedField.name?upper_case}.getValue(), ${helper.getDataWriterCall(helper.getEnumBaseTypeReference(typedField.type), namedField.name)}${helper.getFieldOptions(typedField, parserArguments)});<#else>writeConstField("${constField.name}", ${namedField.name?upper_case}, ${helper.getDataWriterCall(typedField.type, namedField.name)}${helper.getFieldOptions(typedField, parserArguments)});</#if>
-                        <#break>
-                    <#case "enum">
-                        <#assign enumField = field.asEnumField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Enum field (${namedField.name})
-                        writeEnumField("${namedField.name}", "${helper.getLanguageTypeNameForField(field)}", ${namedField.name}, ${helper.getEnumDataWriterCall(typedField.type, namedField.name, enumField.fieldName)}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "implicit">
-                        <#assign implicitField = field.asImplicitField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Implicit Field (${implicitField.name}) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
-                    <#-- Implicit field values might be used in expressions, in order to avoid problems, we generate a temporary variable with the given name. -->
-                        ${helper.getLanguageTypeNameForField(field)} ${implicitField.name} = (${helper.getLanguageTypeNameForField(field)}) (${helper.toSerializationExpression(implicitField, implicitField.type, implicitField.serializeExpression, parserArguments)});
-                        writeImplicitField("${namedField.name}", ${implicitField.name}, ${helper.getDataWriterCall(typedField.type, namedField.name)}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "manualArray">
-                        <#assign manualArrayField = field.asManualArrayField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Manual Array Field (${manualArrayField.name})
-                        writeManualArrayField("${namedField.name}", ${namedField.name}, (${helper.getLanguageTypeNameForTypeReference(manualArrayField.type.elementTypeReference)} _value) -> ${helper.toParseExpression(manualArrayField, manualArrayField.type.elementTypeReference, manualArrayField.serializeExpression, parserArguments)}, writeBuffer${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "manual">
-                        <#assign manualField = field.asManualField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Manual Field (${manualField.name})
-                        writeManualField("${namedField.name}", () -> ${helper.toParseExpression(manualField, manualField.type, manualField.serializeExpression, parserArguments)}, writeBuffer${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "optional">
-                        <#assign optionalField = field.asOptionalField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Optional Field (${optionalField.name}) (Can be skipped, if the value is null)
-                        <#if optionalField.type.isEnumTypeReference()>
-                            writeOptionalEnumField("${optionalField.name}", "${helper.getLanguageTypeNameForField(field)}", ${optionalField.name}, ${helper.getEnumDataWriterCall(optionalField.type, optionalField.name, "value")}<#if optionalField.conditionExpression.present>, ${helper.toSerializationExpression(optionalField, helper.boolTypeReference, optionalField.conditionExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, parserArguments)});
-                        <#elseif optionalField.type.isDataIoTypeReference()>
-                            writeOptionalField("${optionalField.name}", ${optionalField.name}, new DataWriterDataIoDefault(writeBuffer, (wb, val) -> ${optionalField.type.asComplexTypeReference().orElseThrow().name}.staticSerialize(wb, val<#if optionalField.type.asComplexTypeReference().orElseThrow().params?has_content>, <#list optionalField.type.asComplexTypeReference().orElseThrow().params.orElseThrow() as param>${helper.toParseExpression(optionalField, helper.anyTypeReference, param, p [...]
-                        <#else>
-                            writeOptionalField("${optionalField.name}", ${optionalField.name}, ${helper.getDataWriterCall(typedField.type, optionalField.name)}<#if helper.isGeneratePropertiesForParserArguments() && optionalField.conditionExpression.present>, ${helper.toSerializationExpression(optionalField, helper.boolTypeReference, optionalField.conditionExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, parserArguments)});
-                        </#if>
-                        <#break>
-                    <#case "padding">
-                        <#assign paddingField = field.asPaddingField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-
-                        // Padding Field (padding)
-                        writePaddingField("padding", (int) (${helper.toParseExpression(paddingField, helper.intTypeReference, paddingField.paddingCondition, parserArguments)}), (${helper.getLanguageTypeNameForField(field)}) ${helper.toSerializationExpression(paddingField, paddingField.type, paddingField.paddingValue, parserArguments)}, ${helper.getDataWriterCall(typedField.type, "padding")}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#break>
-                    <#case "reserved">
-                        <#assign reservedField = field.asReservedField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-
-                        // Reserved Field (reserved)
-                        writeReservedField("reserved", <#if helper.isGeneratePropertiesForReservedFields()>reservedField${reservedFieldIndex}!=null?reservedField${reservedFieldIndex}:</#if>${helper.getReservedValue(reservedField)}, ${helper.getDataWriterCall(typedField.type, "reserved")}${helper.getFieldOptions(typedField, parserArguments)});<#assign reservedFieldIndex=reservedFieldIndex+1>
-                        <#break>
-                    <#case "simple">
-                        <#assign simpleField = field.asSimpleField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Simple Field (${namedField.name})
-                        <#if typedField.type.isEnumTypeReference()>
-                            writeSimpleEnumField("${simpleField.name}", "${helper.getLanguageTypeNameForField(field)}", (${helper.getLanguageTypeNameForTypeReference(simpleField.type, true)}) ${helper.getDataIoPropertyValue(simpleField)}, ${helper.getEnumDataWriterCall(simpleField.type, simpleField.name, "value")}${helper.getFieldOptions(typedField, parserArguments)});
-                        <#elseif simpleField.type.isDataIoTypeReference()>
-                            writeSimpleField("${simpleField.name}", (${helper.getLanguageTypeNameForTypeReference(simpleField.type, true)}) ${helper.getDataIoPropertyValue(simpleField)}, new DataWriterDataIoDefault(writeBuffer, (wb, val) -> ${simpleField.type.asComplexTypeReference().orElseThrow().name}.staticSerialize(wb, val<#if simpleField.type.asComplexTypeReference().orElseThrow().params?has_content>, <#list simpleField.type.asComplexTypeReference().orElseThrow().params.orElseThrow( [...]
-                        <#else>
-                            writeSimpleField("${simpleField.name}", (${helper.getLanguageTypeNameForTypeReference(simpleField.type, true)}) ${helper.getDataIoPropertyValue(simpleField)}, ${helper.getDataWriterCall(typedField.type, simpleField.name)}${helper.getFieldOptions(typedField, parserArguments)});</#if>
-                        <#break>
-                    <#case "virtual">
-                        <#assign virtualField = field.asVirtualField().orElseThrow()>
-                        <#assign typedField = field.asTypedField().orElseThrow()>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-
-                        // Virtual field (doesn't actually serialize anything, just makes the value available)
-                        ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = get${namedField.name?cap_first}();
-                        writeBuffer.writeVirtual("${namedField.name}", ${namedField.name});
-                        <#break>
-                </#switch>
-            </#list>
-            </#if>
-            }<#sep> else </#sep>
-        </#list>
-    }
-
-}
-</#outputformat>
diff --git a/code-generation/language/java/src/main/resources/templates/java/enum-template.java.ftlh b/code-generation/language/java/src/main/resources/templates/java/enum-template.java.ftlh
deleted file mode 100644
index 1e2cde81ec..0000000000
--- a/code-generation/language/java/src/main/resources/templates/java/enum-template.java.ftlh
+++ /dev/null
@@ -1,177 +0,0 @@
-<#--
-<#--
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you 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
-
-      https://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.
--->
-<#-- Prevent freemarker from escaping stuff -->
-<#outputformat "undefined">
-<#-- Declare the name and type of variables passed in to the template -->
-<#-- @ftlvariable name="languageName" type="java.lang.String" -->
-<#-- @ftlvariable name="protocolName" type="java.lang.String" -->
-<#-- @ftlvariable name="outputFlavor" type="java.lang.String" -->
-<#-- @ftlvariable name="helper" type="org.apache.plc4x.language.java.JavaLanguageTemplateHelper" -->
-<#-- @ftlvariable name="tracer" type="org.apache.plc4x.plugins.codegenerator.protocol.freemarker.Tracer" -->
-<#-- @ftlvariable name="type" type="org.apache.plc4x.plugins.codegenerator.types.definitions.EnumTypeDefinition" -->
-<#if !helper.isExternal()>${helper.packageName(protocolName, languageName, outputFlavor)?replace(".", "/")}/${type.name}.java</#if>
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you 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
- *
- *   https://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 ${helper.packageName(protocolName, languageName, outputFlavor)};
-
-import org.apache.plc4x.java.spi.generation.Message;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-${helper.getExternalTypeImports()}
-
-// Code generated by code-generation. DO NOT EDIT.
-
-public enum ${type.name} {
-
-<@compress single_line=true>
-    <#list type.enumValues as enumValue>
-        ${enumValue.name}(
-            <#if type.type.isPresent()>
-                (${helper.getLanguageTypeNameForTypeReference(type.type.orElseThrow(), true)})
-                <#if type.type.orElseThrow().isNonSimpleTypeReference()>
-                    <#if type.type.orElseThrow().isEnumTypeReference()>
-                        ${helper.getLanguageTypeNameForTypeReference(type.type.orElseThrow(), true)}.${enumValue.value}
-                    <#else>
-                        ${enumValue.value}
-                    </#if>
-                <#else>
-                    ${enumValue.value}<#if helper.needsLongMarker(type.type)>L</#if>
-                </#if>
-            </#if>
-            <#if type.constantNames?has_content>
-                <#if type.type?has_content>, </#if>
-                <#list type.constantNames as constantName>
-                    <#if type.getConstantType(constantName).isNonSimpleTypeReference()>
-                        <#if helper.escapeValue(type.getConstantType(constantName), enumValue.getConstant(constantName).orElse(null)) == 'null'>
-                            null
-                        <#elseif type.getConstantType(constantName).isEnumTypeReference()>
-                            ${helper.getLanguageTypeNameForTypeReference(type.getConstantType(constantName), true)}.${helper.escapeValue(type.getConstantType(constantName), enumValue.getConstant(constantName).orElseThrow())}<#else>(${helper.getLanguageTypeNameForTypeReference(type.getConstantType(constantName), true)}) ${helper.escapeValue(type.getConstantType(constantName), enumValue.getConstant(constantName).orElseThrow())}</#if><#else>(${helper.getLanguageTypeNameForTypeReference(type [...]
-                        </#if>
-                    <#sep>, </#sep>
-                </#list>
-            </#if>)
-        <#sep>, </#sep>
-    </#list>;
-</...@compress>
-
-<#if type.type.isPresent()>
-    private static final Map<${helper.getLanguageTypeNameForTypeReference(type.type.orElseThrow(), false)}, ${type.name}> map;
-    static {
-        map = new HashMap<>();
-        for (${type.name} value : ${type.name}.values()) {
-            map.put((${helper.getLanguageTypeNameForTypeReference(type.type.orElseThrow(), true)}) value.getValue(), value);
-        }
-    }
-
-    private final ${helper.getLanguageTypeNameForTypeReference(type.type.orElseThrow(), true)} value;
-</#if>
-<#if type.constantNames?has_content>
-    <#list type.constantNames as constantName>
-        private final ${helper.getLanguageTypeNameForTypeReference(type.getConstantType(constantName), true)} ${constantName};
-    </#list>
-</#if>
-
-    ${type.name}(<#if type.type.isPresent()>${helper.getLanguageTypeNameForTypeReference(type.type.orElseThrow(), true)} value</#if><#if type.constantNames?has_content><#if type.type?has_content>, </#if><#list type.constantNames as constantName>${helper.getLanguageTypeNameForTypeReference(type.getConstantType(constantName), true)} ${constantName}<#sep>, </#sep></#list></#if>) {
-<#if type.type.isPresent()>        this.value = value;</#if>
-<#if type.constantNames?has_content>
-    <#list type.constantNames as constantName>
-        this.${constantName} = ${constantName};
-    </#list>
-</#if>
-    }
-
-<#if type.type.isPresent()>
-    public ${helper.getLanguageTypeNameForTypeReference(type.type.orElseThrow(), true)} getValue() {
-        return value;
-    }
-</#if>
-
-<#if type.constantNames?has_content>
-    <#list type.constantNames as constantName>
-    public ${helper.getLanguageTypeNameForTypeReference(type.getConstantType(constantName), true)} get${constantName?cap_first}() {
-        return ${constantName};
-    }
-
-    public static ${type.name} firstEnumForField${constantName?cap_first}(${helper.getLanguageTypeNameForTypeReference(type.getConstantType(constantName), true)} fieldValue) {
-        for (${type.name} _val : ${type.name}.values()) {
-        <#if type.name == "String" || helper.getLanguageTypeNameForTypeReference(type.getConstantType(constantName), true) == "String">
-            if(_val.get${constantName?cap_first}().equals(fieldValue)) {
-                return _val;
-            }
-        <#else>
-            if(_val.get${constantName?cap_first}() == fieldValue) {
-                return _val;
-            }
-        </#if>
-        }
-        return null;
-    }
-
-    public static List<${type.name}> enumsForField${constantName?cap_first}(${helper.getLanguageTypeNameForTypeReference(type.getConstantType(constantName), true)} fieldValue) {
-        List<${type.name}> _values = new ArrayList<>();
-        for (${type.name} _val : ${type.name}.values()) {
-        <#if type.name == "String" || helper.getLanguageTypeNameForTypeReference(type.getConstantType(constantName), true) == "String">
-            if(_val.get${constantName?cap_first}().equals(fieldValue)) {
-                _values.add(_val);
-            }
-        <#else>
-            if(_val.get${constantName?cap_first}() == fieldValue) {
-                _values.add(_val);
-            }
-        </#if>
-        }
-        return _values;
-    }
-
-    </#list>
-</#if>
-<#if type.type.isPresent()>
-    public static ${type.name} enumForValue(${helper.getLanguageTypeNameForTypeReference(type.type.orElseThrow(), true)} value) {
-        return map.get(value);
-    }
-</#if>
-
-<#if type.type.isPresent()>
-    public static Boolean isDefined(${helper.getLanguageTypeNameForTypeReference(type.type.orElseThrow(), true)} value) {
-        return map.containsKey(value);
-    }
-</#if>
-
-}
-</#outputformat>
diff --git a/code-generation/language/java/src/test/resources/integration-test/pom.xml b/code-generation/language/java/src/test/resources/integration-test/pom.xml
deleted file mode 100644
index 4ffa0c1eb2..0000000000
--- a/code-generation/language/java/src/test/resources/integration-test/pom.xml
+++ /dev/null
@@ -1,201 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you 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
-
-      https://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.
-  -->
-<project xmlns="http://maven.apache.org/POM/4.1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.1.0 http://maven.apache.org/xsd/maven-4.1.0.xsd">
-  <modelVersion>4.1.0</modelVersion>
-
-  <parent>
-    <groupId>org.apache.plc4x</groupId>
-    <artifactId>plc4x-code-generation</artifactId>
-    <version>@project.version@</version>
-    <relativePath/>
-  </parent>
-
-  <artifactId>plc4j-java-mspec-test</artifactId>
-
-  <name>PLC4J: Driver: Java Mspec Test</name>
-  <description></description>
-
-  <build>
-    <plugins>
-      <plugin>
-        <groupId>org.apache.plc4x.plugins</groupId>
-        <artifactId>plc4x-maven-plugin</artifactId>
-        <version>${plc4x-code-generation.version}</version>
-        <executions>
-          <execution>
-            <id>generate-driver</id>
-            <phase>generate-sources</phase>
-            <goals>
-              <goal>generate-driver</goal>
-            </goals>
-            <configuration>
-              <protocolName>test</protocolName>
-              <languageName>java</languageName>
-              <outputFlavor>read-write</outputFlavor>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
-      <plugin>
-        <groupId>org.apache.karaf.tooling</groupId>
-        <artifactId>karaf-maven-plugin</artifactId>
-        <executions>
-          <execution>
-            <id>generate-feature-xml</id>
-            <phase>compile</phase>
-            <goals>
-              <!-- Generate the feature.xml -->
-              <goal>features-generate-descriptor</goal>
-              <!-- Check the feature.xml -->
-              <goal>verify</goal>
-            </goals>
-            <configuration>
-              <enableGeneration>true</enableGeneration>
-              <aggregateFeatures>true</aggregateFeatures>
-            </configuration>
-          </execution>
-          <execution>
-            <id>build-kar</id>
-            <phase>package</phase>
-            <goals>
-              <!--
-                Build a kar archive (Jar containing the feature.xml
-                as well as the module content and it's dependencies.
-              -->
-              <goal>kar</goal>
-            </goals>
-          </execution>
-        </executions>
-      </plugin>
-      <plugin>
-        <groupId>org.apache.felix</groupId>
-        <artifactId>maven-bundle-plugin</artifactId>
-        <extensions>true</extensions>
-        <configuration>
-          <instructions>
-            <Bundle-SymbolicName>${project.groupId}.${project.artifactId}</Bundle-SymbolicName>
-            <Bundle-Activator>org.apache.plc4x.java.osgi.DriverActivator</Bundle-Activator>
-            <Export-Service>org.apache.plc4x.java.api.PlcDriver,org.apache.plc4x.protocol.test
-            </Export-Service>
-            <Import-Package>
-              *
-            </Import-Package>
-          </instructions>
-        </configuration>
-      </plugin>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-dependency-plugin</artifactId>
-        <configuration>
-          <usedDependencies combine.children="append">
-            <usedDependency>org.apache.plc4x:plc4x-code-generation-language-java</usedDependency>
-            <usedDependency>org.apache.plc4x:plc4x-code-generation-protocol-test</usedDependency>
-          </usedDependencies>
-        </configuration>
-      </plugin>
-
-      <!--
-          Make the failsafe execute all integration-tests
-        -->
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-failsafe-plugin</artifactId>
-        <executions>
-          <execution>
-            <goals>
-              <goal>integration-test</goal>
-              <goal>verify</goal>
-            </goals>
-          </execution>
-        </executions>
-        <configuration>
-          <!--
-                Notice the @ instead of the $ as prefix? That's late evaluation.
-          -->
-          <!--argLine>@{failsafeArgLine}</argLine-->
-        </configuration>
-      </plugin>
-    </plugins>
-  </build>
-
-<dependencies>
-  <dependency>
-    <groupId>org.apache.plc4x</groupId>
-    <artifactId>plc4j-api</artifactId>
-    <version>@project.version@</version>
-  </dependency>
-
-  <dependency>
-    <groupId>org.apache.plc4x</groupId>
-    <artifactId>plc4j-spi-buffers-byte</artifactId>
-    <version>@project.version@</version>
-  </dependency>
-
-    <dependency>
-      <groupId>org.apache.plc4x</groupId>
-      <artifactId>plc4j-transports-tcp</artifactId>
-      <version>@project.version@</version>
-    </dependency>
-
-    <dependency>
-      <groupId>io.netty</groupId>
-      <artifactId>netty-buffer</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>org.apache.commons</groupId>
-      <artifactId>commons-lang3</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>org.apache.plc4x</groupId>
-      <artifactId>plc4j-utils-test-utils</artifactId>
-      <version>@project.version@</version>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>org.apache.plc4x</groupId>
-      <artifactId>plc4x-code-generation-language-java</artifactId>
-      <version>@project.version@</version>
-      <!-- Scope is 'provided' as this way it's not shipped with the driver -->
-      <scope>provided</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>org.apache.plc4x</groupId>
-      <artifactId>plc4x-code-generation-protocol-test</artifactId>
-      <version>@project.version@</version>
-    </dependency>
-
-    <dependency>
-      <groupId>org.apache.plc4x</groupId>
-      <artifactId>plc4x-code-generation-protocol-test</artifactId>
-      <version>@project.version@</version>
-      <classifier>tests</classifier>
-      <type>test-jar</type>
-      <scope>test</scope>
-    </dependency>
-
-  </dependencies>
-
-</project>
-
diff --git a/code-generation/language/java/src/test/resources/integration-test/src/main/java/org/apache/plc4x/java/test/readwrite/utils/StaticHelper.java b/code-generation/language/java/src/test/resources/integration-test/src/main/java/org/apache/plc4x/java/test/readwrite/utils/StaticHelper.java
deleted file mode 100644
index aef1fd594f..0000000000
--- a/code-generation/language/java/src/test/resources/integration-test/src/main/java/org/apache/plc4x/java/test/readwrite/utils/StaticHelper.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you 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
- *
- *   https://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 org.apache.plc4x.java.test.readwrite.utils;
-
-import org.apache.plc4x.java.spi.generation.*;
-
-public class StaticHelper {
-
-    public static boolean parseBit(ReadBuffer io) {
-        throw new IllegalArgumentException("Hurz!");
-    }
-
-    public static void serializeBit(WriteBuffer io, boolean data) {
-    }
-
-    public static byte parseByte(ReadBuffer io) {
-        throw new IllegalArgumentException("Hurz!");
-    }
-
-    public static void serializeByte(WriteBuffer io, byte data) {
-    }
-
-    public static byte parseInt8(ReadBuffer io) {
-        throw new IllegalArgumentException("Hurz!");
-    }
-
-    public static void serializeInt8(WriteBuffer io, byte data) {
-    }
-
-    public static short parseUint8(ReadBuffer io) {
-        throw new IllegalArgumentException("Hurz!");
-    }
-
-    public static void serializeUint8(WriteBuffer io, short data) {
-    }
-
-    public static float parseFloat(ReadBuffer io) {
-        throw new IllegalArgumentException("Hurz!");
-    }
-
-    public static void serializeFloat(WriteBuffer io, float data) {
-    }
-
-    public static double parseDouble(ReadBuffer io) {
-        throw new IllegalArgumentException("Hurz!");
-    }
-
-    public static void serializeDouble(WriteBuffer io, double data) {
-    }
-
-    public static String parseString(ReadBuffer io) {
-        throw new IllegalArgumentException("Hurz!");
-    }
-
-    public static void serializeString(WriteBuffer io, String data) {
-    }
-
-    public static short readAManualField(ReadBuffer io, short simpleField) {
-        return 0;
-    }
-
-    public static void writeAManualField(WriteBuffer io, short simpleFlied) {
-
-    }
-
-    public static short crcInt8(int num) {
-        return (byte) num;
-    }
-
-    public static short crcUint8(int num) {
-        return (short) num;
-    }
-
-}
diff --git a/code-generation/language/java/src/test/resources/settings.xml b/code-generation/language/java/src/test/resources/settings.xml
deleted file mode 100644
index 7e9bc3609a..0000000000
--- a/code-generation/language/java/src/test/resources/settings.xml
+++ /dev/null
@@ -1,53 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you 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
-
-      https://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.
-  -->
-<settings>
-  <profiles>
-    <profile>
-      <id>it-repo</id>
-      <activation>
-        <activeByDefault>true</activeByDefault>
-      </activation>
-      <repositories>
-        <repository>
-          <id>local.central</id>
-          <url>@localRepositoryUrl@</url>
-          <releases>
-            <enabled>true</enabled>
-          </releases>
-          <snapshots>
-            <enabled>true</enabled>
-          </snapshots>
-        </repository>
-      </repositories>
-      <pluginRepositories>
-        <pluginRepository>
-          <id>local.central</id>
-          <url>@localRepositoryUrl@</url>
-          <releases>
-            <enabled>true</enabled>
-          </releases>
-          <snapshots>
-            <enabled>true</enabled>
-          </snapshots>
-        </pluginRepository>
-      </pluginRepositories>
-    </profile>
-  </profiles>
-</settings>
\ No newline at end of file
diff --git a/code-generation/language/pom.xml b/code-generation/language/pom.xml
index 1a5ce689bf..d2e507d524 100644
--- a/code-generation/language/pom.xml
+++ b/code-generation/language/pom.xml
@@ -61,7 +61,6 @@
       <id>with-java</id>
       <subprojects>
         <subproject>java</subproject>
-        <subproject>java-jp</subproject>
       </subprojects>
     </profile>
 
diff --git a/plc4j/drivers/ab-eth/pom.xml b/plc4j/drivers/ab-eth/pom.xml
index 7612e06c4f..f5e0a7c766 100644
--- a/plc4j/drivers/ab-eth/pom.xml
+++ b/plc4j/drivers/ab-eth/pom.xml
@@ -228,7 +228,7 @@
       <dependencies>
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
           <version>1.0.0-SNAPSHOT</version>
           <!-- Scope is 'provided' as this way it's not shipped with the driver -->
           <scope>provided</scope>
diff --git a/plc4j/drivers/ads/pom.xml b/plc4j/drivers/ads/pom.xml
index 42371770f4..c1f0ca1752 100644
--- a/plc4j/drivers/ads/pom.xml
+++ b/plc4j/drivers/ads/pom.xml
@@ -269,7 +269,8 @@
 
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>          <version>1.0.0-SNAPSHOT</version>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
+          <version>1.0.0-SNAPSHOT</version>
           <!-- Scope is 'provided' as this way it's not shipped with the driver -->
           <scope>provided</scope>
         </dependency>
diff --git a/plc4j/drivers/bacnet/pom.xml b/plc4j/drivers/bacnet/pom.xml
index 3b1b2130d5..c42a4d5364 100644
--- a/plc4j/drivers/bacnet/pom.xml
+++ b/plc4j/drivers/bacnet/pom.xml
@@ -258,7 +258,8 @@
       <dependencies>
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>          <version>1.0.0-SNAPSHOT</version>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
+          <version>1.0.0-SNAPSHOT</version>
           <!-- Scope is 'provided' as this way it's not shipped with the driver -->
           <scope>provided</scope>
         </dependency>
diff --git a/plc4j/drivers/c-bus/pom.xml b/plc4j/drivers/c-bus/pom.xml
index 6737e83191..8987cff2bd 100644
--- a/plc4j/drivers/c-bus/pom.xml
+++ b/plc4j/drivers/c-bus/pom.xml
@@ -269,7 +269,8 @@
       <dependencies>
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>          <version>1.0.0-SNAPSHOT</version>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
+          <version>1.0.0-SNAPSHOT</version>
           <!-- Scope is 'provided' as this way it's not shipped with the driver -->
           <scope>provided</scope>
         </dependency>
diff --git a/plc4j/drivers/can/pom.xml b/plc4j/drivers/can/pom.xml
index 4b725c32f4..3839149c09 100644
--- a/plc4j/drivers/can/pom.xml
+++ b/plc4j/drivers/can/pom.xml
@@ -264,7 +264,7 @@
 
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
           <version>1.0.0-SNAPSHOT</version>
           <scope>provided</scope>
         </dependency>
diff --git a/plc4j/drivers/canopen/pom.xml b/plc4j/drivers/canopen/pom.xml
index 202c5b07d7..1108a0fb2f 100644
--- a/plc4j/drivers/canopen/pom.xml
+++ b/plc4j/drivers/canopen/pom.xml
@@ -276,7 +276,8 @@
 
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>          <version>1.0.0-SNAPSHOT</version>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
+          <version>1.0.0-SNAPSHOT</version>
           <!-- Scope is 'provided' as this way it's not shipped with the driver -->
           <scope>provided</scope>
         </dependency>
diff --git a/plc4j/drivers/eip/pom.xml b/plc4j/drivers/eip/pom.xml
index 4067eca854..8e24fdc941 100644
--- a/plc4j/drivers/eip/pom.xml
+++ b/plc4j/drivers/eip/pom.xml
@@ -319,7 +319,8 @@
       <dependencies>
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>          <version>1.0.0-SNAPSHOT</version>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
+          <version>1.0.0-SNAPSHOT</version>
           <!-- Scope is 'provided' as this way it's not shipped with the driver -->
           <scope>provided</scope>
         </dependency>
diff --git a/plc4j/drivers/firmata/pom.xml b/plc4j/drivers/firmata/pom.xml
index 6f0725d7e4..430a1170a3 100644
--- a/plc4j/drivers/firmata/pom.xml
+++ b/plc4j/drivers/firmata/pom.xml
@@ -318,7 +318,8 @@
       <dependencies>
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>          <version>1.0.0-SNAPSHOT</version>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
+          <version>1.0.0-SNAPSHOT</version>
           <!-- Scope is 'provided' as this way it's not shipped with the driver -->
           <scope>provided</scope>
         </dependency>
diff --git a/plc4j/drivers/iec-60870/pom.xml b/plc4j/drivers/iec-60870/pom.xml
index cdf905aa68..8a295d0da4 100644
--- a/plc4j/drivers/iec-60870/pom.xml
+++ b/plc4j/drivers/iec-60870/pom.xml
@@ -259,7 +259,8 @@
       <dependencies>
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>          <version>1.0.0-SNAPSHOT</version>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
+          <version>1.0.0-SNAPSHOT</version>
           <!-- Scope is 'provided' as this way it's not shipped with the driver -->
           <scope>provided</scope>
         </dependency>
diff --git a/plc4j/drivers/knxnetip/pom.xml b/plc4j/drivers/knxnetip/pom.xml
index 5dd8f23e8e..31df299008 100644
--- a/plc4j/drivers/knxnetip/pom.xml
+++ b/plc4j/drivers/knxnetip/pom.xml
@@ -276,7 +276,8 @@
       <dependencies>
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>          <version>1.0.0-SNAPSHOT</version>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
+          <version>1.0.0-SNAPSHOT</version>
           <!-- Scope is 'provided' as this way it's not shipped with the driver -->
           <scope>provided</scope>
         </dependency>
diff --git a/plc4j/drivers/modbus/pom.xml b/plc4j/drivers/modbus/pom.xml
index dbb79f7c62..3878c2efcb 100644
--- a/plc4j/drivers/modbus/pom.xml
+++ b/plc4j/drivers/modbus/pom.xml
@@ -306,7 +306,8 @@
       <dependencies>
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>          <version>1.0.0-SNAPSHOT</version>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
+          <version>1.0.0-SNAPSHOT</version>
           <!-- Scope is 'provided' as this way it's not shipped with the driver -->
           <scope>provided</scope>
         </dependency>
diff --git a/plc4j/drivers/opcua/pom.xml b/plc4j/drivers/opcua/pom.xml
index ad22fc43ba..a2bcccecbc 100644
--- a/plc4j/drivers/opcua/pom.xml
+++ b/plc4j/drivers/opcua/pom.xml
@@ -357,7 +357,8 @@
       <dependencies>
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>          <version>1.0.0-SNAPSHOT</version>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
+          <version>1.0.0-SNAPSHOT</version>
           <!-- Scope is 'provided' as this way it's not shipped with the driver -->
           <scope>provided</scope>
         </dependency>
diff --git a/plc4j/drivers/open-protocol/pom.xml b/plc4j/drivers/open-protocol/pom.xml
index a409dc7901..68e4c1986b 100644
--- a/plc4j/drivers/open-protocol/pom.xml
+++ b/plc4j/drivers/open-protocol/pom.xml
@@ -232,7 +232,8 @@
       <dependencies>
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>          <version>1.0.0-SNAPSHOT</version>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
+          <version>1.0.0-SNAPSHOT</version>
           <!-- Scope is 'provided' as this way it's not shipped with the driver -->
           <scope>provided</scope>
         </dependency>
diff --git a/plc4j/drivers/plc4x/pom.xml b/plc4j/drivers/plc4x/pom.xml
index f3dc24a629..b0f8928d7b 100644
--- a/plc4j/drivers/plc4x/pom.xml
+++ b/plc4j/drivers/plc4x/pom.xml
@@ -214,7 +214,8 @@
       <dependencies>
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>          <version>1.0.0-SNAPSHOT</version>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
+          <version>1.0.0-SNAPSHOT</version>
           <!-- Scope is 'provided' as this way it's not shipped with the driver -->
           <scope>provided</scope>
         </dependency>
diff --git a/plc4j/drivers/profinet-ng/pom.xml b/plc4j/drivers/profinet-ng/pom.xml
index 90666828b3..3a813726a2 100644
--- a/plc4j/drivers/profinet-ng/pom.xml
+++ b/plc4j/drivers/profinet-ng/pom.xml
@@ -286,7 +286,8 @@
       <dependencies>
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>          <version>1.0.0-SNAPSHOT</version>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
+          <version>1.0.0-SNAPSHOT</version>
           <!-- Scope is 'provided' as this way it's not shipped with the driver -->
           <scope>provided</scope>
         </dependency>
diff --git a/plc4j/drivers/profinet/pom.xml b/plc4j/drivers/profinet/pom.xml
index f8ad39b70e..3e308ca0b8 100644
--- a/plc4j/drivers/profinet/pom.xml
+++ b/plc4j/drivers/profinet/pom.xml
@@ -294,7 +294,8 @@
       <dependencies>
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>          <version>1.0.0-SNAPSHOT</version>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
+          <version>1.0.0-SNAPSHOT</version>
           <!-- Scope is 'provided' as this way it's not shipped with the driver -->
           <scope>provided</scope>
         </dependency>
diff --git a/plc4j/drivers/s7/pom.xml b/plc4j/drivers/s7/pom.xml
index fa74432d06..225e27d194 100644
--- a/plc4j/drivers/s7/pom.xml
+++ b/plc4j/drivers/s7/pom.xml
@@ -296,7 +296,7 @@
             <artifactId>maven-dependency-plugin</artifactId>
             <configuration>
               <usedDependencies combine.children="append">
-                <usedDependency>org.apache.plc4x:plc4x-code-generation-language-java-jp</usedDependency>
+                <usedDependency>org.apache.plc4x:plc4x-code-generation-language-java</usedDependency>
                 <usedDependency>org.apache.plc4x:plc4x-protocols-s7</usedDependency>
               </usedDependencies>
             </configuration>
@@ -307,7 +307,7 @@
       <dependencies>
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
           <version>1.0.0-SNAPSHOT</version>
           <!-- Scope is 'provided' as this way it's not shipped with the driver -->
           <scope>provided</scope>
diff --git a/plc4j/drivers/simulated/pom.xml b/plc4j/drivers/simulated/pom.xml
index 8fda3f7217..a51a58426b 100644
--- a/plc4j/drivers/simulated/pom.xml
+++ b/plc4j/drivers/simulated/pom.xml
@@ -179,7 +179,8 @@
       <dependencies>
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>          <version>1.0.0-SNAPSHOT</version>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
+          <version>1.0.0-SNAPSHOT</version>
           <!-- Scope is 'provided' as this way it's not shipped with the driver -->
           <scope>provided</scope>
         </dependency>
diff --git a/plc4j/drivers/slmp/pom.xml b/plc4j/drivers/slmp/pom.xml
index 13ed8cc186..d8ca50f3bf 100644
--- a/plc4j/drivers/slmp/pom.xml
+++ b/plc4j/drivers/slmp/pom.xml
@@ -250,7 +250,7 @@
       <dependencies>
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
           <version>1.0.0-SNAPSHOT</version>
           <scope>provided</scope>
         </dependency>
diff --git a/plc4j/drivers/umas/pom.xml b/plc4j/drivers/umas/pom.xml
index d26ca00c72..9314ea43ac 100644
--- a/plc4j/drivers/umas/pom.xml
+++ b/plc4j/drivers/umas/pom.xml
@@ -236,7 +236,7 @@
       <dependencies>
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
           <version>1.0.0-SNAPSHOT</version>
           <scope>provided</scope>
         </dependency>
diff --git a/plc4j/transports/cotp/pom.xml b/plc4j/transports/cotp/pom.xml
index e309043e2e..e44c0a39a2 100644
--- a/plc4j/transports/cotp/pom.xml
+++ b/plc4j/transports/cotp/pom.xml
@@ -130,7 +130,7 @@
       <dependencies>
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
           <version>1.0.0-SNAPSHOT</version>
           <!-- Scope is 'provided' as this way it's not shipped with the driver -->
           <scope>provided</scope>
diff --git a/plc4j/transports/socketcan/pom.xml b/plc4j/transports/socketcan/pom.xml
index aa1b3fbceb..44cfe6f26f 100644
--- a/plc4j/transports/socketcan/pom.xml
+++ b/plc4j/transports/socketcan/pom.xml
@@ -130,7 +130,7 @@
 
         <dependency>
           <groupId>org.apache.plc4x</groupId>
-          <artifactId>plc4x-code-generation-language-java-jp</artifactId>
+          <artifactId>plc4x-code-generation-language-java</artifactId>
           <version>1.0.0-SNAPSHOT</version>
           <scope>provided</scope>
         </dependency>