refactor(plc4go/bacnetip): multiple improvements helping with debugging

plc4go/internal/bacnetip/ApplicationLayerMessageCodec.go

@@ -75,7 +75,7 @@ func NewApplicationLayerMessageCodec(localLog zerolog.Logger, udpTransport *udp.
 	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.NewLocalDeviceObject(comp.NoArgs,
 		comp.NewKWArgs(comp.KWNumberOfAPDURetries, func() *uint { retries := uint(10); return &retries }()),
-	), *address, &a.deviceInfoCache, nil)
+	), *address, app.WithApplicationDeviceInfoCache(&a.deviceInfoCache))
 	if err != nil {
 		return nil, err
 	}

plc4go/internal/bacnetip/bacgopes/apdu/apdu_APCI.go

@@ -103,7 +103,7 @@ func newAPCI(args Args, kwArgs KWArgs, options ...Option) (*_APCI, error) {
 		_debug("__init__ %r %r", args, kwArgs)
 	}
 	a := &_APCI{
-		_leafName: ExtractLeafName(options, "APCI"),
+		_leafName: ExtractLeafName(options, StructName()),
 	}
 	options = AddLeafTypeIfAbundant(options, a)
 	a.DebugContents = NewDebugContents(a, "apduType", "apduSeg", "apduMor", "apduSA", "apduSrv",
@@ -516,7 +516,7 @@ func (a *_APCI) String() string {
 	stype := ""
 	if a.apduType != nil {
 		if v, ok := APDUTypes[*a.apduType]; ok {
-			stype = fmt.Sprintf("%T", v)
+			stype = QualifiedTypeName(v())
 		} else {
 			stype = "?"
 		}

plc4go/internal/bacnetip/bacgopes/apdu/apdu__APDU.go

@@ -26,6 +26,7 @@ import (
 	"github.com/pkg/errors"
 
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/comp"
+	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/debugging"
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/pdu"
 )
 
@@ -39,14 +40,14 @@ type _APDU interface {
 type ___APDU struct {
 	*__APDU
 
-	_leafType string
+	_leafName string
 }
 
 var _ _APDU = (*___APDU)(nil)
 
 func New_APDU(args Args, kwArgs KWArgs, options ...Option) (_APDU, error) {
 	i := &___APDU{
-		_leafType: ExtractLeafName(options, "APDU"),
+		_leafName: ExtractLeafName(options, StructName()),
 	}
 	options = AddLeafTypeIfAbundant(options, i)
 	var err error
@@ -107,7 +108,7 @@ func (a *___APDU) SetContext(context APDU) {
 func (a *___APDU) Format(s fmt.State, v rune) {
 	switch v {
 	case 'v', 's', 'r':
-		sname := a._leafType
+		sname := a._leafName
 
 		// the type is the service
 		stype := ""

plc4go/internal/bacnetip/bacgopes/app/app_Application.go

@@ -55,33 +55,28 @@ type Application struct {
 
 	_startupDisabled bool
 
-	// pass through args
-	argAseID *int                       `ignore:"true"`
-	argAse   *ApplicationServiceElement `ignore:"true"`
-
 	log zerolog.Logger
 }
 
-func NewApplication(localLog zerolog.Logger, opts ...func(*Application)) (*Application, error) {
+func NewApplication(localLog zerolog.Logger, options ...Option) (*Application, error) {
 	a := &Application{
 		log:     localLog,
 		helpers: map[string]func(apdu APDU) error{},
 	}
-	for _, opt := range opts {
-		opt(a)
+	ApplyAppliers(options, a)
+	optionsForParent := AddLeafTypeIfAbundant(options, a)
+	var err error
+	a.ApplicationServiceElementContract, err = NewApplicationServiceElement(localLog, optionsForParent...)
+	if err != nil {
+		return nil, err
 	}
 	localLog.Debug().
 		Stringer("localDevice", a.localDevice).
 		Stringer("deviceInfoCache", a.deviceInfoCache).
-		Interface("aseID", a.argAseID).
+		Interface("aseID", a.GetElementId()).
 		Msg("NewApplication")
 	if _debug != nil {
-		_debug("__init__ %r %r deviceInfoCache=%r aseID=%r", a.localDevice, a.localAddress, a.deviceInfoCache, a.argAse)
-	}
-	var err error
-	a.ApplicationServiceElementContract, err = NewApplicationServiceElement(localLog, OptionalOption2(a.argAseID, a.argAse, WithApplicationServiceElementAseID))
-	if err != nil {
-		return nil, err
+		_debug("__init__ %r %r deviceInfoCache=%r aseID=%r", a.localDevice, a.localAddress, a.deviceInfoCache, a.GetElementId())
 	}
 
 	// local objects by ID and name
@@ -124,23 +119,12 @@ func NewApplication(localLog zerolog.Logger, opts ...func(*Application)) (*Appli
 	return a, nil
 }
 
-func WithApplicationLocalDeviceObject(localDevice LocalDeviceObject) func(*Application) {
-	return func(a *Application) {
-		a.localDevice = localDevice
-	}
-}
-
-func WithApplicationAseID(aseID int, ase ApplicationServiceElement) func(*Application) {
-	return func(a *Application) {
-		a.argAseID = &aseID
-		a.argAse = &ase
-	}
+func WithApplicationLocalDeviceObject(localDevice LocalDeviceObject) GenericApplier[*Application] {
+	return WrapGenericApplier(func(a *Application) { a.localDevice = localDevice })
 }
 
-func WithApplicationDeviceInfoCache(deviceInfoCache *appservice.DeviceInfoCache) func(*Application) {
-	return func(a *Application) {
-		a.deviceInfoCache = deviceInfoCache
-	}
+func WithApplicationDeviceInfoCache(deviceInfoCache *appservice.DeviceInfoCache) GenericApplier[*Application] {
+	return WrapGenericApplier(func(a *Application) { a.deviceInfoCache = deviceInfoCache })
 }
 
 func (a *Application) GetDeviceInfoCache() *appservice.DeviceInfoCache {

plc4go/internal/bacnetip/bacgopes/app/app_ApplicationIOController.go

@@ -23,10 +23,8 @@ import (
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog"
 
-	"github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/appservice"
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/comp"
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/iocb"
-	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/local/device"
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/pdu"
 	readWriteModel "github.com/apache/plc4x/plc4go/protocols/bacnetip/readwrite/model"
 )
@@ -38,50 +36,29 @@ type ApplicationIOController struct {
 
 	queueByAddress map[string]*SieveQueue
 
-	// pass through args
-	argDeviceInfoCache *appservice.DeviceInfoCache `ignore:"true"`
-	argAseID           *int                        `ignore:"true"`
-
 	log zerolog.Logger
 }
 
-func NewApplicationIOController(localLog zerolog.Logger, localDevice LocalDeviceObject, opts ...func(controller *ApplicationIOController)) (*ApplicationIOController, error) {
+func NewApplicationIOController(localLog zerolog.Logger, options ...Option) (*ApplicationIOController, error) {
 	a := &ApplicationIOController{
 		// queues for each address
 		queueByAddress: make(map[string]*SieveQueue),
 		log:            localLog,
 	}
-	for _, opt := range opts {
-		opt(a)
-	}
+	ApplyAppliers(options, a)
+	optionsForParent := AddLeafTypeIfAbundant(options, a)
 	var err error
-	a.IOController, err = NewIOController(localLog, "", a)
+	a.IOController, err = NewIOController(localLog, "", a, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating io controller")
 	}
-	a.Application, err = NewApplication(localLog, func(application *Application) {
-		application.localDevice = localDevice
-		application.deviceInfoCache = a.argDeviceInfoCache
-		application.argAseID = a.argAseID
-	})
+	a.Application, err = NewApplication(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating application")
 	}
 	return a, nil
 }
 
-func WithApplicationIOControllerDeviceInfoCache(deviceInfoCache *appservice.DeviceInfoCache) func(*ApplicationIOController) {
-	return func(a *ApplicationIOController) {
-		a.argDeviceInfoCache = deviceInfoCache
-	}
-}
-
-func WithApplicationIOControllerAseID(aseID *int) func(*ApplicationIOController) {
-	return func(a *ApplicationIOController) {
-		a.argAseID = aseID
-	}
-}
-
 func (a *ApplicationIOController) ProcessIO(iocb IOCBContract) error {
 	a.log.Debug().Stringer("iocb", iocb).Msg("ProcessIO")
 

plc4go/internal/bacnetip/bacgopes/app/app_BIPForeignApplication.go

@@ -26,6 +26,7 @@ import (
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/appservice"
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/bvllservice"
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/comm"
+	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/comp"
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/local/device"
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/netservice"
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/pdu"
@@ -48,34 +49,36 @@ type BIPForeignApplication struct {
 	log zerolog.Logger
 }
 
-func NewBIPForeignApplication(localLog zerolog.Logger, localDevice LocalDeviceObject, localAddress Address, bbmdAddress *Address, bbmdTTL *uint16, deviceInfoCache *DeviceInfoCache, aseID *int) (*BIPForeignApplication, error) {
+func NewBIPForeignApplication(localLog zerolog.Logger, localDevice LocalDeviceObject, localAddress Address, bbmdAddress *Address, bbmdTTL uint16, options ...Option) (*BIPForeignApplication, error) {
 	b := &BIPForeignApplication{
 		log: localLog,
 	}
+	ApplyAppliers(options, b)
+	optionsForParent := AddLeafTypeIfAbundant(options, b)
 	var err error
-	b.ApplicationIOController, err = NewApplicationIOController(localLog, localDevice, WithApplicationIOControllerDeviceInfoCache(deviceInfoCache), WithApplicationIOControllerAseID(aseID))
+	b.ApplicationIOController, err = NewApplicationIOController(localLog, Combine(optionsForParent, WithApplicationLocalDeviceObject(localDevice))...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating io controller")
 	}
-	b.WhoIsIAmServices, err = NewWhoIsIAmServices(localLog, b)
+	b.WhoIsIAmServices, err = NewWhoIsIAmServices(localLog, b, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error WhoIs/IAm services")
 	}
-	b.ReadWritePropertyServices, err = NewReadWritePropertyServices()
+	b.ReadWritePropertyServices, err = NewReadWritePropertyServices(optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error read write property services")
 	}
 
 	b.localAddress = localAddress
 
 	// include a application decoder
-	b.asap, err = NewApplicationServiceAccessPoint(localLog)
+	b.asap, err = NewApplicationServiceAccessPoint(localLog, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating application service access point")
 	}
 
 	// pass the device object to the state machine access point, so it can know if it should support segmentation
-	b.smap, err = NewStateMachineAccessPoint(localLog, localDevice, WithStateMachineAccessPointDeviceInfoCache(deviceInfoCache))
+	b.smap, err = NewStateMachineAccessPoint(localLog, localDevice, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating state machine access point")
 	}
@@ -84,13 +87,13 @@ func NewBIPForeignApplication(localLog zerolog.Logger, localDevice LocalDeviceOb
 	// Note: deviceInfoCache already passed above, so we don't need to do it again here
 
 	// a network service access point will be needed
-	b.nsap, err = NewNetworkServiceAccessPoint(localLog)
+	b.nsap, err = NewNetworkServiceAccessPoint(localLog, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating network service access point")
 	}
 
 	// give the NSAP a generic network layer service element
-	b.nse, err = NewNetworkServiceElement(localLog)
+	b.nse, err = NewNetworkServiceElement(localLog, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating new network service element")
 	}
@@ -104,15 +107,15 @@ func NewBIPForeignApplication(localLog zerolog.Logger, localDevice LocalDeviceOb
 	}
 
 	// create a generic BIP stack, bound to the Annex J server on the UDP multiplexer
-	b.bip, err = NewBIPForeign(localLog, WithBIPForeignAddress(bbmdAddress), WithBIPForeignTTL(*bbmdTTL))
+	b.bip, err = NewBIPForeign(localLog, Combine(options, WithBIPForeignAddress(bbmdAddress), WithBIPForeignTTL(bbmdTTL))...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating new bip")
 	}
-	b.annexj, err = NewAnnexJCodec(localLog)
+	b.annexj, err = NewAnnexJCodec(localLog, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating new annex j codec")
 	}
-	b.mux, err = NewUDPMultiplexer(localLog, b.localAddress, true)
+	b.mux, err = NewUDPMultiplexer(localLog, b.localAddress, true, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating new udp multiplexer")
 	}

plc4go/internal/bacnetip/bacgopes/app/app_BIPNetworkApplication.go

@@ -32,38 +32,36 @@ import (
 
 type BIPNetworkApplication struct {
 	*NetworkServiceElement
+
 	localAddress Address
 	nsap         *NetworkServiceAccessPoint
 	bip          any // BIPSimple or BIPForeign
 	annexj       *AnnexJCodec
 	mux          *UDPMultiplexer
 
-	// passThroughArgs
-	argBBMDAddress **Address                  `ignore:"true"`
-	argBBMDTTL     *uint16                    `ignore:"true"`
-	argEID         *int                       `ignore:"true"`
-	argASE         *ApplicationServiceElement `ignore:"true"`
+	// args for constructions
+	argBBMDAddress **Address `ignore:"true"`
+	argBBMDTTL     *uint16   `ignore:"true"`
 
 	log zerolog.Logger
 }
 
-func NewBIPNetworkApplication(localLog zerolog.Logger, localAddress Address, opts ...func(*BIPNetworkApplication)) (*BIPNetworkApplication, error) {
+func NewBIPNetworkApplication(localLog zerolog.Logger, localAddress Address, options ...Option) (*BIPNetworkApplication, error) {
 	n := &BIPNetworkApplication{
 		log: localLog,
 	}
-	for _, opt := range opts {
-		opt(n)
-	}
+	ApplyAppliers(options, n)
+	optionsForParent := AddLeafTypeIfAbundant(options, n)
 	var err error
-	n.NetworkServiceElement, err = NewNetworkServiceElement(localLog, OptionalOption2(n.argEID, n.argASE, WithNetworkServiceElementEID))
+	n.NetworkServiceElement, err = NewNetworkServiceElement(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating new network service element")
 	}
 
 	n.localAddress = localAddress
 
 	// a network service access point will be needed
-	n.nsap, err = NewNetworkServiceAccessPoint(localLog)
+	n.nsap, err = NewNetworkServiceAccessPoint(localLog, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating network service access point")
 	}
@@ -76,21 +74,21 @@ func NewBIPNetworkApplication(localLog zerolog.Logger, localAddress Address, opt
 	// create a generic BIP stack, bound to the Annex J server
 	// on the UDP multiplexer
 	if n.argBBMDAddress == nil && n.argBBMDTTL == nil {
-		n.bip, err = NewBIPSimple(localLog)
+		n.bip, err = NewBIPSimple(localLog, options...)
 		if err != nil {
 			return nil, errors.Wrap(err, "error creating BIPSimple")
 		}
 	} else {
-		n.bip, err = NewBIPForeign(localLog, OptionalOption(n.argBBMDAddress, WithBIPForeignAddress), OptionalOption(n.argBBMDTTL, WithBIPForeignTTL))
+		n.bip, err = NewBIPForeign(localLog, Combine(options, OptionalOption(n.argBBMDAddress, WithBIPForeignAddress), OptionalOption(n.argBBMDTTL, WithBIPForeignTTL))...)
 		if err != nil {
 			return nil, errors.Wrap(err, "error creating BIPForeign")
 		}
 	}
-	n.annexj, err = NewAnnexJCodec(localLog)
+	n.annexj, err = NewAnnexJCodec(localLog, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating new annex j codec")
 	}
-	n.mux, err = NewUDPMultiplexer(localLog, n.localAddress, true)
+	n.mux, err = NewUDPMultiplexer(localLog, n.localAddress, true, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating new udp multiplexer")
 	}