You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by sr...@apache.org on 2022/09/09 16:43:11 UTC

[plc4x] branch develop updated: feat(plc4go): added plc4xgenerator to generate the serialize functions

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

sruehl 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 7ae50705a feat(plc4go): added plc4xgenerator to generate the serialize functions
7ae50705a is described below

commit 7ae50705a460e1f60f19eec947c8a09d57b6f3b8
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Fri Sep 9 18:43:04 2022 +0200

    feat(plc4go): added plc4xgenerator to generate the serialize functions
    
    + used for api and spi implementation
---
 plc4go/go.mod                                      |   4 +-
 plc4go/go.sum                                      |  10 +-
 plc4go/spi/model/DefaultPlcBrowseEvent.go          |  61 +--
 ...eEvent.go => DefaultPlcBrowseEvent_plc4xgen.go} |  70 ++--
 plc4go/spi/model/DefaultPlcBrowseQueryResult.go    |  67 +---
 ....go => DefaultPlcBrowseQueryResult_plc4xgen.go} |  88 ++---
 plc4go/tools/plc4xgenerator/gen.go                 | 414 +++++++++++++++++++++
 7 files changed, 491 insertions(+), 223 deletions(-)

diff --git a/plc4go/go.mod b/plc4go/go.mod
index aa906c9e6..7552ed734 100644
--- a/plc4go/go.mod
+++ b/plc4go/go.mod
@@ -41,6 +41,7 @@ require (
 	github.com/stretchr/testify v1.8.0
 	github.com/subchen/go-xmldom v1.1.2
 	github.com/viney-shih/go-lock v1.1.2
+	golang.org/x/tools v0.1.12
 	gopkg.in/yaml.v3 v3.0.1
 )
 
@@ -67,7 +68,8 @@ require (
 	github.com/spf13/jwalterweatherman v1.1.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/subosito/gotenv v1.4.1 // indirect
-	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c // indirect
+	golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect
+	golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4 // indirect
 	golang.org/x/sys v0.0.0-20220829200755-d48e67d00261 // indirect
 	golang.org/x/term v0.0.0-20220722155259-a9ba230a4035 // indirect
 	golang.org/x/text v0.3.7 // indirect
diff --git a/plc4go/go.sum b/plc4go/go.sum
index 02006af6e..1bc2a6765 100644
--- a/plc4go/go.sum
+++ b/plc4go/go.sum
@@ -281,6 +281,8 @@ golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 h1:6zppjxzCulZykYSLyVDYbneBfbaBIQPYMevg0bEwv2s=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -312,7 +314,7 @@ golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwY
 golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20220520000938-2e3eb7b945c2 h1:NWy5+hlRbC7HK+PmcXVUmW1IMyFce7to56IUvhUFm7Y=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b h1:PxfKdU9lEEDYjdIzOtC4qFWgkU2rGHdKlKowJSMN9h0=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -332,8 +334,8 @@ golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4 h1:uVc8UZUe6tr40fFVnUP5Oj+veunVezqYl9z7DYw9xzw=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -438,6 +440,8 @@ golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4f
 golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
+golang.org/x/tools v0.1.12 h1:VveCTK38A2rkS8ZqFY25HIDFscX5X9OoEhJd3quQmXU=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
diff --git a/plc4go/spi/model/DefaultPlcBrowseEvent.go b/plc4go/spi/model/DefaultPlcBrowseEvent.go
index 021063ec7..fa11d2a5c 100644
--- a/plc4go/spi/model/DefaultPlcBrowseEvent.go
+++ b/plc4go/spi/model/DefaultPlcBrowseEvent.go
@@ -21,10 +21,9 @@ package model
 
 import (
 	"github.com/apache/plc4x/plc4go/pkg/api/model"
-	"github.com/apache/plc4x/plc4go/spi/utils"
-	"github.com/pkg/errors"
 )
 
+//go:generate go run ../../tools/plc4xgenerator/gen.go -type=DefaultPlcBrowseEvent
 type DefaultPlcBrowseEvent struct {
 	Request   model.PlcBrowseRequest
 	FieldName string
@@ -51,61 +50,3 @@ func (d *DefaultPlcBrowseEvent) GetResult() model.PlcBrowseFoundField {
 func (d *DefaultPlcBrowseEvent) GetErr() error {
 	return d.Err
 }
-
-func (d *DefaultPlcBrowseEvent) Serialize(writeBuffer utils.WriteBuffer) error {
-	if err := writeBuffer.PushContext("PlcBrowseEvent"); err != nil {
-		return err
-	}
-
-	if d.Request != nil {
-		if err := writeBuffer.PushContext("Request"); err != nil {
-			return err
-		}
-		if serializableField, ok := d.Request.(utils.Serializable); ok {
-			if err := serializableField.Serialize(writeBuffer); err != nil {
-				return err
-			}
-		} else {
-			return errors.Errorf("Error serializing. Field %T doesn't implement Serializable", d.Request)
-		}
-		if err := writeBuffer.PopContext("Request"); err != nil {
-			return err
-		}
-	}
-	if err := writeBuffer.WriteString("fieldName", uint32(len(d.FieldName)*8), "UTF-8", d.FieldName); err != nil {
-		return err
-	}
-	if d.Result != nil {
-		if err := writeBuffer.PushContext("Result"); err != nil {
-			return err
-		}
-		if serializableField, ok := d.Result.(utils.Serializable); ok {
-			if err := serializableField.Serialize(writeBuffer); err != nil {
-				return err
-			}
-		} else {
-			return errors.Errorf("Error serializing. Field %T doesn't implement Serializable", d.Result)
-		}
-		if err := writeBuffer.PopContext("Result"); err != nil {
-			return err
-		}
-	}
-	if d.Err != nil {
-		if err := writeBuffer.WriteString("err", uint32(len(d.Err.Error())*8), "UTF-8", d.Err.Error()); err != nil {
-			return err
-		}
-	}
-
-	if err := writeBuffer.PopContext("PlcBrowseEvent"); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (d *DefaultPlcBrowseEvent) String() string {
-	writeBuffer := utils.NewWriteBufferBoxBasedWithOptions(true, true)
-	if err := writeBuffer.WriteSerializable(d); err != nil {
-		return err.Error()
-	}
-	return writeBuffer.GetBox().String()
-}
diff --git a/plc4go/spi/model/DefaultPlcBrowseEvent.go b/plc4go/spi/model/DefaultPlcBrowseEvent_plc4xgen.go
similarity index 64%
copy from plc4go/spi/model/DefaultPlcBrowseEvent.go
copy to plc4go/spi/model/DefaultPlcBrowseEvent_plc4xgen.go
index 021063ec7..8d0d8316f 100644
--- a/plc4go/spi/model/DefaultPlcBrowseEvent.go
+++ b/plc4go/spi/model/DefaultPlcBrowseEvent_plc4xgen.go
@@ -17,40 +17,16 @@
  * under the License.
  */
 
+// Code generated by "plc4xgenerator -type=DefaultPlcBrowseEvent"; DO NOT EDIT.
+
 package model
 
 import (
-	"github.com/apache/plc4x/plc4go/pkg/api/model"
+	"fmt"
 	"github.com/apache/plc4x/plc4go/spi/utils"
-	"github.com/pkg/errors"
 )
 
-type DefaultPlcBrowseEvent struct {
-	Request   model.PlcBrowseRequest
-	FieldName string
-	Result    model.PlcBrowseFoundField
-	Err       error
-}
-
-func (d *DefaultPlcBrowseEvent) IsAPlcMessage() bool {
-	return true
-}
-
-func (d *DefaultPlcBrowseEvent) GetRequest() model.PlcBrowseRequest {
-	return d.Request
-}
-
-func (d *DefaultPlcBrowseEvent) GetFieldName() string {
-	return d.FieldName
-}
-
-func (d *DefaultPlcBrowseEvent) GetResult() model.PlcBrowseFoundField {
-	return d.Result
-}
-
-func (d *DefaultPlcBrowseEvent) GetErr() error {
-	return d.Err
-}
+var _ = fmt.Printf
 
 func (d *DefaultPlcBrowseEvent) Serialize(writeBuffer utils.WriteBuffer) error {
 	if err := writeBuffer.PushContext("PlcBrowseEvent"); err != nil {
@@ -58,44 +34,52 @@ func (d *DefaultPlcBrowseEvent) Serialize(writeBuffer utils.WriteBuffer) error {
 	}
 
 	if d.Request != nil {
-		if err := writeBuffer.PushContext("Request"); err != nil {
-			return err
-		}
 		if serializableField, ok := d.Request.(utils.Serializable); ok {
+			if err := writeBuffer.PushContext("request"); err != nil {
+				return err
+			}
 			if err := serializableField.Serialize(writeBuffer); err != nil {
 				return err
 			}
+			if err := writeBuffer.PopContext("request"); err != nil {
+				return err
+			}
 		} else {
-			return errors.Errorf("Error serializing. Field %T doesn't implement Serializable", d.Request)
-		}
-		if err := writeBuffer.PopContext("Request"); err != nil {
-			return err
+			stringValue := fmt.Sprintf("%v", d.Request)
+			if err := writeBuffer.WriteString("request", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+				return err
+			}
 		}
 	}
+
 	if err := writeBuffer.WriteString("fieldName", uint32(len(d.FieldName)*8), "UTF-8", d.FieldName); err != nil {
 		return err
 	}
+
 	if d.Result != nil {
-		if err := writeBuffer.PushContext("Result"); err != nil {
-			return err
-		}
 		if serializableField, ok := d.Result.(utils.Serializable); ok {
+			if err := writeBuffer.PushContext("result"); err != nil {
+				return err
+			}
 			if err := serializableField.Serialize(writeBuffer); err != nil {
 				return err
 			}
+			if err := writeBuffer.PopContext("result"); err != nil {
+				return err
+			}
 		} else {
-			return errors.Errorf("Error serializing. Field %T doesn't implement Serializable", d.Result)
-		}
-		if err := writeBuffer.PopContext("Result"); err != nil {
-			return err
+			stringValue := fmt.Sprintf("%v", d.Result)
+			if err := writeBuffer.WriteString("result", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+				return err
+			}
 		}
 	}
+
 	if d.Err != nil {
 		if err := writeBuffer.WriteString("err", uint32(len(d.Err.Error())*8), "UTF-8", d.Err.Error()); err != nil {
 			return err
 		}
 	}
-
 	if err := writeBuffer.PopContext("PlcBrowseEvent"); err != nil {
 		return err
 	}
diff --git a/plc4go/spi/model/DefaultPlcBrowseQueryResult.go b/plc4go/spi/model/DefaultPlcBrowseQueryResult.go
index f85c4169a..9a78476dd 100644
--- a/plc4go/spi/model/DefaultPlcBrowseQueryResult.go
+++ b/plc4go/spi/model/DefaultPlcBrowseQueryResult.go
@@ -20,12 +20,11 @@
 package model
 
 import (
-	"fmt"
 	"github.com/apache/plc4x/plc4go/pkg/api/model"
 	"github.com/apache/plc4x/plc4go/pkg/api/values"
-	"github.com/apache/plc4x/plc4go/spi/utils"
 )
 
+//go:generate go run ../../tools/plc4xgenerator/gen.go -type=DefaultPlcBrowseQueryResult
 type DefaultPlcBrowseQueryResult struct {
 	Field             model.PlcField
 	Name              string
@@ -63,67 +62,3 @@ func (d *DefaultPlcBrowseQueryResult) GetPossibleDataTypes() []string {
 func (d *DefaultPlcBrowseQueryResult) GetAttributes() map[string]values.PlcValue {
 	return d.Attributes
 }
-
-func (d *DefaultPlcBrowseQueryResult) Serialize(writeBuffer utils.WriteBuffer) error {
-	if err := writeBuffer.PushContext("PlcBrowseQueryResult"); err != nil {
-		return err
-	}
-
-	var fieldAsString string
-	fieldAsString = fmt.Sprintf("%s", d.Field)
-	if err := writeBuffer.WriteString("field", uint32(len(fieldAsString)*8), "UTF-8", fieldAsString); err != nil {
-		return err
-	}
-	if err := writeBuffer.WriteString("name", uint32(len(d.Name)*8), "UTF-8", d.Name); err != nil {
-		return err
-	}
-	if err := writeBuffer.WriteBit("readable", d.Readable); err != nil {
-		return err
-	}
-	if err := writeBuffer.WriteBit("writable", d.Writable); err != nil {
-		return err
-	}
-	if err := writeBuffer.WriteBit("subscribable", d.Subscribable); err != nil {
-		return err
-	}
-	if err := writeBuffer.PushContext("possibleDataTypes", utils.WithRenderAsList(true)); err != nil {
-		return err
-	}
-	for _, dataType := range d.PossibleDataTypes {
-		if err := writeBuffer.WriteString("", uint32(len(dataType)*8), "UTF-8", dataType); err != nil {
-			return err
-		}
-	}
-	if err := writeBuffer.PopContext("possibleDataTypes", utils.WithRenderAsList(true)); err != nil {
-		return err
-	}
-	if err := writeBuffer.PushContext("attributes", utils.WithRenderAsList(true)); err != nil {
-		return err
-	}
-	for name, plcValue := range d.Attributes {
-		if serializable, ok := plcValue.(utils.Serializable); ok {
-			if err := writeBuffer.PushContext(name); err != nil {
-				return err
-			}
-			if err := serializable.Serialize(writeBuffer); err != nil {
-				return err
-			}
-			if err := writeBuffer.PopContext(name); err != nil {
-				return err
-			}
-		} else {
-			plcValueAsString := fmt.Sprintf("%v", plcValue)
-			if err := writeBuffer.WriteString(name, uint32(len(plcValueAsString)*8), "UTF-8", plcValueAsString); err != nil {
-				return err
-			}
-		}
-	}
-	if err := writeBuffer.PopContext("attributes", utils.WithRenderAsList(true)); err != nil {
-		return err
-	}
-
-	if err := writeBuffer.PopContext("PlcBrowseQueryResult"); err != nil {
-		return err
-	}
-	return nil
-}
diff --git a/plc4go/spi/model/DefaultPlcBrowseQueryResult.go b/plc4go/spi/model/DefaultPlcBrowseQueryResult_plc4xgen.go
similarity index 59%
copy from plc4go/spi/model/DefaultPlcBrowseQueryResult.go
copy to plc4go/spi/model/DefaultPlcBrowseQueryResult_plc4xgen.go
index f85c4169a..fa4a6ae67 100644
--- a/plc4go/spi/model/DefaultPlcBrowseQueryResult.go
+++ b/plc4go/spi/model/DefaultPlcBrowseQueryResult_plc4xgen.go
@@ -17,80 +17,61 @@
  * under the License.
  */
 
+// Code generated by "plc4xgenerator -type=DefaultPlcBrowseQueryResult"; DO NOT EDIT.
+
 package model
 
 import (
 	"fmt"
-	"github.com/apache/plc4x/plc4go/pkg/api/model"
-	"github.com/apache/plc4x/plc4go/pkg/api/values"
 	"github.com/apache/plc4x/plc4go/spi/utils"
 )
 
-type DefaultPlcBrowseQueryResult struct {
-	Field             model.PlcField
-	Name              string
-	Readable          bool
-	Writable          bool
-	Subscribable      bool
-	PossibleDataTypes []string
-	Attributes        map[string]values.PlcValue
-}
-
-func (d *DefaultPlcBrowseQueryResult) GetField() model.PlcField {
-	return d.Field
-}
-
-func (d *DefaultPlcBrowseQueryResult) GetName() string {
-	return d.Name
-}
-
-func (d *DefaultPlcBrowseQueryResult) IsReadable() bool {
-	return d.Readable
-}
-
-func (d *DefaultPlcBrowseQueryResult) IsWritable() bool {
-	return d.Writable
-}
-
-func (d *DefaultPlcBrowseQueryResult) IsSubscribable() bool {
-	return d.Subscribable
-}
-
-func (d *DefaultPlcBrowseQueryResult) GetPossibleDataTypes() []string {
-	return d.PossibleDataTypes
-}
-
-func (d *DefaultPlcBrowseQueryResult) GetAttributes() map[string]values.PlcValue {
-	return d.Attributes
-}
+var _ = fmt.Printf
 
 func (d *DefaultPlcBrowseQueryResult) Serialize(writeBuffer utils.WriteBuffer) error {
 	if err := writeBuffer.PushContext("PlcBrowseQueryResult"); err != nil {
 		return err
 	}
 
-	var fieldAsString string
-	fieldAsString = fmt.Sprintf("%s", d.Field)
-	if err := writeBuffer.WriteString("field", uint32(len(fieldAsString)*8), "UTF-8", fieldAsString); err != nil {
-		return err
+	if d.Field != nil {
+		if serializableField, ok := d.Field.(utils.Serializable); ok {
+			if err := writeBuffer.PushContext("field"); err != nil {
+				return err
+			}
+			if err := serializableField.Serialize(writeBuffer); err != nil {
+				return err
+			}
+			if err := writeBuffer.PopContext("field"); err != nil {
+				return err
+			}
+		} else {
+			stringValue := fmt.Sprintf("%v", d.Field)
+			if err := writeBuffer.WriteString("field", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+				return err
+			}
+		}
 	}
+
 	if err := writeBuffer.WriteString("name", uint32(len(d.Name)*8), "UTF-8", d.Name); err != nil {
 		return err
 	}
+
 	if err := writeBuffer.WriteBit("readable", d.Readable); err != nil {
 		return err
 	}
+
 	if err := writeBuffer.WriteBit("writable", d.Writable); err != nil {
 		return err
 	}
+
 	if err := writeBuffer.WriteBit("subscribable", d.Subscribable); err != nil {
 		return err
 	}
 	if err := writeBuffer.PushContext("possibleDataTypes", utils.WithRenderAsList(true)); err != nil {
 		return err
 	}
-	for _, dataType := range d.PossibleDataTypes {
-		if err := writeBuffer.WriteString("", uint32(len(dataType)*8), "UTF-8", dataType); err != nil {
+	for _, elem := range d.PossibleDataTypes {
+		if err := writeBuffer.WriteString("", uint32(len(elem)*8), "UTF-8", elem); err != nil {
 			return err
 		}
 	}
@@ -100,8 +81,8 @@ func (d *DefaultPlcBrowseQueryResult) Serialize(writeBuffer utils.WriteBuffer) e
 	if err := writeBuffer.PushContext("attributes", utils.WithRenderAsList(true)); err != nil {
 		return err
 	}
-	for name, plcValue := range d.Attributes {
-		if serializable, ok := plcValue.(utils.Serializable); ok {
+	for name, elemValue := range d.Attributes {
+		if serializable, ok := elemValue.(utils.Serializable); ok {
 			if err := writeBuffer.PushContext(name); err != nil {
 				return err
 			}
@@ -112,8 +93,8 @@ func (d *DefaultPlcBrowseQueryResult) Serialize(writeBuffer utils.WriteBuffer) e
 				return err
 			}
 		} else {
-			plcValueAsString := fmt.Sprintf("%v", plcValue)
-			if err := writeBuffer.WriteString(name, uint32(len(plcValueAsString)*8), "UTF-8", plcValueAsString); err != nil {
+			elemValueAsString := fmt.Sprintf("%v", elemValue)
+			if err := writeBuffer.WriteString(name, uint32(len(elemValueAsString)*8), "UTF-8", elemValueAsString); err != nil {
 				return err
 			}
 		}
@@ -121,9 +102,16 @@ func (d *DefaultPlcBrowseQueryResult) Serialize(writeBuffer utils.WriteBuffer) e
 	if err := writeBuffer.PopContext("attributes", utils.WithRenderAsList(true)); err != nil {
 		return err
 	}
-
 	if err := writeBuffer.PopContext("PlcBrowseQueryResult"); err != nil {
 		return err
 	}
 	return nil
 }
+
+func (d *DefaultPlcBrowseQueryResult) String() string {
+	writeBuffer := utils.NewWriteBufferBoxBasedWithOptions(true, true)
+	if err := writeBuffer.WriteSerializable(d); err != nil {
+		return err.Error()
+	}
+	return writeBuffer.GetBox().String()
+}
diff --git a/plc4go/tools/plc4xgenerator/gen.go b/plc4go/tools/plc4xgenerator/gen.go
new file mode 100644
index 000000000..96e5cf426
--- /dev/null
+++ b/plc4go/tools/plc4xgenerator/gen.go
@@ -0,0 +1,414 @@
+/*
+ * 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 main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/token"
+	"go/types"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"golang.org/x/tools/go/packages"
+)
+
+var (
+	typeNames = flag.String("type", "", "comma-separated list of type names; must be set")
+	output    = flag.String("output", "", "output file name; default srcdir/<type>_plc4xgen.go")
+	buildTags = flag.String("tags", "", "comma-separated list of build tags to apply")
+)
+
+// Usage is a replacement usage function for the flags package.
+func Usage() {
+	_, _ = fmt.Fprintf(os.Stderr, "Usage of plc4xgenerator:\n")
+	_, _ = fmt.Fprintf(os.Stderr, "\tplc4xgenerator [flags] -type T [directory]\n")
+	_, _ = fmt.Fprintf(os.Stderr, "\tplc4xgenerator [flags] -type T files... # Must be a single package\n")
+	_, _ = fmt.Fprintf(os.Stderr, "Flags:\n")
+	flag.PrintDefaults()
+}
+
+func main() {
+	log.SetFlags(0)
+	log.SetPrefix("plc4xgenerator: ")
+	flag.Usage = Usage
+	flag.Parse()
+	if len(*typeNames) == 0 {
+		flag.Usage()
+		os.Exit(2)
+	}
+	typeList := strings.Split(*typeNames, ",")
+	var tags []string
+	if len(*buildTags) > 0 {
+		tags = strings.Split(*buildTags, ",")
+	}
+
+	args := flag.Args()
+	if len(args) == 0 {
+		args = []string{"."}
+	}
+
+	// Parse the package once.
+	var dir string
+	generator := Generator{}
+	if len(args) == 1 && isDirectory(args[0]) {
+		dir = args[0]
+	} else {
+		if len(tags) != 0 {
+			log.Fatal("-tags option applies only to directories, not when files are specified")
+		}
+		dir = filepath.Dir(args[0])
+	}
+
+	generator.parsePackage(args, tags)
+
+	// Print the header and package clause.
+	generator.Printf(asfHeader)
+	generator.Printf("// Code generated by \"plc4xgenerator %s\"; DO NOT EDIT.\n", strings.Join(os.Args[1:], " "))
+	generator.Printf("\n")
+	generator.Printf("package %s", generator.pkg.name)
+	generator.Printf("\n")
+	generator.Printf("import (\n")
+	generator.Printf("\t\"github.com/apache/plc4x/plc4go/spi/utils\"\n")
+	generator.Printf("\t\"fmt\"\n")
+	generator.Printf(")\n")
+	generator.Printf("\n")
+	generator.Printf("var _ = fmt.Printf\n")
+
+	// Run generate for each type.
+	for _, typeName := range typeList {
+		generator.generate(typeName)
+	}
+
+	// Format the output.
+	src := generator.format()
+
+	// Write to file.
+	outputName := *output
+	if outputName == "" {
+		baseName := fmt.Sprintf("%s_plc4xgen.go", typeList[0])
+		outputName = filepath.Join(dir, baseName)
+	}
+	err := ioutil.WriteFile(outputName, src, 0644)
+	if err != nil {
+		log.Fatalf("writing output: %s", err)
+	}
+}
+
+// isDirectory reports whether the named file is a directory.
+func isDirectory(name string) bool {
+	info, err := os.Stat(name)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return info.IsDir()
+}
+
+// Generator holds the state of the analysis. Primarily used to buffer
+// the output for format.Source.
+type Generator struct {
+	buf bytes.Buffer // Accumulated output.
+	pkg *Package     // Package we are scanning.
+}
+
+func (g *Generator) Printf(format string, args ...interface{}) {
+	fmt.Fprintf(&g.buf, format, args...)
+}
+
+// File holds a single parsed file and associated data.
+type File struct {
+	pkg  *Package  // Package to which this file belongs.
+	file *ast.File // Parsed AST.
+	// These fields are reset for each type being generated.
+	typeName string  // Name of the type.
+	fields   []Field // Accumulator for fields of that type.
+
+	trimPrefix  string
+	lineComment bool
+}
+
+type Package struct {
+	name  string
+	defs  map[*ast.Ident]types.Object
+	files []*File
+}
+
+// parsePackage analyzes the single package constructed from the patterns and tags.
+// parsePackage exits if there is an error.
+func (g *Generator) parsePackage(patterns []string, tags []string) {
+	cfg := &packages.Config{
+		Mode:       packages.NeedName | packages.NeedTypes | packages.NeedTypesInfo | packages.NeedSyntax,
+		Tests:      false,
+		BuildFlags: []string{fmt.Sprintf("-tags=%s", strings.Join(tags, " "))},
+	}
+	pkgs, err := packages.Load(cfg, patterns...)
+	if err != nil {
+		log.Fatal(err)
+	}
+	if len(pkgs) != 1 {
+		log.Fatalf("error: %d packages found", len(pkgs))
+	}
+	g.addPackage(pkgs[0])
+}
+
+// addPackage adds a type checked Package and its syntax files to the generator.
+func (g *Generator) addPackage(pkg *packages.Package) {
+	g.pkg = &Package{
+		name:  pkg.Name,
+		defs:  pkg.TypesInfo.Defs,
+		files: make([]*File, len(pkg.Syntax)),
+	}
+
+	for i, file := range pkg.Syntax {
+		g.pkg.files[i] = &File{
+			file: file,
+			pkg:  g.pkg,
+		}
+	}
+}
+
+// generate produces the String method for the named type.
+func (g *Generator) generate(typeName string) {
+	fields := make([]Field, 0, 100)
+	for _, file := range g.pkg.files {
+		// Set the state for this run of the walker.
+		file.typeName = typeName
+		if file.file != nil {
+			ast.Inspect(file.file, file.genDecl)
+			fields = append(fields, file.fields...)
+		}
+	}
+	if len(fields) == 0 {
+		log.Fatalf("no fields defined for type %s", typeName)
+	}
+	// TODO: for now we remove Default from the start (maybe move that to an option)
+	logicalTypeName := strings.TrimPrefix(typeName, "Default")
+
+	// Generate code that will fail if the constants change value.
+	g.Printf("func (d *%s) Serialize(writeBuffer utils.WriteBuffer) error {\n", typeName)
+	g.Printf("\tif err := writeBuffer.PushContext(\"%s\"); err != nil {\n", logicalTypeName)
+	g.Printf("\t\treturn err\n")
+	g.Printf("\t}\n")
+	for _, field := range fields {
+		fieldName := field.name
+		fieldNameUntitled := unTitle(fieldName)
+		switch fieldType := field.fieldType.(type) {
+		case *ast.SelectorExpr:
+			g.Printf(serializableFieldTemplate, "d."+field.name, fieldNameUntitled)
+		case *ast.Ident:
+			switch fieldType.Name {
+			case "bool":
+				g.Printf(boolFieldSerialize, "d."+field.name, fieldNameUntitled)
+			case "string":
+				g.Printf(stringFieldSerialize, "d."+field.name, fieldNameUntitled)
+			case "error":
+				g.Printf(errorFieldSerialize, "d."+field.name, fieldNameUntitled)
+			default:
+				fmt.Printf("no support implemented %v\n", fieldType)
+			}
+		case *ast.ArrayType:
+			g.Printf("if err := writeBuffer.PushContext(\"%s\", utils.WithRenderAsList(true)); err != nil {\n\t\treturn err\n\t}\n", fieldNameUntitled)
+			g.Printf("for _, elem := range d.%s {", field.name)
+			switch eltType := fieldType.Elt.(type) {
+			case *ast.SelectorExpr:
+				g.Printf(serializableFieldTemplate, "", "value")
+			case *ast.Ident:
+				switch eltType.Name {
+				case "bool":
+					g.Printf(boolFieldSerialize, "elem", "")
+				case "string":
+					g.Printf(stringFieldSerialize, "elem", "")
+				case "error":
+					g.Printf(errorFieldSerialize, "elem", "")
+				default:
+					fmt.Printf("no support implemented %v\n", fieldType)
+				}
+			}
+			g.Printf("}\n")
+			g.Printf("if err := writeBuffer.PopContext(\"%s\", utils.WithRenderAsList(true)); err != nil {\n\t\treturn err\n\t}\n", fieldNameUntitled)
+		case *ast.MapType:
+			if ident, ok := fieldType.Key.(*ast.Ident); !ok || ident.Name != "string" {
+				fmt.Printf("Only string types are supported for maps right now")
+			}
+			g.Printf("if err := writeBuffer.PushContext(\"%s\", utils.WithRenderAsList(true)); err != nil {\n\t\treturn err\n\t}\n", fieldNameUntitled)
+			// TODO: we use serializable or strings as we don't want to over-complex this
+			g.Printf("for name, elemValue := range d.%s {\n", fieldName)
+			g.Printf("\t\tif serializable, ok := elemValue.(utils.Serializable); ok {\n")
+			g.Printf("\t\t\tif err := writeBuffer.PushContext(name); err != nil {\n")
+			g.Printf("\t\t\t\treturn err\n")
+			g.Printf("\t\t\t}\n")
+			g.Printf("\t\t\tif err := serializable.Serialize(writeBuffer); err != nil {\n")
+			g.Printf("\t\t\t\treturn err\n")
+			g.Printf("\t\t\t}\n")
+			g.Printf("\t\t\tif err := writeBuffer.PopContext(name); err != nil {\n")
+			g.Printf("\t\t\t\treturn err\n")
+			g.Printf("\t\t\t}\n")
+			g.Printf("\t\t} else {\n")
+			g.Printf("\t\t\telemValueAsString := fmt.Sprintf(\"%%v\", elemValue)\n")
+			g.Printf("\t\t\tif err := writeBuffer.WriteString(name, uint32(len(elemValueAsString)*8), \"UTF-8\", elemValueAsString); err != nil {\n")
+			g.Printf("\t\t\t\treturn err\n")
+			g.Printf("\t\t\t}\n")
+			g.Printf("\t\t}\n\t}\n")
+			g.Printf("if err := writeBuffer.PopContext(\"%s\", utils.WithRenderAsList(true)); err != nil {\n\t\treturn err\n\t}\n", fieldNameUntitled)
+		default:
+			fmt.Printf("no support implemented %#v\n", fieldType)
+		}
+	}
+	g.Printf("\tif err := writeBuffer.PopContext(\"%s\"); err != nil {\n", logicalTypeName)
+	g.Printf("\t\treturn err\n")
+	g.Printf("\t}\n")
+	g.Printf("\treturn nil\n")
+	g.Printf("}\n")
+	g.Printf("\n")
+	g.Printf(stringerTemplate, typeName)
+}
+
+// format returns the gofmt-ed contents of the Generator's buffer.
+func (g *Generator) format() []byte {
+	src, err := format.Source(g.buf.Bytes())
+	if err != nil {
+		// Should never happen, but can arise when developing this code.
+		// The user can compile the output to see the error.
+		log.Printf("warning: internal error: invalid Go generated: %s", err)
+		log.Printf("warning: compile the package to analyze the error")
+		return g.buf.Bytes()
+	}
+	return src
+}
+
+// Field represents a declared field.
+type Field struct {
+	name      string // The name with trimmed prefix.
+	fieldType ast.Expr
+}
+
+func (f *Field) String() string {
+	return f.name
+}
+
+// genDecl processes one declaration clause.
+func (f *File) genDecl(node ast.Node) bool {
+	decl, ok := node.(*ast.GenDecl)
+	if !ok || decl.Tok != token.TYPE {
+		// We only care about type declarations.
+		return true
+	}
+	for _, spec := range decl.Specs {
+		typeSpec := spec.(*ast.TypeSpec)
+		structDecl, ok := typeSpec.Type.(*ast.StructType)
+		if !ok {
+			continue
+		}
+		if typeSpec.Name.Name != f.typeName {
+			continue
+		}
+		fmt.Printf("Handling %s\n", typeSpec.Name.Name)
+		for _, field := range structDecl.Fields.List {
+			fmt.Printf("\t adding field %s %v\n", field.Names[0].Name, field.Type)
+			f.fields = append(f.fields, Field{
+				name:      field.Names[0].Name,
+				fieldType: field.Type,
+			})
+		}
+	}
+	return false
+}
+
+var asfHeader = `/*
+ * 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.
+ */
+
+`
+
+var stringerTemplate = `
+func (d *%s) String() string {
+	writeBuffer := utils.NewWriteBufferBoxBasedWithOptions(true, true)
+	if err := writeBuffer.WriteSerializable(d); err != nil {
+		return err.Error()
+	}
+	return writeBuffer.GetBox().String()
+}
+`
+
+var serializableFieldTemplate = `
+	if %[1]s != nil {
+		if serializableField, ok := %[1]s.(utils.Serializable); ok {
+			if err := writeBuffer.PushContext("%[2]s"); err != nil {
+				return err
+			}
+			if err := serializableField.Serialize(writeBuffer); err != nil {
+				return err
+			}
+			if err := writeBuffer.PopContext("%[2]s"); err != nil {
+				return err
+			}
+		} else {
+			stringValue := fmt.Sprintf("%%v", %[1]s)
+			if err := writeBuffer.WriteString("%[2]s", uint32(len(stringValue)*8), "UTF-8", stringValue); err != nil {
+				return err
+			}
+		}
+	}
+`
+
+var boolFieldSerialize = `
+	if err := writeBuffer.WriteBit("%[2]s", %[1]s); err != nil {
+		return err
+	}
+`
+
+var stringFieldSerialize = `
+	if err := writeBuffer.WriteString("%[2]s", uint32(len(%[1]s)*8), "UTF-8", %[1]s); err != nil {
+		return err
+	}
+`
+
+var errorFieldSerialize = `
+	if %[1]s != nil {
+		if err := writeBuffer.WriteString("%[2]s", uint32(len(%[1]s.Error())*8), "UTF-8", %[1]s.Error()); err != nil {
+			return err
+		}
+	}
+`
+
+func unTitle(value string) string {
+	return strings.ToLower(string(value[0])) + value[1:]
+}