feat(plc4go/bacnetip): improvements:

- inheritance support improved - bugfixes - write tag data - split up debugging - more logging - inital objects
apache · Sep 19, 2024 · 9d19f01 · 9d19f01
1 parent fb2fb4d
commit 9d19f01
Show file tree

Hide file tree

Showing 219 changed files with 8,626 additions and 2,379 deletions.
diff --git a/plc4go/internal/bacnetip/ApplicationLayerMessageCodec.go b/plc4go/internal/bacnetip/ApplicationLayerMessageCodec.go
@@ -73,9 +73,9 @@ func NewApplicationLayerMessageCodec(localLog zerolog.Logger, udpTransport *udp.
 	}
 	// TODO: workaround for strange address parsing
 	address.AddrTuple = pdu.NewAddressTuple(fmt.Sprintf("%d.%d.%d.%d", address.AddrAddress[0], address.AddrAddress[1], address.AddrAddress[2], address.AddrAddress[3]), *address.AddrPort)
-	application, err := app.NewBIPSimpleApplication(localLog, &device.LocalDeviceObject{
-		NumberOfAPDURetries: func() *uint { retries := uint(10); return &retries }(),
-	}, *address, &a.deviceInfoCache, nil)
+	application, err := app.NewBIPSimpleApplication(localLog, device.NewLocalDeviceObject(comp.NoArgs,
+		comp.NewKWArgs(comp.KWNumberOfAPDURetries, func() *uint { retries := uint(10); return &retries }()),
+	), *address, &a.deviceInfoCache, nil)
 	if err != nil {
 		return nil, err
 	}

diff --git a/plc4go/internal/bacnetip/bacgopes/apdu/apdu_APCI.go b/plc4go/internal/bacnetip/bacgopes/apdu/apdu_APCI.go
@@ -88,52 +88,58 @@ type _APCI struct {
 
 	// Deprecated: hacky workaround
 	bytesToDiscard int
+
+	_leafName string
 }
 
 var _ APCI = (*_APCI)(nil)
 
-func NewAPCI(args Args, kwArgs KWArgs) APCI {
+func NewAPCI(args Args, kwArgs KWArgs, options ...Option) (APCI, error) {
+	return newAPCI(args, kwArgs, options...)
+}
+
+func newAPCI(args Args, kwArgs KWArgs, options ...Option) (*_APCI, error) {
 	if _debug != nil {
 		_debug("__init__ %r %r", args, kwArgs)
 	}
-	a := &_APCI{}
+	a := &_APCI{
+		_leafName: ExtractLeafName(options, "APCI"),
+	}
+	options = AddLeafTypeIfAbundant(options, a)
 	a.DebugContents = NewDebugContents(a, "apduType", "apduSeg", "apduMor", "apduSA", "apduSrv",
 		"apduNak", "apduSeq", "apduWin", "apduMaxSegs", "apduMaxResp",
 		"apduService", "apduInvokeID", "apduAbortRejectReason")
-	a.PCI = NewPCI(args, kwArgs)
+	a.PCI = NewPCI(args, kwArgs, options...)
 	a.AddExtraPrinters(a.PCI.(DebugContentPrinter))
-	return a
+	return a, nil
 }
 
 func (a *_APCI) GetDebugAttr(attr string) any {
 	switch attr {
 	case "apduType":
-		return a.apduType
+		if a.apduType != nil {
+			return *a.apduType
+		}
 	case "apduSeg":
-		if !a.apduSeg {
-			return nil
+		if a.apduSeg {
+			return a.apduSeq
 		}
-		return a.apduSeq
 	case "apduMor":
-		if !a.apduMor {
-			return nil
+		if a.apduMor {
+			return a.apduMor
 		}
-		return a.apduMor
 	case "apduSA":
-		if !a.apduSA {
-			return nil
+		if a.apduSA {
+			return a.apduSA
 		}
-		return a.apduSA
 	case "apduSrv":
-		if !a.apduSrv {
-			return nil
+		if a.apduSrv {
+			return a.apduSrv
 		}
-		return a.apduSrv
 	case "apduNak":
-		if !a.apduNak {
-			return nil
+		if a.apduNak {
+			return a.apduNak
 		}
-		return a.apduNak
 	case "apduSeq":
 		if a.apduSeq != nil {
 			return *a.apduSeq
@@ -504,7 +510,7 @@ func (a *_APCI) deepCopy() *_APCI {
 }
 
 func (a *_APCI) String() string {
-	sname := StructName()
+	sname := a._leafName
 
 	// expand the type if possible
 	stype := ""

diff --git a/plc4go/internal/bacnetip/bacgopes/apdu/apdu_APCISequence.go b/plc4go/internal/bacnetip/bacgopes/apdu/apdu_APCISequence.go
@@ -49,39 +49,46 @@ type APCISequence struct {
 	tagList *TagList
 }
 
-func NewAPCISequence(args Args, kwArgs KWArgs, opts ...func(*APCISequence)) (*APCISequence, error) {
+func NewAPCISequence(args Args, kwArgs KWArgs, options ...Option) (*APCISequence, error) {
 	a := &APCISequence{}
-	for _, opt := range opts {
-		opt(a)
+	ApplyAppliers(options, a)
+	if _debug != nil {
+		_debug("__init__ %r %r", args, kwArgs)
 	}
 	if a._contract == nil {
 		a._contract = a
 	} else {
 		a._contract.(APCISequenceContractRequirement).SetAPCISequence(a)
 	}
-	a._APCI = NewAPCI(args, kwArgs).(*_APCI)
+	options = AddLeafTypeIfAbundant(options, a)
 	var err error
-	a.Sequence, err = NewSequence(args, kwArgs, WithSequenceExtension(a._contract))
+	a._APCI, err = CreateSharedSuperIfAbundant[_APCI](options, newAPCI, args, kwArgs, options...)
+	if err != nil {
+		return nil, errors.Wrap(err, "error creating APCI")
+	}
+	a.Sequence, err = NewSequence(args, kwArgs, Combine(options, WithSequenceExtension(a._contract))...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating sequence")
 	}
+	a.AddExtraPrinters(a.Sequence)
 
 	// start with an empty tag list
 	a.tagList = NewTagList(nil)
 	return a, nil
 }
 
-func WithAPCISequenceExtension(contract APCISequenceContractRequirement) func(*APCISequence) {
-	return func(a *APCISequence) {
-		a._contract = contract
-	}
+func WithAPCISequenceExtension(contract APCISequenceContractRequirement) GenericApplier[*APCISequence] {
+	return WrapGenericApplier(func(a *APCISequence) { a._contract = contract })
 }
 
 func (a *APCISequence) SetSequence(sequence *Sequence) {
 	a.Sequence = sequence
 }
 
 func (a *APCISequence) Encode(apdu Arg) error {
+	if _debug != nil {
+		_debug("encode %r", apdu)
+	}
 	switch apdu := apdu.(type) {
 	case Updater:
 		if err := apdu.Update(a); err != nil {
@@ -107,6 +114,9 @@ func (a *APCISequence) Encode(apdu Arg) error {
 }
 
 func (a *APCISequence) Decode(apdu Arg) error {
+	if _debug != nil {
+		_debug("decode %r", apdu)
+	}
 	// copy the header fields
 	if err := a.Update(apdu); err != nil {
 		return errors.Wrap(err, "error updating APDU")
@@ -126,8 +136,14 @@ func (a *APCISequence) Decode(apdu Arg) error {
 	if err := a.Sequence.Decode(a.tagList); err != nil {
 		return errors.Wrap(err, "error encoding TagList")
 	}
+	if _debug != nil {
+		_debug("    - tag list: %r", a.tagList)
+	}
 
 	if len(a.tagList.GetTagList()) > 0 {
+		if _debug != nil {
+			_debug("    - trailing unmatched tags")
+		}
 		return errors.New("trailing unmatched tags")
 	}
 	return nil

diff --git a/plc4go/internal/bacnetip/bacgopes/apdu/apdu_APDU.go b/plc4go/internal/bacnetip/bacgopes/apdu/apdu_APDU.go
@@ -21,8 +21,6 @@ package apdu
 
 import (
 	"context"
-	"fmt"
-	"strings"
 
 	"github.com/pkg/errors"
 
@@ -34,6 +32,7 @@ import (
 )
 
 type APDU interface {
+	Copyable
 	readWriteModel.APDU
 	APCI
 	PDUData
@@ -46,13 +45,18 @@ type __APDU struct {
 
 var _ APDU = (*__APDU)(nil)
 
-func NewAPDU(args Args, kwArgs KWArgs) (APDU, error) {
+func NewAPDU(args Args, kwArgs KWArgs, options ...Option) (APDU, error) {
 	if _debug != nil {
 		_debug("__init__ %r %r", args, kwArgs)
 	}
 	a := &__APDU{}
-	a._APCI = NewAPCI(args, kwArgs).(*_APCI)
-	a.PDUData = NewPDUData(args, kwArgs)
+	options = AddLeafTypeIfAbundant(options, a)
+	var err error
+	a._APCI, err = CreateSharedSuperIfAbundant[_APCI](options, newAPCI, args, kwArgs, options...)
+	if err != nil {
+		return nil, errors.Wrap(err, "error creating APCI")
+	}
+	a.PDUData = NewPDUData(args, kwArgs, options...)
 	a.AddExtraPrinters(a.PDUData.(DebugContentPrinter))
 	return a, nil
 }
@@ -133,9 +137,5 @@ func (a *__APDU) DeepCopy() any {
 }
 
 func (a *__APDU) String() string {
-	if IsDebuggingActive() {
-		pci := "\t" + strings.Join(strings.Split(a.PCI.String(), "\n"), "\n\t")
-		return fmt.Sprintf("<APDU instance at %p>\n%s\n\tpduData = x'%s'", a, pci, Btox(a.GetPduData(), "."))
-	}
-	return fmt.Sprintf("APDU{%s}", a.PCI)
+	return a._APCI.String()
 }
diff --git a/plc4go/internal/bacnetip/bacgopes/apdu/apdu_ConfirmedPrivateTransferRequest.go b/plc4go/internal/bacnetip/bacgopes/apdu/apdu_ConfirmedPrivateTransferRequest.go
@@ -37,7 +37,7 @@ type ConfirmedPrivateTransferRequest struct {
 	sequenceElements []Element
 }
 
-func NewConfirmedPrivateTransferRequest(args Args, kwArgs KWArgs) (*ConfirmedPrivateTransferRequest, error) {
+func NewConfirmedPrivateTransferRequest(args Args, kwArgs KWArgs, options ...Option) (*ConfirmedPrivateTransferRequest, error) {
 	c := &ConfirmedPrivateTransferRequest{
 		serviceChoice: readWriteModel.BACnetConfirmedServiceChoice_CONFIRMED_PRIVATE_TRANSFER,
 		sequenceElements: []Element{
@@ -46,16 +46,15 @@ func NewConfirmedPrivateTransferRequest(args Args, kwArgs KWArgs) (*ConfirmedPri
 			NewElement("serviceParameters", Vs2E(NewAny), WithElementContext(2), WithElementOptional(true)),
 		},
 	}
-	if _, ok := kwArgs[KWCompRootMessage]; !ok {
-		kwArgs[KWCompRootMessage] = readWriteModel.NewBACnetConfirmedServiceRequestConfirmedPrivateTransfer(
-			readWriteModel.CreateBACnetVendorIdContextTagged(0, 0),     // TODO: get right values
-			readWriteModel.CreateBACnetContextTagUnsignedInteger(1, 0), // TODO: get right values
-			nil,
-			0,
-		)
-	}
+	options = AddRootMessageIfAbundant(options, readWriteModel.NewBACnetConfirmedServiceRequestConfirmedPrivateTransfer(
+		readWriteModel.CreateBACnetVendorIdContextTagged(0, 0),     // TODO: get right values
+		readWriteModel.CreateBACnetContextTagUnsignedInteger(1, 0), // TODO: get right values
+		nil,
+		0,
+	))
+	options = AddLeafTypeIfAbundant(options, c)
 	var err error
-	c.ConfirmedRequestSequence, err = NewConfirmedRequestSequence(args, kwArgs, WithConfirmedRequestSequenceExtension(c))
+	c.ConfirmedRequestSequence, err = NewConfirmedRequestSequence(args, kwArgs, Combine(options, WithConfirmedRequestSequenceExtension(c))...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error building confirmed request")
 	}

diff --git a/plc4go/internal/bacnetip/bacgopes/apdu/apdu_ConfirmedRequestPDU.go b/plc4go/internal/bacnetip/bacgopes/apdu/apdu_ConfirmedRequestPDU.go
@@ -34,13 +34,13 @@ type ConfirmedRequestPDU struct {
 
 var _ readWriteModel.APDUConfirmedRequest = (*ConfirmedRequestPDU)(nil)
 
-func NewConfirmedRequestPDU(args Args, kwArgs KWArgs) (*ConfirmedRequestPDU, error) {
+func NewConfirmedRequestPDU(args Args, kwArgs KWArgs, options ...Option) (*ConfirmedRequestPDU, error) {
 	c := &ConfirmedRequestPDU{}
 	choice, ok := KWO[*readWriteModel.BACnetConfirmedServiceChoice](kwArgs, KWConfirmedServiceChoice, nil)
 	if _debug != nil {
 		_debug("__init__ %r %r %r", choice, args, kwArgs)
 	}
-	apdu, err := New_APDU(args, kwArgs)
+	apdu, err := New_APDU(args, kwArgs, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating _APDU")
 	}

diff --git a/plc4go/internal/bacnetip/bacgopes/apdu/apdu_ConfirmedRequestSequence.go b/plc4go/internal/bacnetip/bacgopes/apdu/apdu_ConfirmedRequestSequence.go
@@ -46,28 +46,27 @@ type ConfirmedRequestSequence struct {
 	_contract ConfirmedRequestSequenceContract
 }
 
-func NewConfirmedRequestSequence(args Args, kwArgs KWArgs, opts ...func(*ConfirmedRequestSequence)) (*ConfirmedRequestSequence, error) {
+func NewConfirmedRequestSequence(args Args, kwArgs KWArgs, options ...Option) (*ConfirmedRequestSequence, error) {
 	u := &ConfirmedRequestSequence{}
-	for _, opt := range opts {
-		opt(u)
-	}
+	ApplyAppliers(options, u)
 	if u._contract == nil {
 		u._contract = u
 	} else {
 		u._contract.(ConfirmedRequestSequenceContractRequirement).SetConfirmedRequestSequence(u)
 	}
-	var err error
+	options = AddSharedSuperIfAbundant[_APCI](options)
+	options = AddLeafTypeIfAbundant(options, u)
 	kwArgs[KWConfirmedServiceChoice] = u._contract.GetServiceChoice()
-	u.ConfirmedRequestPDU, err = NewConfirmedRequestPDU(args, kwArgs)
+	var err error
+	u.ConfirmedRequestPDU, err = NewConfirmedRequestPDU(args, kwArgs, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating ConfirmedRequestPDU")
 	}
-	u.APCISequence, err = NewAPCISequence(args, kwArgs, WithAPCISequenceExtension(u._contract))
+	//TODO: the sequence is usually init first but seems upstream does a init on the same level first before going deeper
+	u.APCISequence, err = NewAPCISequence(args, kwArgs, Combine(options, WithAPCISequenceExtension(u._contract))...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating _APCISequence")
 	}
-	// We need to set the APCI to the same objects...
-	u.APCISequence._APCI = u.ConfirmedRequestPDU._APCI
 	if u.GetRootMessage() == nil {
 		panic("this should be set by NewConfirmedRequestPDU")
 		serviceRequest, _ := GAO[model.BACnetConfirmedServiceRequest](args, 0, nil)
@@ -79,10 +78,8 @@ func NewConfirmedRequestSequence(args Args, kwArgs KWArgs, opts ...func(*Confirm
 	return u, nil
 }
 
-func WithConfirmedRequestSequenceExtension(contract ConfirmedRequestSequenceContractRequirement) func(*ConfirmedRequestSequence) {
-	return func(a *ConfirmedRequestSequence) {
-		a._contract = contract
-	}
+func WithConfirmedRequestSequenceExtension(contract ConfirmedRequestSequenceContractRequirement) GenericApplier[*ConfirmedRequestSequence] {
+	return WrapGenericApplier(func(a *ConfirmedRequestSequence) { a._contract = contract })
 }
 
 func (u *ConfirmedRequestSequence) SetAPCISequence(a *APCISequence) {

diff --git a/plc4go/internal/bacnetip/bacgopes/apdu/apdu_ErrorPDU.go b/plc4go/internal/bacnetip/bacgopes/apdu/apdu_ErrorPDU.go
@@ -34,15 +34,16 @@ type ErrorPDU struct {
 
 var _ readWriteModel.APDUError = (*ErrorPDU)(nil)
 
-func NewErrorPDU(args Args, kwArgs KWArgs) (*ErrorPDU, error) {
+func NewErrorPDU(args Args, kwArgs KWArgs, options ...Option) (*ErrorPDU, error) {
 	e := &ErrorPDU{}
 	choice, ok := KWO[*readWriteModel.BACnetConfirmedServiceChoice](kwArgs, KWConfirmedServiceChoice, nil)
 	invokeID, ok := KWO[*uint8](kwArgs, KWInvokedID, nil)
 	context, ok := KWO[APDU](kwArgs, KWContext, nil)
 	if _debug != nil {
 		_debug("__init__ %r %r %r %r %r", choice, invokeID, context, args, kwArgs)
 	}
-	apdu, err := New_APDU(args, kwArgs)
+	options = AddLeafTypeIfAbundant(options, e)
+	apdu, err := New_APDU(args, kwArgs, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating _APDU")
 	}

diff --git a/plc4go/internal/bacnetip/bacgopes/apdu/apdu_ErrorSequence.go b/plc4go/internal/bacnetip/bacgopes/apdu/apdu_ErrorSequence.go
@@ -46,23 +46,22 @@ type ErrorSequence struct {
 	_contract ErrorSequenceContract
 }
 
-func NewErrorSequence(args Args, kwArgs KWArgs, opts ...func(*ErrorSequence)) (*ErrorSequence, error) {
+func NewErrorSequence(args Args, kwArgs KWArgs, options ...Option) (*ErrorSequence, error) {
 	e := &ErrorSequence{}
-	for _, opt := range opts {
-		opt(e)
-	}
+	ApplyAppliers(options, e)
 	if e._contract == nil {
 		e._contract = e
 	} else {
 		e._contract.(ErrorSequenceContractRequirement).SetErrorSequence(e)
 	}
+	options = AddLeafTypeIfAbundant(options, e)
 	var err error
 	kwArgs[KWConfirmedServiceChoice] = e._contract.GetErrorChoice()
-	e.ErrorPDU, err = NewErrorPDU(args, kwArgs)
+	e.ErrorPDU, err = NewErrorPDU(args, kwArgs, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating ErrorPDU")
 	}
-	e.APCISequence, err = NewAPCISequence(args, kwArgs, WithAPCISequenceExtension(e._contract))
+	e.APCISequence, err = NewAPCISequence(args, kwArgs, Combine(options, WithAPCISequenceExtension(e._contract))...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating _APCISequence")
 	}
@@ -71,10 +70,8 @@ func NewErrorSequence(args Args, kwArgs KWArgs, opts ...func(*ErrorSequence)) (*
 	return e, nil
 }
 
-func WithErrorSequenceExtension(contract ErrorSequenceContractRequirement) func(*ErrorSequence) {
-	return func(a *ErrorSequence) {
-		a._contract = contract
-	}
+func WithErrorSequenceExtension(contract ErrorSequenceContractRequirement) GenericApplier[*ErrorSequence] {
+	return WrapGenericApplier(func(a *ErrorSequence) { a._contract = contract })
 }
 
 func (u *ErrorSequence) SetAPCISequence(a *APCISequence) {