fix(plc4x/codegen): add possibility to extract traces

this allows to save them to reattach it if a manipulation on expressions is needed

code-generation/language-base-freemarker/src/main/java/org/apache/plc4x/plugins/codegenerator/protocol/freemarker/Tracer.java

@@ -18,6 +18,10 @@
  */
 package org.apache.plc4x.plugins.codegenerator.protocol.freemarker;
 
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
 /**
  * Can be used to annotate generated code with traces out of the generator
  * <p>
@@ -50,7 +54,18 @@ public static Tracer start(String base) {
      * @return a new trace with current trace + sub trace
      */
     public Tracer dive(String sub) {
-        return new Tracer(currentTrace + separator() + sub);
+        Tracer that = this;
+        return new Tracer(currentTrace + separator() + sub) {
+            @Override
+            protected String prefix() {
+                return that.prefix();
+            }
+
+            @Override
+            protected String suffix() {
+                return that.suffix();
+            }
+        };
     }
 
     /**
@@ -63,7 +78,22 @@ public String removeTraces(String somethingContainingTraces) {
         if (somethingContainingTraces == null) {
             return null;
         }
-        return somethingContainingTraces.replaceAll("/\\*.*\\*/", "");
+        return somethingContainingTraces.replaceAll(Pattern.quote(prefix()) + ".*" + Pattern.quote(suffix()), "");
+    }
+
+    /**
+     * Can be used to extract traces from a traced string.
+     *
+     * @param somethingContainingTraces something containing traces
+     * @return trace of something containing traces or "" if not traces available
+     */
+    public String extractTraces(String somethingContainingTraces) {
+        Pattern pattern = Pattern.compile("(" + Pattern.quote(prefix()) + ".*" + Pattern.quote(suffix()) + ").*");
+        Matcher matcher = pattern.matcher(somethingContainingTraces);
+        if (!matcher.find()) {
+            return "";
+        }
+        return matcher.group(1);
     }
 
     protected String separator() {

code-generation/language-base-freemarker/src/test/java/org/apache/plc4x/plugins/codegenerator/protocol/freemarker/TracerTest.java

@@ -0,0 +1,146 @@
+package org.apache.plc4x.plugins.codegenerator.protocol.freemarker;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class TracerTest {
+
+    @BeforeEach
+    void setUp() {
+        Tracer.ENABLED = false;
+    }
+
+    @Test
+    void start() {
+        Tracer tracer = Tracer.start("random");
+        assertNotNull(tracer);
+        assertEquals("", tracer.toString());
+        Tracer.ENABLED = true;
+        assertEquals("/*random*/", tracer.toString());
+    }
+
+    @Test
+    void dive() {
+        Tracer tracer = Tracer.start("random");
+        assertNotNull(tracer);
+        assertEquals("", tracer.toString());
+        Tracer.ENABLED = true;
+        assertEquals("/*random*/", tracer.toString());
+        tracer = tracer.dive("something other");
+        assertEquals("/*random/something other*/", tracer.toString());
+        tracer = tracer.dive("something third");
+        assertEquals("/*random/something other/something third*/", tracer.toString());
+        String functionExpression = "someFunction(1+2)";
+        String someExpression = tracer + functionExpression;
+        Tracer subTracer = Tracer.start("subtracing").dive("even deeper");
+        String tracedExpression = subTracer + someExpression;
+        assertEquals("/*subtracing/even deeper*//*random/something other/something third*/" + functionExpression, tracedExpression);
+    }
+
+    @Test
+    void removeTraces() {
+        Tracer tracer = Tracer.start("random");
+        assertNotNull(tracer);
+        assertEquals("", tracer.toString());
+        Tracer.ENABLED = true;
+        assertEquals("/*random*/", tracer.toString());
+        String unTracedExpression = "someExpression(123,123)";
+        String expression = tracer + unTracedExpression;
+        assertEquals(unTracedExpression, tracer.removeTraces(expression));
+        Tracer subTracer = Tracer.start("subtracing").dive("even deeper");
+        String tracedExpression = subTracer + expression;
+        assertEquals(unTracedExpression, tracer.removeTraces(tracedExpression));
+    }
+
+    @Test
+    void extractTraces() {
+        Tracer tracer = Tracer.start("random");
+        assertNotNull(tracer);
+        assertEquals("", tracer.toString());
+        Tracer.ENABLED = true;
+        String trace = "/*random*/";
+        assertEquals(trace, tracer.toString());
+        String unTracedExpression = "someExpression(123,123)";
+        String expression = tracer + unTracedExpression;
+        assertEquals(unTracedExpression, tracer.removeTraces(expression));
+        assertEquals(trace, tracer.extractTraces(expression));
+        Tracer subTracer = Tracer.start("subtracing").dive("even deeper");
+        String tracedExpression = subTracer + expression;
+        assertEquals("/*subtracing/even deeper*//*random*/", tracer.extractTraces(tracedExpression));
+    }
+
+    @Test
+    void separator() {
+        String separator = "everythingIsPossible";
+        Tracer tracer = new Tracer("random") {
+            @Override
+            protected String separator() {
+                return separator;
+            }
+        };
+        assertNotNull(tracer);
+        assertEquals("", tracer.toString());
+        Tracer.ENABLED = true;
+        assertEquals("/*random*/", tracer.toString());
+        tracer = tracer.dive("something other");
+        assertEquals("/*random" + separator + "something other*/", tracer.toString());
+    }
+
+    @Test
+    void prefix() {
+        String prefix = "everythingIsPossible";
+        Tracer tracer = new Tracer("random") {
+            @Override
+            protected String prefix() {
+                return prefix;
+            }
+        };
+        assertNotNull(tracer);
+        assertEquals("", tracer.toString());
+        Tracer.ENABLED = true;
+        assertEquals(prefix + "random*/", tracer.toString());
+        tracer = tracer.dive("something other");
+        assertEquals(prefix + "random/something other*/", tracer.toString());
+    }
+
+    @Test
+    void suffix() {
+        String suffix = "everythingIsPossible";
+        Tracer tracer = new Tracer("random") {
+            @Override
+            protected String suffix() {
+                return suffix;
+            }
+        };
+        assertNotNull(tracer);
+        assertEquals("", tracer.toString());
+        Tracer.ENABLED = true;
+        assertEquals("/*random" + suffix, tracer.toString());
+        tracer = tracer.dive("something other");
+        assertEquals("/*random/something other" + suffix, tracer.toString());
+    }
+
+    @Test
+    void isEnabled() {
+        Tracer.ENABLED = false;
+        Tracer tracer = Tracer.start("doesn't matter");
+        assertFalse(tracer.isEnabled());
+        Tracer.ENABLED = true;
+        assertTrue(tracer.isEnabled());
+        Tracer.ENABLED = false;
+        assertFalse(tracer.isEnabled());
+    }
+
+    @Test
+    void testToString() {
+        Tracer tracer = Tracer.start("random");
+        assertNotNull(tracer);
+        assertEquals("", tracer.toString());
+        Tracer.ENABLED = true;
+        assertEquals("/*random*/", tracer.toString());
+    }
+}

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

@@ -1344,7 +1344,9 @@ public boolean needsReferenceForParserArgument(String propertyName, TypeReferenc
     }
 
     public String capitalize(String str) {
-        return StringUtils.capitalize(str);
+        Tracer dummyTracer = Tracer.start("");
+        String extractedTrace = dummyTracer.extractTraces(str);
+        String cleanedString = dummyTracer.removeTraces(str);
+        return extractedTrace + StringUtils.capitalize(cleanedString);
     }
-
 }