From 7029d2b03c9bd21b3a38a3fe56b1dfad7226b2a2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sebastian=20R=C3=BChl?= <sruehl@apache.org>
Date: Thu, 19 Sep 2024 20:08:32 +0200
Subject: [PATCH] refactor(plc4go/bacnetip): multiple improvements helping with
 debugging

---
 .../bacnetip/ApplicationLayerMessageCodec.go  |  2 +-
 .../bacnetip/bacgopes/apdu/apdu_APCI.go       |  4 +-
 .../bacnetip/bacgopes/apdu/apdu__APDU.go      |  7 ++-
 .../bacnetip/bacgopes/app/app_Application.go  | 42 ++++---------
 .../app/app_ApplicationIOController.go        | 33 ++--------
 .../bacgopes/app/app_BIPForeignApplication.go | 25 ++++----
 .../bacgopes/app/app_BIPNetworkApplication.go | 28 ++++-----
 .../bacgopes/app/app_BIPSimpleApplication.go  | 23 ++++---
 ...ppservice_ApplicationServiceAccessPoint.go | 37 +++--------
 .../bacgopes/appservice/appservice_SSM.go     |  2 +-
 .../appservice_StateMachineAccessPoint.go     | 55 +++++-----------
 .../bvllservice/bvllservice_AnnexJCodec.go    | 41 ++++--------
 .../bvllservice/bvllservice_BIPBBMD.go        | 27 +++-----
 .../bvllservice/bvllservice_BIPForeign.go     | 54 +++++++---------
 .../bvllservice/bvllservice_BIPSAP.go         | 32 +++-------
 .../bvllservice/bvllservice_BIPSimple.go      | 36 +++++------
 .../bvllservice/bvllservice_UDPMultiplexer.go |  3 +-
 .../capability/capability_Capability.go       |  2 +-
 .../comm/comm_ApplicationServiceElement.go    | 17 ++---
 .../bacnetip/bacgopes/comm/comm_Client.go     | 16 +++--
 .../bacnetip/bacgopes/comm/comm_Server.go     | 12 ++--
 .../bacgopes/comm/comm_ServiceAccessPoint.go  | 17 ++---
 .../bacnetip/bacgopes/comm/comm_bind.go       |  4 +-
 .../bacnetip/bacgopes/comp/comp_Args.go       |  9 ++-
 .../bacnetip/bacgopes/comp/comp_KWArgs.go     |  2 +-
 .../bacgopes/comp/comp_inheritance.go         |  2 +-
 .../bacnetip/bacgopes/comp/comp_options.go    | 10 +--
 .../bacgopes/comp/comp_options_test.go        | 45 --------------
 .../constructeddata_Element.go                | 18 ++----
 .../debugging/debugging_DebugContents.go      | 17 +++--
 .../debugging/debugging_DebugPrinter.go       | 50 +++++++++------
 .../debugging/debugging_DefaultRFormatter.go  |  4 +-
 .../bacgopes/debugging/debugging_commons.go   | 28 +--------
 .../bacgopes/iocb/iocb_IOController.go        |  7 ++-
 .../iocb/iocb_IOController_plc4xgen.go        |  4 ++
 .../local/device/local_device_LocalDevice.go  | 46 +++++++-------
 .../bacgopes/netservice/netservice.go         |  2 +
 .../netservice/netservice_NetworkAdapter.go   | 19 ++----
 .../netservice_NetworkAdapter_plc4xgen.go     |  5 --
 .../netservice_NetworkServiceAccessPoint.go   | 35 +++--------
 .../netservice_NetworkServiceElement.go       | 27 ++------
 .../bacgopes/npdu/npdu_RoutingTableEntry.go   | 25 +++-----
 .../object/object_OptionalProperty.go         |  2 +-
 .../bacgopes/object/object_Property.go        |  2 +-
 .../internal/bacnetip/bacgopes/pdu/pdu_PCI.go |  6 +-
 .../service_device_WhoIsIAmServices.go        | 15 ++---
 ...ervice_object_ReadWritePropertyServices.go |  2 +-
 .../bacgopes/task/task_OneShotDeleteTask.go   | 10 +--
 .../bacgopes/task/task_OneShotFunctionTask.go |  4 +-
 .../bacgopes/task/task_OneShotTask.go         | 10 +--
 .../task/task_RecurringFunctionTask.go        |  9 ++-
 .../bacgopes/task/task_RecurringTask.go       | 28 +++------
 .../bacnetip/bacgopes/task/task_Task.go       | 24 +++++--
 .../bacgopes/task/task_Task_plc4xgen.go       |  4 ++
 .../state_machine_ClientStateMachine.go       | 23 +++----
 .../state_machine_ServerStateMachine.go       | 17 +++--
 .../state_machine_StateMachine.go             | 57 +++++++----------
 .../state_machine_TimeoutTask.go              | 11 ++--
 .../state_machine_stateMachine_plc4xgen.go    |  4 ++
 .../test_bvll/helpers_BIPBBMDApplication.go   | 10 +--
 .../test_bvll/helpers_BIPBBMDStateMachine.go  |  2 +-
 .../helpers_BIPForeignStateMachine.go         |  2 +-
 ...s_BIPSimpleApplicationLayerStateMachine.go | 10 +--
 .../helpers_BIPSimpleStateMachine.go          |  2 +-
 .../test_bvll/helpers_BIPStateMachine.go      |  2 +-
 .../test_bvll/helpers_SnifferStateMachine.go  |  2 +-
 .../helpers_ApplicationLayerStateMachine.go   | 20 +++---
 .../test_network/helpers_ApplicationNode.go   | 23 ++++---
 .../helpers_NetworkLayerStateMachine.go       |  2 +-
 .../helpers_RouterStaterMachine.go            |  6 +-
 .../helpers_SnifferStateMachine.go            |  2 +-
 .../test_network/helpers_TestDeviceObject.go  | 24 ++++++-
 .../tests/test_segmentation/test_1_test.go    | 27 ++++----
 .../bacgopes/tests/test_service/helpers.go    | 32 ++++++----
 ...lasses_TrappedApplicationServiceElement.go | 25 ++++----
 .../trapped_classes_TrappedClient.go          |  9 ++-
 ...apped_classes_TrappedClientStateMachine.go |  8 ++-
 .../trapped_classes_TrappedServer.go          | 15 ++---
 ...apped_classes_TrappedServiceAccessPoint.go | 25 ++++----
 .../trapped_classes_TrappedStateMachine.go    | 12 ++--
 .../bacnetip/bacgopes/udp/udp_UDPDirector.go  | 23 +++----
 .../bacnetip/bacgopes/vlan/vlan_IPNetwork.go  | 10 +--
 .../bacnetip/bacgopes/vlan/vlan_IPNode.go     | 17 ++---
 .../bacgopes/vlan/vlan_IPRouterNode.go        | 18 ++----
 .../bacnetip/bacgopes/vlan/vlan_Network.go    | 35 +++++------
 .../bacnetip/bacgopes/vlan/vlan_Node.go       | 62 ++++++++-----------
 .../bacgopes/vlan/vlan_Node_plc4xgen.go       |  4 ++
 87 files changed, 649 insertions(+), 882 deletions(-)

diff --git a/plc4go/internal/bacnetip/ApplicationLayerMessageCodec.go b/plc4go/internal/bacnetip/ApplicationLayerMessageCodec.go
index c6107e244dd..86afacb6c6b 100644
--- a/plc4go/internal/bacnetip/ApplicationLayerMessageCodec.go
+++ b/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
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/apdu/apdu_APCI.go b/plc4go/internal/bacnetip/bacgopes/apdu/apdu_APCI.go
index 348bec8e121..249a637e4d2 100644
--- a/plc4go/internal/bacnetip/bacgopes/apdu/apdu_APCI.go
+++ b/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 = "?"
 		}
diff --git a/plc4go/internal/bacnetip/bacgopes/apdu/apdu__APDU.go b/plc4go/internal/bacnetip/bacgopes/apdu/apdu__APDU.go
index cd37c94da93..a2300462f5b 100644
--- a/plc4go/internal/bacnetip/bacgopes/apdu/apdu__APDU.go
+++ b/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 := ""
diff --git a/plc4go/internal/bacnetip/bacgopes/app/app_Application.go b/plc4go/internal/bacnetip/bacgopes/app/app_Application.go
index 32271e3140d..129d5bdfa64 100644
--- a/plc4go/internal/bacnetip/bacgopes/app/app_Application.go
+++ b/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 {
diff --git a/plc4go/internal/bacnetip/bacgopes/app/app_ApplicationIOController.go b/plc4go/internal/bacnetip/bacgopes/app/app_ApplicationIOController.go
index 0b4d0be4520..c8d636f2dc2 100644
--- a/plc4go/internal/bacnetip/bacgopes/app/app_ApplicationIOController.go
+++ b/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")
 
diff --git a/plc4go/internal/bacnetip/bacgopes/app/app_BIPForeignApplication.go b/plc4go/internal/bacnetip/bacgopes/app/app_BIPForeignApplication.go
index 03f49d35eba..9764edbce6f 100644
--- a/plc4go/internal/bacnetip/bacgopes/app/app_BIPForeignApplication.go
+++ b/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,20 +49,22 @@ 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")
 	}
@@ -69,13 +72,13 @@ func NewBIPForeignApplication(localLog zerolog.Logger, localDevice LocalDeviceOb
 	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")
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/app/app_BIPNetworkApplication.go b/plc4go/internal/bacnetip/bacgopes/app/app_BIPNetworkApplication.go
index 5b49dca2dba..9dade1bee0d 100644
--- a/plc4go/internal/bacnetip/bacgopes/app/app_BIPNetworkApplication.go
+++ b/plc4go/internal/bacnetip/bacgopes/app/app_BIPNetworkApplication.go
@@ -32,30 +32,28 @@ 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")
 	}
@@ -63,7 +61,7 @@ func NewBIPNetworkApplication(localLog zerolog.Logger, localAddress Address, opt
 	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")
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/app/app_BIPSimpleApplication.go b/plc4go/internal/bacnetip/bacgopes/app/app_BIPSimpleApplication.go
index 7a2690b9489..734f1f70456 100644
--- a/plc4go/internal/bacnetip/bacgopes/app/app_BIPSimpleApplication.go
+++ b/plc4go/internal/bacnetip/bacgopes/app/app_BIPSimpleApplication.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"
@@ -50,20 +51,22 @@ type BIPSimpleApplication struct {
 	log zerolog.Logger
 }
 
-func NewBIPSimpleApplication(localLog zerolog.Logger, localDevice LocalDeviceObject, localAddress Address, deviceInfoCache *DeviceInfoCache, aseID *int) (*BIPSimpleApplication, error) {
+func NewBIPSimpleApplication(localLog zerolog.Logger, localDevice LocalDeviceObject, localAddress Address, options ...Option) (*BIPSimpleApplication, error) {
 	b := &BIPSimpleApplication{
 		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")
 	}
@@ -77,7 +80,7 @@ func NewBIPSimpleApplication(localLog zerolog.Logger, localDevice LocalDeviceObj
 	}
 
 	// 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")
 	}
@@ -86,13 +89,13 @@ func NewBIPSimpleApplication(localLog zerolog.Logger, localDevice LocalDeviceObj
 	// 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")
 	}
@@ -106,15 +109,15 @@ func NewBIPSimpleApplication(localLog zerolog.Logger, localDevice LocalDeviceObj
 	}
 
 	// create a generic BIP stack, bound to the Annex J server on the UDP multiplexer
-	b.bip, err = NewBIPSimple(localLog)
+	b.bip, err = NewBIPSimple(localLog, options...)
 	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, false)
+	b.mux, err = NewUDPMultiplexer(localLog, b.localAddress, false, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating new udp multiplexer")
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/appservice/appservice_ApplicationServiceAccessPoint.go b/plc4go/internal/bacnetip/bacgopes/appservice/appservice_ApplicationServiceAccessPoint.go
index cc89ad15580..51b3ee21e29 100644
--- a/plc4go/internal/bacnetip/bacgopes/appservice/appservice_ApplicationServiceAccessPoint.go
+++ b/plc4go/internal/bacnetip/bacgopes/appservice/appservice_ApplicationServiceAccessPoint.go
@@ -39,50 +39,29 @@ type ApplicationServiceAccessPoint struct {
 	ServiceAccessPointContract
 	*DefaultRFormatter `ignore:"true"`
 
-	// pass through args
-	argAseID        *int                       `ignore:"true"`
-	argASEExtension *ApplicationServiceElement `ignore:"true"`
-	argSapID        *int                       `ignore:"true"`
-	argSap          *ServiceAccessPoint        `ignore:"true"`
-
 	log zerolog.Logger
 }
 
-func NewApplicationServiceAccessPoint(localLog zerolog.Logger, opts ...func(*ApplicationServiceAccessPoint)) (*ApplicationServiceAccessPoint, error) {
+func NewApplicationServiceAccessPoint(localLog zerolog.Logger, options ...Option) (*ApplicationServiceAccessPoint, error) {
 	a := &ApplicationServiceAccessPoint{
 		DefaultRFormatter: NewDefaultRFormatter(),
 		log:               localLog,
 	}
-	for _, opt := range opts {
-		opt(a)
-	}
-	if _debug != nil {
-		_debug("__init__ aseID=%r sapID=%r", a.argAseID, a.argSapID)
-	}
+	ApplyAppliers(options, a)
+	optionsForParent := AddLeafTypeIfAbundant(options, a)
 	var err error
-	a.ApplicationServiceElementContract, err = NewApplicationServiceElement(localLog, OptionalOption2(a.argAseID, a.argASEExtension, WithApplicationServiceElementAseID))
+	a.ApplicationServiceElementContract, err = NewApplicationServiceElement(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating application service element")
 	}
-	a.ServiceAccessPointContract, err = NewServiceAccessPoint(localLog, OptionalOption2(a.argSapID, a.argSap, WithServiceAccessPointSapID))
+	a.ServiceAccessPointContract, err = NewServiceAccessPoint(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating service access point")
 	}
-	return a, nil
-}
-
-func WithApplicationServiceAccessPointAseID(aseID int, argASEExtension ApplicationServiceElement) func(*ApplicationServiceAccessPoint) {
-	return func(a *ApplicationServiceAccessPoint) {
-		a.argAseID = &aseID
-		a.argASEExtension = &argASEExtension
-	}
-}
-
-func WithApplicationServiceAccessPointSapID(sapID int, sap ServiceAccessPoint) func(*ApplicationServiceAccessPoint) {
-	return func(a *ApplicationServiceAccessPoint) {
-		a.argSapID = &sapID
-		a.argSap = &sap
+	if _debug != nil {
+		_debug("__init__ aseID=%r sapID=%r", a.GetElementId(), a.GetServiceID())
 	}
+	return a, nil
 }
 
 func (a *ApplicationServiceAccessPoint) Indication(args Args, kwArgs KWArgs) error {
diff --git a/plc4go/internal/bacnetip/bacgopes/appservice/appservice_SSM.go b/plc4go/internal/bacnetip/bacgopes/appservice/appservice_SSM.go
index 22697f67140..a510e450849 100644
--- a/plc4go/internal/bacnetip/bacgopes/appservice/appservice_SSM.go
+++ b/plc4go/internal/bacnetip/bacgopes/appservice/appservice_SSM.go
@@ -191,7 +191,7 @@ func NewSSM(localLog zerolog.Logger, sap interface {
 		maxApduLengthAccepted: maxApduLengthAccepted,
 		log:                   localLog,
 	}
-	ssm.OneShotTask = NewOneShotTask(ssm, nil)
+	ssm.OneShotTask = NewOneShotTask(ssm)
 	ssm.SSMProcessingRequirements = sap
 	return ssm, nil
 }
diff --git a/plc4go/internal/bacnetip/bacgopes/appservice/appservice_StateMachineAccessPoint.go b/plc4go/internal/bacnetip/bacgopes/appservice/appservice_StateMachineAccessPoint.go
index e42b9df0bb5..c29a584ec06 100644
--- a/plc4go/internal/bacnetip/bacgopes/appservice/appservice_StateMachineAccessPoint.go
+++ b/plc4go/internal/bacnetip/bacgopes/appservice/appservice_StateMachineAccessPoint.go
@@ -55,15 +55,10 @@ type StateMachineAccessPoint struct {
 	dccEnableDisable      readWriteModel.BACnetConfirmedServiceRequestDeviceCommunicationControlEnableDisable `stringer:"true"`
 	applicationTimeout    uint
 
-	// pass through args
-	argSapID *int                `ignore:"true"`
-	argSap   *ServiceAccessPoint `ignore:"true"`
-	argCid   *int                `ignore:"true"`
-
 	log zerolog.Logger
 }
 
-func NewStateMachineAccessPoint(localLog zerolog.Logger, localDevice LocalDeviceObject, opts ...func(*StateMachineAccessPoint)) (*StateMachineAccessPoint, error) {
+func NewStateMachineAccessPoint(localLog zerolog.Logger, localDevice LocalDeviceObject, options ...Option) (*StateMachineAccessPoint, error) {
 	s := &StateMachineAccessPoint{
 		DefaultRFormatter: NewDefaultRFormatter(),
 		// save a reference to the device information cache
@@ -96,48 +91,32 @@ func NewStateMachineAccessPoint(localLog zerolog.Logger, localDevice LocalDevice
 
 		log: localLog,
 	}
-	for _, opt := range opts {
-		opt(s)
+	ApplyAppliers(options, s)
+	optionsForParent := AddLeafTypeIfAbundant(options, s)
+	// basic initialization
+	var err error
+	s.ClientContract, err = NewClient(s.log, optionsForParent...)
+	if err != nil {
+		return nil, errors.Wrap(err, "error building client")
+	}
+	s.ServiceAccessPointContract, err = NewServiceAccessPoint(s.log, optionsForParent...)
+	if err != nil {
+		return nil, errors.Wrap(err, "error building serviceAccessPoint")
 	}
 	if _debug != nil {
-		_debug("__init__ localDevice=%r deviceInfoCache=%r sap=%r cid=%r", localDevice, s.deviceInfoCache, s.argSap, s.argCid)
+		_debug("__init__ localDevice=%r deviceInfoCache=%r sap=%r cid=%r", localDevice, s.deviceInfoCache, s.GetServiceID(), s.GetClientID())
 	}
 	s.log.Debug().
 		Stringer("localDevice", localDevice).
 		Stringer("deviceInfoCache", s.deviceInfoCache).
-		Interface("sapID", s.argSapID).
-		Interface("cid", s.argCid).
+		Interface("sapID", s.GetServiceID()).
+		Interface("cid", s.GetClientID()).
 		Msg("NewStateMachineAccessPoint")
-	// basic initialization
-	var err error
-	s.ClientContract, err = NewClient(s.log, OptionalOption2(s.argCid, ToPtr[ClientRequirements](s), WithClientCID))
-	if err != nil {
-		return nil, errors.Wrapf(err, "error building client for %d", s.argCid)
-	}
-	s.ServiceAccessPointContract, err = NewServiceAccessPoint(s.log, OptionalOption2(s.argSapID, s.argSap, WithServiceAccessPointSapID))
-	if err != nil {
-		return nil, errors.Wrapf(err, "error building serviceAccessPoint for %d", s.argSapID)
-	}
 	return s, nil
 }
 
-func WithStateMachineAccessPointDeviceInfoCache(deviceInfoCache *DeviceInfoCache) func(*StateMachineAccessPoint) {
-	return func(s *StateMachineAccessPoint) {
-		s.deviceInfoCache = deviceInfoCache
-	}
-}
-
-func WithStateMachineAccessPointSapID(sapID int, sap ServiceAccessPoint) func(*StateMachineAccessPoint) {
-	return func(s *StateMachineAccessPoint) {
-		s.argSapID = &sapID
-		s.argSap = &sap
-	}
-}
-
-func WithStateMachineAccessPointCid(cid int) func(*StateMachineAccessPoint) {
-	return func(s *StateMachineAccessPoint) {
-		s.argCid = &cid
-	}
+func WithStateMachineAccessPointDeviceInfoCache(deviceInfoCache *DeviceInfoCache) GenericApplier[*StateMachineAccessPoint] {
+	return WrapGenericApplier(func(s *StateMachineAccessPoint) { s.deviceInfoCache = deviceInfoCache })
 }
 
 // getNextInvokeId Called by clients to get an unused invoke ID
diff --git a/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_AnnexJCodec.go b/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_AnnexJCodec.go
index 35756f72b60..b7f6caa061b 100644
--- a/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_AnnexJCodec.go
+++ b/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_AnnexJCodec.go
@@ -36,50 +36,33 @@ type AnnexJCodec struct {
 	ServerContract
 	*DefaultRFormatter `ignore:"true"`
 
-	// pass through args
-	argCid *int `ignore:"true"`
-	argSid *int `ignore:"true"`
-
 	log zerolog.Logger
 }
 
-func NewAnnexJCodec(localLog zerolog.Logger, opts ...func(*AnnexJCodec)) (*AnnexJCodec, error) {
+func NewAnnexJCodec(localLog zerolog.Logger, options ...Option) (*AnnexJCodec, error) {
 	a := &AnnexJCodec{
 		DefaultRFormatter: NewDefaultRFormatter(),
 		log:               localLog,
 	}
-	for _, opt := range opts {
-		opt(a)
-	}
-	if _debug != nil {
-		_debug("__init__ cid=%r sid=%r", a.argCid, a.argSid)
-	}
-	localLog.Debug().
-		Interface("cid", a.argCid).
-		Interface("sid", a.argSid).
-		Msg("NewAnnexJCodec")
+	ApplyAppliers(options, a)
+	optionsForParent := AddLeafTypeIfAbundant(options, a)
 	var err error
-	a.ClientContract, err = NewClient(localLog, OptionalOption2(a.argCid, ToPtr[ClientRequirements](a), WithClientCID))
+	a.ClientContract, err = NewClient(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating client")
 	}
-	a.ServerContract, err = NewServer(localLog, OptionalOption2(a.argSid, ToPtr[ServerRequirements](a), WithServerSID))
+	a.ServerContract, err = NewServer(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating server")
 	}
-	return a, nil
-}
-
-func WithAnnexJCodecCid(cid int) func(*AnnexJCodec) {
-	return func(a *AnnexJCodec) {
-		a.argCid = &cid
-	}
-}
-
-func WithAnnexJCodecSid(sid int) func(*AnnexJCodec) {
-	return func(a *AnnexJCodec) {
-		a.argSid = &sid
+	if _debug != nil {
+		_debug("__init__ cid=%r sid=%r", a.GetClientID(), a.GetServerId())
 	}
+	localLog.Debug().
+		Interface("cid", a.GetClientID()).
+		Interface("sid", a.GetServerId()).
+		Msg("NewAnnexJCodec")
+	return a, nil
 }
 
 func (b *AnnexJCodec) Indication(args Args, kwArgs KWArgs) error {
diff --git a/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_BIPBBMD.go b/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_BIPBBMD.go
index 4fbb04780b5..aaf9f222238 100644
--- a/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_BIPBBMD.go
+++ b/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_BIPBBMD.go
@@ -47,41 +47,34 @@ type BIPBBMD struct {
 	bbmdBDT     []*Address
 	bbmdFDT     []*FDTEntry
 
-	// Pass Through args
-	argSapID *int `ignore:"true"`
-	argCID   *int `ignore:"true"`
-	argSID   *int `ignore:"true"`
-
 	log zerolog.Logger
 }
 
-func NewBIPBBMD(localLog zerolog.Logger, addr *Address, opts ...func(*BIPBBMD)) (*BIPBBMD, error) {
+func NewBIPBBMD(localLog zerolog.Logger, addr *Address, options ...Option) (*BIPBBMD, error) {
 	b := &BIPBBMD{log: localLog}
-	for _, opt := range opts {
-		opt(b)
-	}
-	if _debug != nil {
-		_debug("__init__ %r sapID=%r cid=%r sid=%r", addr, b.argSapID, b.argCID, b.argSID)
-	}
+	ApplyAppliers(options, b)
+	optionsForParent := AddLeafTypeIfAbundant(options, b)
 	b.DebugContents = NewDebugContents(b, "bbmdAddress", "bbmdBDT+", "bbmdFDT+")
 	var err error
-	b.BIPSAP, err = NewBIPSAP(localLog, b, func(bipsap *BIPSAP) {
-		bipsap.argSapID = b.argSapID
-	})
+	b.BIPSAP, err = NewBIPSAP(localLog, b, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating BIPSAP")
 	}
-	b.ClientContract, err = NewClient(localLog, OptionalOption2(b.argCID, ToPtr[ClientRequirements](b), WithClientCID))
+	b.ClientContract, err = NewClient(localLog, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating Client")
 	}
-	b.ServerContract, err = NewServer(localLog, OptionalOption2(b.argSID, ToPtr[ServerRequirements](b), WithServerSID))
+	b.ServerContract, err = NewServer(localLog, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating Server")
 	}
 	b.RecurringTask = NewRecurringTask(localLog, b, WithRecurringTaskInterval(1*time.Second))
 	b.AddExtraPrinters(b.RecurringTask)
 
+	if _debug != nil {
+		_debug("__init__ %r sapID=%r cid=%r sid=%r", addr, b.GetServiceID(), b.GetClientID(), b.GetServiceID())
+	}
+
 	b.bbmdAddress = addr
 
 	// install so process_task runs
diff --git a/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_BIPForeign.go b/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_BIPForeign.go
index 626b3ba173d..641b6e836cd 100644
--- a/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_BIPForeign.go
+++ b/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_BIPForeign.go
@@ -51,49 +51,41 @@ type BIPForeign struct {
 	argAddr *Address `ignore:"true"`
 	argTTL  *uint16  `ignore:"true"`
 
-	// pass through args
-	argSapID *int `ignore:"true"`
-	argCid   *int `ignore:"true"`
-	argSid   *int `ignore:"true"`
-
 	log zerolog.Logger
 }
 
-func NewBIPForeign(localLog zerolog.Logger, opts ...func(*BIPForeign)) (*BIPForeign, error) {
+func NewBIPForeign(localLog zerolog.Logger, options ...Option) (*BIPForeign, error) {
 	b := &BIPForeign{
 		log: localLog,
 	}
 	b.DebugContents = NewDebugContents(b, "registrationStatus", "bbmdAddress", "bbmdTimeToLive")
-	for _, opt := range opts {
-		opt(b)
-	}
-	if _debug != nil {
-		_debug("__init__ addr=%r ttl=%r sapID=%r cid=%r sid=%r", b.argAddr, b.argTTL, b.argSapID, b.argCid, b.argSid)
-	}
-	localLog.Debug().
-		Stringer("addrs", b.argAddr).
-		Interface("ttls", b.argTTL).
-		Interface("sapID", b.argSapID).
-		Interface("cid", b.argCid).
-		Interface("sid", b.argSid).
-		Msg("NewBIPForeign")
-	bipsap, err := NewBIPSAP(localLog, b, func(bipsap *BIPSAP) {
-		bipsap.argSapID = b.argSapID
-	})
+	ApplyAppliers(options, b)
+	optionsForParent := AddLeafTypeIfAbundant(options, b)
+	bipsap, err := NewBIPSAP(localLog, b, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating bisap")
 	}
 	b.BIPSAP = bipsap
-	b.ClientContract, err = NewClient(localLog, OptionalOption2(b.argCid, ToPtr[ClientRequirements](b), WithClientCID))
+	b.ClientContract, err = NewClient(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating client")
 	}
-	b.ServerContract, err = NewServer(localLog, OptionalOption2(b.argSid, ToPtr[ServerRequirements](b), WithServerSID))
+	b.ServerContract, err = NewServer(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating server")
 	}
-	b.OneShotTask = NewOneShotTask(b, nil)
+	b.OneShotTask = NewOneShotTask(b)
 	b.AddExtraPrinters(b.OneShotTask)
+	if _debug != nil {
+		_debug("__init__ addr=%r ttl=%r sapID=%r cid=%r sid=%r", b.argAddr, b.argTTL, b.GetServiceID(), b.GetClientID(), b.GetServerId())
+	}
+	localLog.Debug().
+		Stringer("addrs", b.argAddr).
+		Interface("ttls", b.argTTL).
+		Interface("sapID", b.GetServiceID()).
+		Interface("cid", b.GetClientID()).
+		Interface("sid", b.GetServiceID()).
+		Msg("NewBIPForeign")
 
 	// -2=unregistered, -1=not attempted or no ack, 0=OK, >0 error
 	b.registrationStatus = -1
@@ -140,16 +132,12 @@ func (b *BIPForeign) GetDebugAttr(attr string) any {
 	return nil
 }
 
-func WithBIPForeignAddress(addr *Address) func(*BIPForeign) {
-	return func(b *BIPForeign) {
-		b.argAddr = addr
-	}
+func WithBIPForeignAddress(addr *Address) GenericApplier[*BIPForeign] {
+	return WrapGenericApplier(func(b *BIPForeign) { b.argAddr = addr })
 }
 
-func WithBIPForeignTTL(ttl uint16) func(*BIPForeign) {
-	return func(b *BIPForeign) {
-		b.argTTL = &ttl
-	}
+func WithBIPForeignTTL(ttl uint16) GenericApplier[*BIPForeign] {
+	return WrapGenericApplier(func(b *BIPForeign) { b.argTTL = &ttl })
 }
 
 func (b *BIPForeign) Indication(args Args, kwArgs KWArgs) error {
diff --git a/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_BIPSAP.go b/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_BIPSAP.go
index 2866b2a51e7..895b51b47a3 100644
--- a/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_BIPSAP.go
+++ b/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_BIPSAP.go
@@ -42,44 +42,32 @@ type BIPSAP struct {
 
 	requirements BIPSAPRequirements
 
-	// pass through args
-	argSapID *int
-	argSap   *ServiceAccessPoint
-
 	log zerolog.Logger
 }
 
-func NewBIPSAP(localLog zerolog.Logger, requirements BIPSAPRequirements, opts ...func(*BIPSAP)) (*BIPSAP, error) {
+func NewBIPSAP(localLog zerolog.Logger, requirements BIPSAPRequirements, options ...Option) (*BIPSAP, error) {
 	b := &BIPSAP{
 		DefaultRFormatter: NewDefaultRFormatter(),
 		log:               localLog,
 	}
-	for _, opt := range opts {
-		opt(b)
+	ApplyAppliers(options, b)
+	optionsForParent := AddLeafTypeIfAbundant(options, b)
+	var err error
+	b.ServiceAccessPointContract, err = NewServiceAccessPoint(localLog, optionsForParent...)
+	if err != nil {
+		return nil, errors.Wrap(err, "Error creating service access point")
 	}
+	b.requirements = requirements
 	if _debug != nil {
-		_debug("__init__ sap=%r", b.argSapID)
+		_debug("__init__ sap=%r", b.GetServiceID())
 	}
 	localLog.Debug().
-		Interface("sapID", b.argSapID).
+		Interface("sapID", b.GetServiceElement()).
 		Interface("requirements", requirements).
 		Msg("NewBIPSAP")
-	var err error
-	b.ServiceAccessPointContract, err = NewServiceAccessPoint(localLog, OptionalOption2(b.argSapID, b.argSap, WithServiceAccessPointSapID))
-	if err != nil {
-		return nil, errors.Wrap(err, "Error creating service access point")
-	}
-	b.requirements = requirements
 	return b, nil
 }
 
-func WithBIPSAPSapID(sapID int, sap ServiceAccessPoint) func(*BIPSAP) {
-	return func(b *BIPSAP) {
-		b.argSapID = &sapID
-		b.argSap = &sap
-	}
-}
-
 func (b *BIPSAP) String() string {
 	return fmt.Sprintf("BIPSAP(SAP: %s)", b.ServiceAccessPointContract)
 }
diff --git a/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_BIPSimple.go b/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_BIPSimple.go
index ed1e6256b53..7768a7037f2 100644
--- a/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_BIPSimple.go
+++ b/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_BIPSimple.go
@@ -38,45 +38,37 @@ type BIPSimple struct {
 	ServerContract
 	*debugging.DefaultRFormatter `ignore:"true"`
 
-	// pass through args
-	argSapID *int `ignore:"true"`
-	argCid   *int `ignore:"true"`
-	argSid   *int `ignore:"true"`
-
 	log zerolog.Logger
 }
 
-func NewBIPSimple(localLog zerolog.Logger, opts ...func(simple *BIPSimple)) (*BIPSimple, error) {
+func NewBIPSimple(localLog zerolog.Logger, options ...Option) (*BIPSimple, error) {
 	b := &BIPSimple{
 		DefaultRFormatter: debugging.NewDefaultRFormatter(),
 		log:               localLog,
 	}
-	for _, opt := range opts {
-		opt(b)
-	}
-	if _debug != nil {
-		_debug("__init__ sapID=%r cid=%r sid=%r", b.argSapID, b.argCid, b.argSid)
-	}
-	localLog.Debug().
-		Interface("sapID", b.argSapID).
-		Interface("cid", b.argCid).
-		Interface("sid", b.argSid).
-		Msg("NewBIPSimple")
-	bipsap, err := NewBIPSAP(localLog, b, func(bipsap *BIPSAP) {
-		bipsap.argSapID = b.argSapID
-	})
+	ApplyAppliers(options, b)
+	optionsForParent := AddLeafTypeIfAbundant(options, b)
+	bipsap, err := NewBIPSAP(localLog, b, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating bisap")
 	}
 	b.BIPSAP = bipsap
-	b.ClientContract, err = NewClient(localLog, OptionalOption2(b.argCid, ToPtr[ClientRequirements](b), WithClientCID))
+	b.ClientContract, err = NewClient(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating client")
 	}
-	b.ServerContract, err = NewServer(localLog, OptionalOption2(b.argSid, ToPtr[ServerRequirements](b), WithServerSID))
+	b.ServerContract, err = NewServer(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating server")
 	}
+	if _debug != nil {
+		_debug("__init__ sapID=%r cid=%r sid=%r", b.GetServiceID(), b.GetClientID(), b.GetServerId())
+	}
+	localLog.Debug().
+		Interface("sapID", b.GetServerId()).
+		Interface("cid", b.GetClientID()).
+		Interface("sid", b.GetServiceID()).
+		Msg("NewBIPSimple")
 	return b, nil
 }
 
diff --git a/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_UDPMultiplexer.go b/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_UDPMultiplexer.go
index 56c0cbb18e2..6c03cf44af5 100644
--- a/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_UDPMultiplexer.go
+++ b/plc4go/internal/bacnetip/bacgopes/bvllservice/bvllservice_UDPMultiplexer.go
@@ -45,12 +45,13 @@ type UDPMultiplexer struct {
 	log zerolog.Logger
 }
 
-func NewUDPMultiplexer(localLog zerolog.Logger, address any, noBroadcast bool) (*UDPMultiplexer, error) {
+func NewUDPMultiplexer(localLog zerolog.Logger, address any, noBroadcast bool, options ...Option) (*UDPMultiplexer, error) {
 	localLog.Debug().
 		Interface("address", address).
 		Bool("noBroadcast", noBroadcast).
 		Msg("NewUDPMultiplexer")
 	u := &UDPMultiplexer{}
+	ApplyAppliers(options, u)
 	if _debug != nil {
 		_debug("__init__ %r noBroadcast=%r", address, noBroadcast)
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/capability/capability_Capability.go b/plc4go/internal/bacnetip/bacgopes/capability/capability_Capability.go
index edabe8cd867..e2478118943 100644
--- a/plc4go/internal/bacnetip/bacgopes/capability/capability_Capability.go
+++ b/plc4go/internal/bacnetip/bacgopes/capability/capability_Capability.go
@@ -40,7 +40,7 @@ type capability struct {
 
 var _ Capability = (*capability)(nil)
 
-func NewCapability() Capability {
+func NewCapability(options ...Option) Capability {
 	return &capability{_zindex: 99}
 }
 
diff --git a/plc4go/internal/bacnetip/bacgopes/comm/comm_ApplicationServiceElement.go b/plc4go/internal/bacnetip/bacgopes/comm/comm_ApplicationServiceElement.go
index e284923041f..328faccfce0 100644
--- a/plc4go/internal/bacnetip/bacgopes/comm/comm_ApplicationServiceElement.go
+++ b/plc4go/internal/bacnetip/bacgopes/comm/comm_ApplicationServiceElement.go
@@ -43,6 +43,7 @@ type ApplicationServiceElementContract interface {
 	utils.Serializable
 	Request(args Args, kwArgs KWArgs) error
 	Response(args Args, kwArgs KWArgs) error
+	GetElementId() *int
 	_setElementService(elementService ElementService)
 	GetElementService() ElementService
 }
@@ -64,13 +65,11 @@ type applicationServiceElement struct {
 	log zerolog.Logger
 }
 
-func NewApplicationServiceElement(localLog zerolog.Logger, opts ...func(*applicationServiceElement)) (ApplicationServiceElementContract, error) {
+func NewApplicationServiceElement(localLog zerolog.Logger, options ...Option) (ApplicationServiceElementContract, error) {
 	a := &applicationServiceElement{
 		log: localLog,
 	}
-	for _, opt := range opts {
-		opt(a)
-	}
+	ApplyAppliers(options, a)
 	if _debug != nil {
 		_debug("__init__(%v)", a.argASEExtension)
 	}
@@ -96,14 +95,18 @@ func NewApplicationServiceElement(localLog zerolog.Logger, opts ...func(*applica
 	return a, nil
 }
 
-func WithApplicationServiceElementAseID(aseID int, ase ApplicationServiceElement) func(*applicationServiceElement) {
+func WithApplicationServiceElementAseID(aseID int, ase ApplicationServiceElement) GenericApplier[*applicationServiceElement] {
 	if ase == nil {
 		panic("saq required (completely build sap)") // TODO: might be hard because initialization not yet done
 	}
-	return func(s *applicationServiceElement) {
+	return WrapGenericApplier(func(s *applicationServiceElement) {
 		s.elementID = &aseID
 		s.argASEExtension = ase
-	}
+	})
+}
+
+func (a *applicationServiceElement) GetElementId() *int {
+	return a.elementID
 }
 
 func (a *applicationServiceElement) Request(args Args, kwArgs KWArgs) error {
diff --git a/plc4go/internal/bacnetip/bacgopes/comm/comm_Client.go b/plc4go/internal/bacnetip/bacgopes/comm/comm_Client.go
index a7caf519486..1bc5241e07d 100644
--- a/plc4go/internal/bacnetip/bacgopes/comm/comm_Client.go
+++ b/plc4go/internal/bacnetip/bacgopes/comm/comm_Client.go
@@ -38,9 +38,9 @@ type Client interface {
 type ClientContract interface {
 	fmt.Stringer
 	utils.Serializable
+	GetClientID() *int
 	Request(args Args, kwArgs KWArgs) error
 	_setClientPeer(server Server)
-	getClientId() *int
 }
 
 // ClientRequirements provides a set of functions which must be overwritten by a sub struct
@@ -61,13 +61,11 @@ type client struct {
 
 var _ ClientContract = (*client)(nil)
 
-func NewClient(localLog zerolog.Logger, opts ...func(*client)) (ClientContract, error) {
+func NewClient(localLog zerolog.Logger, options ...Option) (ClientContract, error) {
 	c := &client{
 		log: localLog,
 	}
-	for _, opt := range opts {
-		opt(c)
-	}
+	ApplyAppliers(options, c)
 	if _debug != nil {
 		_debug("__init__ cid=%v", c.clientID)
 	}
@@ -93,11 +91,11 @@ func NewClient(localLog zerolog.Logger, opts ...func(*client)) (ClientContract,
 	return c, nil
 }
 
-func WithClientCID(cid int, requirements ClientRequirements) func(*client) {
-	return func(c *client) {
+func WithClientCID(cid int, requirements ClientRequirements) GenericApplier[*client] {
+	return WrapGenericApplier(func(c *client) {
 		c.clientID = &cid
 		c.argClientRequirements = requirements
-	}
+	})
 }
 
 func (c *client) Request(args Args, kwArgs KWArgs) error {
@@ -116,6 +114,6 @@ func (c *client) _setClientPeer(server Server) {
 	c.clientPeer = server
 }
 
-func (c *client) getClientId() *int {
+func (c *client) GetClientID() *int {
 	return c.clientID
 }
diff --git a/plc4go/internal/bacnetip/bacgopes/comm/comm_Server.go b/plc4go/internal/bacnetip/bacgopes/comm/comm_Server.go
index 1f4b7fd3def..52a8ee4612d 100644
--- a/plc4go/internal/bacnetip/bacgopes/comm/comm_Server.go
+++ b/plc4go/internal/bacnetip/bacgopes/comm/comm_Server.go
@@ -62,13 +62,11 @@ type server struct {
 	log zerolog.Logger
 }
 
-func NewServer(localLog zerolog.Logger, opts ...func(server *server)) (ServerContract, error) {
+func NewServer(localLog zerolog.Logger, options ...Option) (ServerContract, error) {
 	s := &server{
 		log: localLog,
 	}
-	for _, opt := range opts {
-		opt(s)
-	}
+	ApplyAppliers(options, s)
 	if _debug != nil {
 		_debug("__init__ sid=%v", s.serverID)
 	}
@@ -94,11 +92,11 @@ func NewServer(localLog zerolog.Logger, opts ...func(server *server)) (ServerCon
 	return s, nil
 }
 
-func WithServerSID(sid int, requirements ServerRequirements) func(*server) {
-	return func(s *server) {
+func WithServerSID(sid int, requirements ServerRequirements) GenericApplier[*server] {
+	return WrapGenericApplier(func(s *server) {
 		s.serverID = &sid
 		s.argServerRequirements = requirements
-	}
+	})
 }
 
 func (s *server) Response(args Args, kwArgs KWArgs) error {
diff --git a/plc4go/internal/bacnetip/bacgopes/comm/comm_ServiceAccessPoint.go b/plc4go/internal/bacnetip/bacgopes/comm/comm_ServiceAccessPoint.go
index d66535b7543..a0f6f57325e 100644
--- a/plc4go/internal/bacnetip/bacgopes/comm/comm_ServiceAccessPoint.go
+++ b/plc4go/internal/bacnetip/bacgopes/comm/comm_ServiceAccessPoint.go
@@ -38,6 +38,7 @@ type ServiceAccessPoint interface {
 type ServiceAccessPointContract interface {
 	fmt.Stringer
 	utils.Serializable
+	GetServiceID() *int
 	SapRequest(Args, KWArgs) error
 	SapResponse(Args, KWArgs) error
 	_setServiceElement(serviceElement ServiceElement)
@@ -68,13 +69,11 @@ type serviceAccessPoint struct {
 
 var _ ServiceAccessPointContract = (*serviceAccessPoint)(nil)
 
-func NewServiceAccessPoint(localLog zerolog.Logger, opts ...func(point *serviceAccessPoint)) (ServiceAccessPointContract, error) {
+func NewServiceAccessPoint(localLog zerolog.Logger, options ...Option) (ServiceAccessPointContract, error) {
 	s := &serviceAccessPoint{
 		log: localLog,
 	}
-	for _, opt := range opts {
-		opt(s)
-	}
+	ApplyAppliers(options, s)
 	if _debug != nil {
 		_debug("__init__(%v)", s.serviceID)
 	}
@@ -100,14 +99,18 @@ func NewServiceAccessPoint(localLog zerolog.Logger, opts ...func(point *serviceA
 	return s, nil
 }
 
-func WithServiceAccessPointSapID(sapID int, sap ServiceAccessPoint) func(*serviceAccessPoint) {
+func WithServiceAccessPointSapID(sapID int, sap ServiceAccessPoint) GenericApplier[*serviceAccessPoint] {
 	if sap == nil {
 		panic("saq required (completely build sap)") // TODO: might be hard because initialization not yet done
 	}
-	return func(s *serviceAccessPoint) {
+	return WrapGenericApplier(func(s *serviceAccessPoint) {
 		s.serviceID = &sapID
 		s.argSAPExtension = sap
-	}
+	})
+}
+
+func (s *serviceAccessPoint) GetServiceID() *int {
+	return s.serviceID
 }
 
 func (s *serviceAccessPoint) SapRequest(args Args, kwArgs KWArgs) error {
diff --git a/plc4go/internal/bacnetip/bacgopes/comm/comm_bind.go b/plc4go/internal/bacnetip/bacgopes/comm/comm_bind.go
index 04231fa0a75..18eb5f56f22 100644
--- a/plc4go/internal/bacnetip/bacgopes/comm/comm_bind.go
+++ b/plc4go/internal/bacnetip/bacgopes/comm/comm_bind.go
@@ -24,12 +24,14 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog"
+
+	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/comp"
 )
 
 // Bind a list of clients and servers together, top down
 func Bind(localLog zerolog.Logger, args ...any) error {
 	if _debug != nil {
-		_debug("bind %v", args)
+		_debug("bind %r", Args(args))
 	}
 	// generic bind is pairs of names
 	if len(args) == 0 {
diff --git a/plc4go/internal/bacnetip/bacgopes/comp/comp_Args.go b/plc4go/internal/bacnetip/bacgopes/comp/comp_Args.go
index f05bc7672bc..c6a5665d087 100644
--- a/plc4go/internal/bacnetip/bacgopes/comp/comp_Args.go
+++ b/plc4go/internal/bacnetip/bacgopes/comp/comp_Args.go
@@ -73,15 +73,18 @@ func GAO[T any](args Args, index int, defaultValue T) (T, bool) {
 func (a Args) Format(s fmt.State, verb rune) {
 	switch verb {
 	case 'r':
-		_, _ = fmt.Fprintf(s, "(%s)", a.string(false, false)[1:len(a.string(false, false))-1])
+		str := a.string(false, false)
+		_, _ = fmt.Fprintf(s, "(%s)", str[1:len(str)-1])
 	case 's', 'v':
-		_, _ = fmt.Fprintf(s, "(%s)", a.String()[1:len(a.String())-1])
+		str := a.String()
+		_, _ = fmt.Fprintf(s, "(%s)", str[1:len(str)-1])
 	}
 }
 
 func (a Args) String() string {
 	return a.string(true, true)
 }
+
 func (a Args) string(printIndex bool, printType bool) string {
 	r := ""
 	for i, ea := range a {
@@ -110,7 +113,7 @@ func (a Args) string(printIndex bool, printType bool) string {
 		r += ", "
 	}
 	if r != "" {
-		r = r[:len(r)-2]
+		r = r[:len(r)-1]
 	}
 	return "[" + r + "]"
 }
diff --git a/plc4go/internal/bacnetip/bacgopes/comp/comp_KWArgs.go b/plc4go/internal/bacnetip/bacgopes/comp/comp_KWArgs.go
index 1dacdc3396f..27569adde4b 100644
--- a/plc4go/internal/bacnetip/bacgopes/comp/comp_KWArgs.go
+++ b/plc4go/internal/bacnetip/bacgopes/comp/comp_KWArgs.go
@@ -66,7 +66,7 @@ func (k KWArgs) String() string {
 		if IsNil(ea) {
 			ea = fmt.Sprintf("<nil>(%T)", ea)
 		}
-		r += fmt.Sprintf("'%s'=%v, ", kk, ea)
+		r += fmt.Sprintf("'%s': %v, ", kk, ea)
 	}
 	if r != "" {
 		r = r[:len(r)-2]
diff --git a/plc4go/internal/bacnetip/bacgopes/comp/comp_inheritance.go b/plc4go/internal/bacnetip/bacgopes/comp/comp_inheritance.go
index 9823acb923b..8a9a7e8e4e4 100644
--- a/plc4go/internal/bacnetip/bacgopes/comp/comp_inheritance.go
+++ b/plc4go/internal/bacnetip/bacgopes/comp/comp_inheritance.go
@@ -50,7 +50,7 @@ func AddLeafTypeIfAbundant[T any](options []Option, leaf *T) []Option {
 
 // WithLeafType can be used to add a leaf type
 func WithLeafType[T any](leaf *T) Option {
-	return leafType{name: fmt.Sprintf("%T", leaf)[1:]}
+	return leafType{name: "bacgopes." + fmt.Sprintf("%T", leaf)[1:]}
 }
 
 // ExtractLeafName or return default
diff --git a/plc4go/internal/bacnetip/bacgopes/comp/comp_options.go b/plc4go/internal/bacnetip/bacgopes/comp/comp_options.go
index e19f4639bfb..a8f28d5e77b 100644
--- a/plc4go/internal/bacnetip/bacgopes/comp/comp_options.go
+++ b/plc4go/internal/bacnetip/bacgopes/comp/comp_options.go
@@ -20,24 +20,24 @@
 package comp
 
 // OptionalOption allows options to be applied that might be optional
-func OptionalOption[V any, T any](value *V, opt func(V) func(*T)) func(*T) {
+func OptionalOption[V any, T any](value *V, opt func(V) GenericApplier[*T]) GenericApplier[*T] {
 	if value != nil {
 		return opt(*value)
 	}
-	return func(c *T) {}
+	return WrapGenericApplier(func(c *T) {})
 }
 
 // OptionalOption2 allows options to be applied that might be optional
-func OptionalOption2[V1 any, V2 any, T any](value1 *V1, value2 *V2, opt func(V1, V2) func(*T)) func(*T) {
+func OptionalOption2[V1 any, V2 any, T any](value1 *V1, value2 *V2, opt func(V1, V2) GenericApplier[*T]) GenericApplier[*T] {
 	v1Set := value1 != nil
 	v2Set := value2 != nil
 	if (v1Set && !v2Set) || (!v1Set && v2Set) {
-		return func(c *T) {}
+		return WrapGenericApplier(func(c *T) {})
 	}
 	if v1Set {
 		return opt(*value1, *value2)
 	}
-	return func(c *T) {}
+	return WrapGenericApplier(func(c *T) {})
 }
 
 // Option is a generic interface for transporting options which are meant to bubble up
diff --git a/plc4go/internal/bacnetip/bacgopes/comp/comp_options_test.go b/plc4go/internal/bacnetip/bacgopes/comp/comp_options_test.go
index 4da7cf00f9e..b9e0f056535 100644
--- a/plc4go/internal/bacnetip/bacgopes/comp/comp_options_test.go
+++ b/plc4go/internal/bacnetip/bacgopes/comp/comp_options_test.go
@@ -138,51 +138,6 @@ func TestApplyGenericOption(t *testing.T) {
 	}
 }
 
-func TestOptionalOption(t *testing.T) {
-	type args[V any, T any] struct {
-		value *V
-		opt   func(V) func(*T)
-	}
-	type testCase[V any, T any] struct {
-		name string
-		args args[V, T]
-		want func(*T)
-	}
-	tests := []testCase[spi.Message, spi.Message]{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := OptionalOption(tt.args.value, tt.args.opt); !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("OptionalOption() = %v, want %v", got != nil, tt.want != nil)
-			}
-		})
-	}
-}
-
-func TestOptionalOption2(t *testing.T) {
-	type args[V1 any, V2 any, T any] struct {
-		value1 *V1
-		value2 *V2
-		opt    func(V1, V2) func(*T)
-	}
-	type testCase[V1 any, V2 any, T any] struct {
-		name string
-		args args[V1, V2, T]
-		want func(*T)
-	}
-	tests := []testCase[spi.Message, spi.Message, spi.Message]{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := OptionalOption2(tt.args.value1, tt.args.value2, tt.args.opt); !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("OptionalOption2() = %v, want %v", got != nil, tt.want != nil)
-			}
-		})
-	}
-}
-
 func TestExtractIfPresent(t *testing.T) {
 	type A interface{}
 	type B interface{ A }
diff --git a/plc4go/internal/bacnetip/bacgopes/constructeddata/constructeddata_Element.go b/plc4go/internal/bacnetip/bacgopes/constructeddata/constructeddata_Element.go
index f920980a914..cf746816a15 100644
--- a/plc4go/internal/bacnetip/bacgopes/constructeddata/constructeddata_Element.go
+++ b/plc4go/internal/bacnetip/bacgopes/constructeddata/constructeddata_Element.go
@@ -45,29 +45,23 @@ type _Element struct {
 	Optional bool
 }
 
-func NewElement(name string, klass func(Args, KWArgs) (ElementKlass, error), opts ...func(*_Element)) Element {
+func NewElement(name string, klass func(Args, KWArgs) (ElementKlass, error), options ...Option) Element {
 	e := &_Element{
 		Name:  name,
 		Klass: klass,
 	}
-	for _, opt := range opts {
-		opt(e)
-	}
+	ApplyAppliers(options, e)
 	return e
 }
 
 var _ Element = (*_Element)(nil)
 
-func WithElementOptional(optional bool) func(*_Element) {
-	return func(e *_Element) {
-		e.Optional = optional
-	}
+func WithElementOptional(optional bool) GenericApplier[*_Element] {
+	return WrapGenericApplier(func(e *_Element) { e.Optional = optional })
 }
 
-func WithElementContext(context int) func(*_Element) {
-	return func(e *_Element) {
-		e.Context = &context
-	}
+func WithElementContext(context int) GenericApplier[*_Element] {
+	return WrapGenericApplier(func(e *_Element) { e.Context = &context })
 }
 
 func (e *_Element) GetName() string {
diff --git a/plc4go/internal/bacnetip/bacgopes/debugging/debugging_DebugContents.go b/plc4go/internal/bacnetip/bacgopes/debugging/debugging_DebugContents.go
index 33f11d5ef20..47a8089527c 100644
--- a/plc4go/internal/bacnetip/bacgopes/debugging/debugging_DebugContents.go
+++ b/plc4go/internal/bacnetip/bacgopes/debugging/debugging_DebugContents.go
@@ -31,6 +31,7 @@ import (
 
 type Debuggable interface {
 	GetDebugAttr(attr string) any
+	GetLeafName() string
 }
 
 type DebugContentPrinter interface {
@@ -54,6 +55,14 @@ func NewDebugContents(debuggable Debuggable, contents ...string) *DebugContents
 
 var _ DebugContentPrinter = (*DebugContents)(nil)
 
+func (d *DebugContents) GetLeafName() string {
+	if len(d.debuggables) > 0 {
+		debuggable := d.debuggables[0]
+		return QualifiedTypeName(debuggable)
+	}
+	return StructName()
+}
+
 func (d *DebugContents) AddExtraPrinters(printers ...DebugContentPrinter) {
 	d.extraPrinters = append(d.extraPrinters, printers...)
 }
@@ -75,14 +84,14 @@ func (d *DebugContents) Format(s fmt.State, v rune) {
 		// TODO: check if that hacky hacky makes sense
 		if len(d.debuggables) > 0 {
 			debuggable := d.debuggables[0]
-			_, _ = fmt.Fprintf(s, "<%s at %p>", QualifiedTypeName(debuggable), debuggable)
+			_, _ = fmt.Fprintf(s, "<%s at %p>", debuggable.GetLeafName(), debuggable)
 		}
 	case 'r':
 		// TODO: check if that hacky hacky makes sense
 		if len(d.debuggables) > 0 {
 			debuggable := d.debuggables[0]
-			_, _ = fmt.Fprintf(s, "<%s at %p>\n", QualifiedTypeName(debuggable), debuggable)
-			_, _ = fmt.Fprintf(s, "    <%s at %p>\n", QualifiedTypeName(debuggable), debuggable) // TODO: why is this duplicated?
+			_, _ = fmt.Fprintf(s, "<%s at %p>\n", debuggable.GetLeafName(), debuggable)
+			_, _ = fmt.Fprintf(s, "    <%s at %p>\n", debuggable.GetLeafName(), debuggable) // TODO: why is this duplicated?
 		}
 		d.PrintDebugContents(2, s, nil)
 	}
@@ -306,7 +315,7 @@ func QualifiedTypeName(anything any) string {
 	if typeOf.Kind() == reflect.Ptr {
 		typeOf = typeOf.Elem()
 	}
-	typeNameString := "bacgopes." + typeOf.String()
+	typeNameString := projectName + "." + typeOf.String()
 	if customProjectName != "" {
 		typeNameString = strings.ReplaceAll(typeNameString, projectName, customProjectName)
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/debugging/debugging_DebugPrinter.go b/plc4go/internal/bacnetip/bacgopes/debugging/debugging_DebugPrinter.go
index ddc8ebeb914..d46bdeabe04 100644
--- a/plc4go/internal/bacnetip/bacgopes/debugging/debugging_DebugPrinter.go
+++ b/plc4go/internal/bacnetip/bacgopes/debugging/debugging_DebugPrinter.go
@@ -54,12 +54,12 @@ func CreateDebugPrinter() DebugPrinter {
 		return nil
 	}
 	dir := path.Dir(file)
-	rootIndex := strings.Index(dir, "bacgopes")
+	rootIndex := strings.Index(dir, projectName)
 	dir = dir[rootIndex:]
 	qualifier := strings.ReplaceAll(dir, "/", ".")
 	switch {
-	case strings.HasPrefix(qualifier, "bacgopes.tests"):
-		qualifier = "tests" + strings.TrimPrefix(qualifier, "bacgopes.tests")
+	case strings.HasPrefix(qualifier, projectName+".tests"):
+		qualifier = "tests" + strings.TrimPrefix(qualifier, projectName+".tests")
 	}
 	dirPrefix := path.Base(dir) + "_"
 
@@ -67,27 +67,12 @@ func CreateDebugPrinter() DebugPrinter {
 	if strings.Contains(bacgopesDebug, qualifier) {
 		_isDebuggingActive = true
 		return func(format string, a ...any) {
-			pc, file, _, ok := runtime.Caller(1)
+			_, file, _, ok := runtime.Caller(1)
 			if !ok {
 				return
 			}
 			base := path.Base(file)
 			prefix := strings.TrimSuffix(base, ".go")
-			if !strings.HasPrefix(prefix, dirPrefix) && !strings.Contains(prefix, "tests") && false { // TODO: disabled for now as it makes more trouble for the rest
-				// Attach the fuction name // TODO: check if that makes sense, only a workaround for bind at the moment
-				details := runtime.FuncForPC(pc)
-				name := details.Name()
-				name = name[strings.LastIndex(name, ".")+1:]
-				prefix = strings.ToLower(name)
-			}
-			{ //TODO: temporary debug
-				if strings.Contains(qualifier, "tests.") {
-					println()
-				}
-				if strings.Contains(file, "tests") {
-					println()
-				}
-			}
 			prefix = strings.TrimPrefix(prefix, dirPrefix)
 			formatString := "DEBUG:" + qualifier + "." + prefix + ":" + format + "\n"
 			formatString = cleanupFormatString(formatString)
@@ -102,12 +87,39 @@ func CreateDebugPrinter() DebugPrinter {
 			for k, v := range customReplaces {
 				output = strings.ReplaceAll(output, k, v)
 			}
+			if customProjectName != "" {
+				output = strings.ReplaceAll(output, projectName, customProjectName)
+			}
 			_, _ = os.Stdout.Write([]byte(output))
 		}
 	}
 	return nil
 }
 
+func fixVerbs(formatString string, values ...any) string {
+	length := len(formatString)
+	verbNumber := -1
+	for i, r := range formatString {
+		switch r {
+		case '%':
+			nextIndex := i + 1
+			if nextIndex >= length {
+				continue
+			}
+			followRune := formatString[nextIndex]
+			if followRune != '%' {
+				verbNumber++
+			}
+			if followRune == 'r' && verbNumber < len(values) { // TODO: this completely breaks at indexed verbs... better fix assap
+				runes := []rune(formatString)
+				runes[nextIndex] = VerbForType(values[verbNumber], 'r')
+				formatString = string(runes)
+			}
+		}
+	}
+	return formatString
+}
+
 func cleanupFormatString(s string) string {
 	// TODO: investigate via comm.comm is happening
 	s = strings.ReplaceAll(s, ".comm.comm:", ".comm:")
diff --git a/plc4go/internal/bacnetip/bacgopes/debugging/debugging_DefaultRFormatter.go b/plc4go/internal/bacnetip/bacgopes/debugging/debugging_DefaultRFormatter.go
index ac2fca2fd2c..283ea5e4e89 100644
--- a/plc4go/internal/bacnetip/bacgopes/debugging/debugging_DefaultRFormatter.go
+++ b/plc4go/internal/bacnetip/bacgopes/debugging/debugging_DefaultRFormatter.go
@@ -37,7 +37,7 @@ func NewDefaultRFormatter(extraPrinters ...DebugContentPrinter) *DefaultRFormatt
 		panic("oh no")
 	}
 	dir := path.Dir(file)
-	rootIndex := strings.Index(dir, "bacgopes")
+	rootIndex := strings.Index(dir, projectName)
 	dir = dir[rootIndex:]
 	dirPrefix := path.Base(dir) + "_"
 	base := path.Base(file)
@@ -47,7 +47,7 @@ func NewDefaultRFormatter(extraPrinters ...DebugContentPrinter) *DefaultRFormatt
 	if strings.HasPrefix(qualifier, "test.") {
 		qualifier = "tests.test_" + strings.TrimPrefix(qualifier, "test.")
 	} else {
-		qualifier = "bacgopes." + qualifier
+		qualifier = projectName + "." + qualifier
 	}
 	header := fmt.Sprintf("<%s at 0x%x>", qualifier+prefix, pc)
 	if customProjectName != "" {
diff --git a/plc4go/internal/bacnetip/bacgopes/debugging/debugging_commons.go b/plc4go/internal/bacnetip/bacgopes/debugging/debugging_commons.go
index aeeceea4632..4547c79193f 100644
--- a/plc4go/internal/bacnetip/bacgopes/debugging/debugging_commons.go
+++ b/plc4go/internal/bacnetip/bacgopes/debugging/debugging_commons.go
@@ -54,33 +54,9 @@ func Xtob(hexString string) ([]byte, error) {
 	return decodeString, nil
 }
 
-func fixVerbs(formatString string, values ...any) string {
-	length := len(formatString)
-	verbNumber := -1
-	for i, r := range formatString {
-		switch r {
-		case '%':
-			nextIndex := i + 1
-			if nextIndex >= length {
-				continue
-			}
-			followRune := formatString[nextIndex]
-			if followRune != '%' {
-				verbNumber++
-			}
-			if followRune == 'r' && verbNumber < len(values) { // TODO: this completely breaks at indexed verbs... better fix assap
-				runes := []rune(formatString)
-				runes[nextIndex] = VerbForType(values[verbNumber], 'r')
-				formatString = string(runes)
-			}
-		}
-	}
-	return formatString
-}
-
 func VerbForType(value any, printVerb rune) rune {
 	if isNil(value) {
-		return 'p' // hack to avoid panic
+		return 'v'
 	}
 	switch value.(type) {
 	case string:
@@ -123,7 +99,7 @@ func StructName() string {
 		return ""
 	}
 	dir := path.Dir(file)
-	rootIndex := strings.Index(dir, "bacgopes")
+	rootIndex := strings.Index(dir, projectName)
 	dir = dir[rootIndex:]
 	dirPrefix := path.Base(dir) + "_"
 	base := path.Base(file)
diff --git a/plc4go/internal/bacnetip/bacgopes/iocb/iocb_IOController.go b/plc4go/internal/bacnetip/bacgopes/iocb/iocb_IOController.go
index 0a982eafd32..eaf5d3cb603 100644
--- a/plc4go/internal/bacnetip/bacgopes/iocb/iocb_IOController.go
+++ b/plc4go/internal/bacnetip/bacgopes/iocb/iocb_IOController.go
@@ -23,6 +23,8 @@ import (
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog"
 
+	. "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"
 )
 
@@ -59,15 +61,18 @@ type IOController struct {
 	name         string
 	requirements IOControllerRequirements `ignore:"true"`
 
+	_leafName string
+
 	log zerolog.Logger
 }
 
-func NewIOController(localLog zerolog.Logger, name string, requirements IOControllerRequirements) (*IOController, error) {
+func NewIOController(localLog zerolog.Logger, name string, requirements IOControllerRequirements, options ...Option) (*IOController, error) {
 	localLog.Debug().Str("name", name).Msg("NewIOController")
 	return &IOController{
 		// save the name
 		name:         name,
 		requirements: requirements,
+		_leafName:    ExtractLeafName(options, StructName()),
 		log:          localLog,
 	}, nil
 }
diff --git a/plc4go/internal/bacnetip/bacgopes/iocb/iocb_IOController_plc4xgen.go b/plc4go/internal/bacnetip/bacgopes/iocb/iocb_IOController_plc4xgen.go
index b485a8ec5bb..f07fbbcbd5e 100644
--- a/plc4go/internal/bacnetip/bacgopes/iocb/iocb_IOController_plc4xgen.go
+++ b/plc4go/internal/bacnetip/bacgopes/iocb/iocb_IOController_plc4xgen.go
@@ -52,6 +52,10 @@ func (d *IOController) SerializeWithWriteBuffer(ctx context.Context, writeBuffer
 	if err := writeBuffer.WriteString("name", uint32(len(d.name)*8), d.name); err != nil {
 		return err
 	}
+
+	if err := writeBuffer.WriteString("_leafName", uint32(len(d._leafName)*8), d._leafName); err != nil {
+		return err
+	}
 	if err := writeBuffer.PopContext("IOController"); err != nil {
 		return err
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/local/device/local_device_LocalDevice.go b/plc4go/internal/bacnetip/bacgopes/local/device/local_device_LocalDevice.go
index 8ff2d196f10..97b17dc77bd 100644
--- a/plc4go/internal/bacnetip/bacgopes/local/device/local_device_LocalDevice.go
+++ b/plc4go/internal/bacnetip/bacgopes/local/device/local_device_LocalDevice.go
@@ -23,12 +23,14 @@ import (
 	"fmt"
 
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/comp"
-	"github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/object"
+	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/debugging"
+	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/object"
 	readWriteModel "github.com/apache/plc4x/plc4go/protocols/bacnetip/readwrite/model"
 )
 
 type LocalDeviceObject interface {
 	fmt.Stringer
+	fmt.Formatter
 	GetObjectIdentifier() string
 	GetMaximumApduLengthAccepted() *readWriteModel.MaxApduLengthAccepted
 	GetSegmentationSupported() *readWriteModel.BACnetSegmentation
@@ -42,14 +44,10 @@ type LocalDeviceObject interface {
 	GetObjectList() []string
 	SetObjectList([]string)
 }
-
-func NewLocalDeviceObject(args Args, kwArgs KWArgs) LocalDeviceObject {
-	return &localDeviceObject{}
-}
-
-type localDeviceObject struct {
+type _LocalDeviceObject struct {
 	*CurrentPropertyListMixIn
-	*object.DeviceObject
+	*DeviceObject
+	*DefaultRFormatter
 
 	// TODO: replace below...
 	NumberOfAPDURetries       *uint
@@ -65,54 +63,60 @@ type localDeviceObject struct {
 	ObjectList                []string
 }
 
-func (l *localDeviceObject) GetObjectIdentifier() string {
+func NewLocalDeviceObject(args Args, kwArgs KWArgs) LocalDeviceObject {
+	return &_LocalDeviceObject{
+		DefaultRFormatter: NewDefaultRFormatter(),
+	}
+}
+
+func (l *_LocalDeviceObject) GetObjectIdentifier() string {
 	return l.ObjectIdentifier
 }
 
-func (l *localDeviceObject) GetMaximumApduLengthAccepted() *readWriteModel.MaxApduLengthAccepted {
+func (l *_LocalDeviceObject) GetMaximumApduLengthAccepted() *readWriteModel.MaxApduLengthAccepted {
 	return l.MaximumApduLengthAccepted
 }
 
-func (l *localDeviceObject) GetSegmentationSupported() *readWriteModel.BACnetSegmentation {
+func (l *_LocalDeviceObject) GetSegmentationSupported() *readWriteModel.BACnetSegmentation {
 	return l.SegmentationSupported
 }
 
-func (l *localDeviceObject) GetVendorIdentifier() any {
+func (l *_LocalDeviceObject) GetVendorIdentifier() any {
 	return l.VendorIdentifier
 }
 
-func (l *localDeviceObject) GetNumberOfAPDURetries() *uint {
+func (l *_LocalDeviceObject) GetNumberOfAPDURetries() *uint {
 	return l.NumberOfAPDURetries
 }
 
-func (l *localDeviceObject) GetAPDUTimeout() *uint {
+func (l *_LocalDeviceObject) GetAPDUTimeout() *uint {
 	return l.APDUTimeout
 }
 
-func (l *localDeviceObject) SetApp(a any) {
+func (l *_LocalDeviceObject) SetApp(a any) {
 	l.App = a
 }
 
-func (l *localDeviceObject) GetAPDUSegmentTimeout() *uint {
+func (l *_LocalDeviceObject) GetAPDUSegmentTimeout() *uint {
 	return l.APDUSegmentTimeout
 }
 
-func (l *localDeviceObject) GetObjectName() string {
+func (l *_LocalDeviceObject) GetObjectName() string {
 	return l.ObjectName
 }
 
-func (l *localDeviceObject) GetMaxSegmentsAccepted() *readWriteModel.MaxSegmentsAccepted {
+func (l *_LocalDeviceObject) GetMaxSegmentsAccepted() *readWriteModel.MaxSegmentsAccepted {
 	return l.MaxSegmentsAccepted
 }
 
-func (l *localDeviceObject) GetObjectList() []string {
+func (l *_LocalDeviceObject) GetObjectList() []string {
 	return l.ObjectList
 }
 
-func (l *localDeviceObject) SetObjectList(strings []string) {
+func (l *_LocalDeviceObject) SetObjectList(strings []string) {
 	l.ObjectList = strings
 }
 
-func (l *localDeviceObject) String() string {
+func (l *_LocalDeviceObject) String() string {
 	panic("implementme")
 }
diff --git a/plc4go/internal/bacnetip/bacgopes/netservice/netservice.go b/plc4go/internal/bacnetip/bacgopes/netservice/netservice.go
index b745659cb78..1e9adeb2749 100644
--- a/plc4go/internal/bacnetip/bacgopes/netservice/netservice.go
+++ b/plc4go/internal/bacnetip/bacgopes/netservice/netservice.go
@@ -21,6 +21,8 @@ package netservice
 
 import . "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/comp"
 
+// TODO: add debug printing
+
 // used for net keys like snet and dnet (tri state)
 type netKey = NillableKey[uint16]
 
diff --git a/plc4go/internal/bacnetip/bacgopes/netservice/netservice_NetworkAdapter.go b/plc4go/internal/bacnetip/bacgopes/netservice/netservice_NetworkAdapter.go
index cc1a03d3b4d..fba7038cfe6 100644
--- a/plc4go/internal/bacnetip/bacgopes/netservice/netservice_NetworkAdapter.go
+++ b/plc4go/internal/bacnetip/bacgopes/netservice/netservice_NetworkAdapter.go
@@ -42,13 +42,10 @@ type NetworkAdapter struct {
 	adapterAddr          *Address
 	adapterNetConfigured *int
 
-	// pass through args
-	argCid *int
-
 	log zerolog.Logger
 }
 
-func NewNetworkAdapter(localLog zerolog.Logger, sap *NetworkServiceAccessPoint, net *uint16, addr *Address, opts ...func(*NetworkAdapter)) (*NetworkAdapter, error) {
+func NewNetworkAdapter(localLog zerolog.Logger, sap *NetworkServiceAccessPoint, net *uint16, addr *Address, options ...Option) (*NetworkAdapter, error) {
 	n := &NetworkAdapter{
 		adapterSAP:  sap,
 		adapterNet:  net,
@@ -56,13 +53,11 @@ func NewNetworkAdapter(localLog zerolog.Logger, sap *NetworkServiceAccessPoint,
 
 		log: localLog,
 	}
-	for _, opt := range opts {
-		opt(n)
-	}
+	ApplyAppliers(options, n)
+	optionsForParent := AddLeafTypeIfAbundant(options, n)
 	n.DebugContents = NewDebugContents(n, "adapterSAP-", "adapterNet", "adapterAddr", "adapterNetConfigured")
-	n.log.Trace().Stringer("sap", sap).Interface("net", net).Stringer("addr", addr).Interface("cid", n.argCid).Msg("NewNetworkAdapter")
 	var err error
-	n.ClientContract, err = NewClient(n.log, OptionalOption2(n.argCid, ToPtr[ClientRequirements](n), WithClientCID))
+	n.ClientContract, err = NewClient(n.log, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating client")
 	}
@@ -74,12 +69,6 @@ func NewNetworkAdapter(localLog zerolog.Logger, sap *NetworkServiceAccessPoint,
 	return n, nil
 }
 
-func WithNetworkAdapterCid(cid int) func(*NetworkAdapter) {
-	return func(na *NetworkAdapter) {
-		na.argCid = &cid
-	}
-}
-
 func (n *NetworkAdapter) GetDebugAttr(attr string) any {
 	switch attr {
 	case "adapterSAP":
diff --git a/plc4go/internal/bacnetip/bacgopes/netservice/netservice_NetworkAdapter_plc4xgen.go b/plc4go/internal/bacnetip/bacgopes/netservice/netservice_NetworkAdapter_plc4xgen.go
index 5bcdb56132d..4997af8de7d 100644
--- a/plc4go/internal/bacnetip/bacgopes/netservice/netservice_NetworkAdapter_plc4xgen.go
+++ b/plc4go/internal/bacnetip/bacgopes/netservice/netservice_NetworkAdapter_plc4xgen.go
@@ -74,11 +74,6 @@ func (d *NetworkAdapter) SerializeWithWriteBuffer(ctx context.Context, writeBuff
 			return err
 		}
 	}
-	if d.argCid != nil {
-		if err := writeBuffer.WriteInt64("argCid", 64, int64(*d.argCid)); err != nil {
-			return err
-		}
-	}
 	if err := writeBuffer.PopContext("NetworkAdapter"); err != nil {
 		return err
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/netservice/netservice_NetworkServiceAccessPoint.go b/plc4go/internal/bacnetip/bacgopes/netservice/netservice_NetworkServiceAccessPoint.go
index 642431c8e01..c1018b54863 100644
--- a/plc4go/internal/bacnetip/bacgopes/netservice/netservice_NetworkServiceAccessPoint.go
+++ b/plc4go/internal/bacnetip/bacgopes/netservice/netservice_NetworkServiceAccessPoint.go
@@ -47,28 +47,22 @@ type NetworkServiceAccessPoint struct {
 	pendingNets     map[netKey][]NPDU
 	localAdapter    *NetworkAdapter `stringer:"true"`
 
-	// pass through args
-	argSapID *int                `ignore:"true"`
-	argSap   *ServiceAccessPoint `ignore:"true"`
-	argSid   *int                `ignore:"true"`
-
 	log zerolog.Logger
 }
 
-func NewNetworkServiceAccessPoint(localLog zerolog.Logger, opts ...func(*NetworkServiceAccessPoint)) (*NetworkServiceAccessPoint, error) {
+func NewNetworkServiceAccessPoint(localLog zerolog.Logger, options ...Option) (*NetworkServiceAccessPoint, error) {
 	n := &NetworkServiceAccessPoint{
 		log: localLog,
 	}
 	n.DebugContents = NewDebugContents(n, "adapters++", "pending_nets", "local_adapter-")
-	for _, opt := range opts {
-		opt(n)
-	}
+	ApplyAppliers(options, n)
+	optionsForParent := AddLeafTypeIfAbundant(options, n)
 	var err error
-	n.ServiceAccessPointContract, err = NewServiceAccessPoint(localLog, OptionalOption2(n.argSapID, n.argSap, WithServiceAccessPointSapID))
+	n.ServiceAccessPointContract, err = NewServiceAccessPoint(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating network service access point")
 	}
-	n.ServerContract, err = NewServer(localLog, OptionalOption2(n.argSid, ToPtr[ServerRequirements](n), WithServerSID))
+	n.ServerContract, err = NewServer(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating server")
 	}
@@ -87,23 +81,8 @@ func NewNetworkServiceAccessPoint(localLog zerolog.Logger, opts ...func(*Network
 	return n, nil
 }
 
-func WithNetworkServiceAccessPointRouterInfoCache(routerInfoCache *RouterInfoCache) func(*NetworkServiceAccessPoint) {
-	return func(n *NetworkServiceAccessPoint) {
-		n.routerInfoCache = routerInfoCache
-	}
-}
-
-func WithNetworkServiceAccessPointRouterSapID(sapID int, sap ServiceAccessPoint) func(*NetworkServiceAccessPoint) {
-	return func(n *NetworkServiceAccessPoint) {
-		n.argSapID = &sapID
-		n.argSap = &sap
-	}
-}
-
-func WithNetworkServiceAccessPointRouterSID(sid int) func(*NetworkServiceAccessPoint) {
-	return func(n *NetworkServiceAccessPoint) {
-		n.argSid = &sid
-	}
+func WithNetworkServiceAccessPointRouterInfoCache(routerInfoCache *RouterInfoCache) GenericApplier[*NetworkServiceAccessPoint] {
+	return WrapGenericApplier(func(n *NetworkServiceAccessPoint) { n.routerInfoCache = routerInfoCache })
 }
 
 func (n *NetworkServiceAccessPoint) GetDebugAttr(attr string) any {
diff --git a/plc4go/internal/bacnetip/bacgopes/netservice/netservice_NetworkServiceElement.go b/plc4go/internal/bacnetip/bacgopes/netservice/netservice_NetworkServiceElement.go
index 4f519b222d4..8d6d04eaaeb 100644
--- a/plc4go/internal/bacnetip/bacgopes/netservice/netservice_NetworkServiceElement.go
+++ b/plc4go/internal/bacnetip/bacgopes/netservice/netservice_NetworkServiceElement.go
@@ -46,24 +46,18 @@ type NetworkServiceElement struct {
 	// regular args
 	argStartupDisabled bool `ignore:"true"`
 
-	// pass through args
-	argEID *int                       `ignore:"true"`
-	argAse *ApplicationServiceElement `ignore:"true"`
-
 	log zerolog.Logger
 }
 
-func NewNetworkServiceElement(localLog zerolog.Logger, opts ...func(*NetworkServiceElement)) (*NetworkServiceElement, error) {
+func NewNetworkServiceElement(localLog zerolog.Logger, options ...Option) (*NetworkServiceElement, error) {
 	n := &NetworkServiceElement{
 		DefaultRFormatter: NewDefaultRFormatter(),
 		log:               localLog,
 	}
-	for _, opt := range opts {
-		opt(n)
-	}
-	n.log.Trace().Interface("eid", n.argEID).Msg("NewNetworkServiceElement")
+	ApplyAppliers(options, n)
+	optionsForParent := AddLeafTypeIfAbundant(options, n)
 	var err error
-	n.ApplicationServiceElementContract, err = NewApplicationServiceElement(localLog, OptionalOption2(n.argEID, n.argAse, WithApplicationServiceElementAseID))
+	n.ApplicationServiceElementContract, err = NewApplicationServiceElement(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating application service element")
 	}
@@ -78,17 +72,8 @@ func NewNetworkServiceElement(localLog zerolog.Logger, opts ...func(*NetworkServ
 	return n, nil
 }
 
-func WithNetworkServiceElementEID(eid int, ase ApplicationServiceElement) func(*NetworkServiceElement) {
-	return func(n *NetworkServiceElement) {
-		n.argEID = &eid
-		n.argAse = &ase
-	}
-}
-
-func WithNetworkServiceElementStartupDisabled(startupDisabled bool) func(*NetworkServiceElement) {
-	return func(n *NetworkServiceElement) {
-		n.argStartupDisabled = startupDisabled
-	}
+func WithNetworkServiceElementStartupDisabled(startupDisabled bool) GenericApplier[*NetworkServiceElement] {
+	return WrapGenericApplier(func(n *NetworkServiceElement) { n.argStartupDisabled = startupDisabled })
 }
 
 func (n *NetworkServiceElement) Startup(_ Args, _ KWArgs) error {
diff --git a/plc4go/internal/bacnetip/bacgopes/npdu/npdu_RoutingTableEntry.go b/plc4go/internal/bacnetip/bacgopes/npdu/npdu_RoutingTableEntry.go
index 29a9076c85c..1405c20aa6c 100644
--- a/plc4go/internal/bacnetip/bacgopes/npdu/npdu_RoutingTableEntry.go
+++ b/plc4go/internal/bacnetip/bacgopes/npdu/npdu_RoutingTableEntry.go
@@ -23,6 +23,7 @@ import (
 	"bytes"
 	"fmt"
 
+	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/comp"
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/debugging"
 )
 
@@ -33,12 +34,10 @@ type RoutingTableEntry struct {
 	rtPortInfo     []byte
 }
 
-func NewRoutingTableEntry(opts ...func(*RoutingTableEntry)) *RoutingTableEntry {
+func NewRoutingTableEntry(options ...Option) *RoutingTableEntry {
 	r := &RoutingTableEntry{}
 	r.DebugContents = NewDebugContents(r, "rtDNET", "rtPortID", "rtPortInfo")
-	for _, opt := range opts {
-		opt(r)
-	}
+	ApplyAppliers(options, r)
 	return r
 }
 
@@ -55,22 +54,16 @@ func (r *RoutingTableEntry) GetDebugAttr(attr string) any {
 	}
 }
 
-func WithRoutingTableEntryDestinationNetworkAddress(dnet uint16) func(*RoutingTableEntry) {
-	return func(r *RoutingTableEntry) {
-		r.rtDNET = dnet
-	}
+func WithRoutingTableEntryDestinationNetworkAddress(dnet uint16) GenericApplier[*RoutingTableEntry] {
+	return WrapGenericApplier(func(r *RoutingTableEntry) { r.rtDNET = dnet })
 }
 
-func WithRoutingTableEntryPortId(id uint8) func(*RoutingTableEntry) {
-	return func(r *RoutingTableEntry) {
-		r.rtPortId = id
-	}
+func WithRoutingTableEntryPortId(id uint8) GenericApplier[*RoutingTableEntry] {
+	return WrapGenericApplier(func(r *RoutingTableEntry) { r.rtPortId = id })
 }
 
-func WithRoutingTableEntryPortInfo(portInfo []byte) func(*RoutingTableEntry) {
-	return func(r *RoutingTableEntry) {
-		r.rtPortInfo = portInfo
-	}
+func WithRoutingTableEntryPortInfo(portInfo []byte) GenericApplier[*RoutingTableEntry] {
+	return WrapGenericApplier(func(r *RoutingTableEntry) { r.rtPortInfo = portInfo })
 }
 
 func (r *RoutingTableEntry) tuple() (destinationNetworkAddress uint16, portId uint8, portInfoLength uint8, portInfo []byte) {
diff --git a/plc4go/internal/bacnetip/bacgopes/object/object_OptionalProperty.go b/plc4go/internal/bacnetip/bacgopes/object/object_OptionalProperty.go
index d1c29cfe46f..d10906fb10a 100644
--- a/plc4go/internal/bacnetip/bacgopes/object/object_OptionalProperty.go
+++ b/plc4go/internal/bacnetip/bacgopes/object/object_OptionalProperty.go
@@ -26,6 +26,6 @@ type OptionalProperty interface {
 	StandardProperty
 }
 
-func NewOptionalProperty(name string, klass func(Args, KWArgs) (PropertyKlass, error), opts ...func(*PropertyKlass)) OptionalProperty {
+func NewOptionalProperty(name string, klass func(Args, KWArgs) (PropertyKlass, error), options ...Option) OptionalProperty {
 	panic("implement me")
 }
diff --git a/plc4go/internal/bacnetip/bacgopes/object/object_Property.go b/plc4go/internal/bacnetip/bacgopes/object/object_Property.go
index a224285ba0b..bfbbddbba69 100644
--- a/plc4go/internal/bacnetip/bacgopes/object/object_Property.go
+++ b/plc4go/internal/bacnetip/bacgopes/object/object_Property.go
@@ -31,7 +31,7 @@ type PropertyKlass interface {
 	Encode(Arg) error
 }
 
-func NewProperty(name string, klass func(Args, KWArgs) (PropertyKlass, error), opts ...func(*PropertyKlass)) Property {
+func NewProperty(name string, klass func(Args, KWArgs) (PropertyKlass, error), options ...Option) Property {
 	return &_Property{}
 }
 
diff --git a/plc4go/internal/bacnetip/bacgopes/pdu/pdu_PCI.go b/plc4go/internal/bacnetip/bacgopes/pdu/pdu_PCI.go
index 652471f70a5..c98106ff0f4 100644
--- a/plc4go/internal/bacnetip/bacgopes/pdu/pdu_PCI.go
+++ b/plc4go/internal/bacnetip/bacgopes/pdu/pdu_PCI.go
@@ -81,7 +81,11 @@ func NewPCI(args Args, kwArgs KWArgs, options ...Option) *_PCI {
 func (p *_PCI) GetDebugAttr(attr string) any {
 	switch attr {
 	case "pduExpectingReply":
-		return p.pduExpectingReply
+		if p.pduExpectingReply {
+			return 1
+		} else {
+			return 0
+		}
 	case "pduNetworkPriority":
 		return p.pduNetworkPriority
 	default:
diff --git a/plc4go/internal/bacnetip/bacgopes/service/service_device_WhoIsIAmServices.go b/plc4go/internal/bacnetip/bacgopes/service/service_device_WhoIsIAmServices.go
index 06fbc8a5b9e..c20a18c70f8 100644
--- a/plc4go/internal/bacnetip/bacgopes/service/service_device_WhoIsIAmServices.go
+++ b/plc4go/internal/bacnetip/bacgopes/service/service_device_WhoIsIAmServices.go
@@ -49,18 +49,17 @@ type WhoIsIAmServices struct {
 	log zerolog.Logger
 }
 
-func NewWhoIsIAmServices(localLog zerolog.Logger, whoIsIAmServicesRequirements WhoIsIAmServicesRequirements, opts ...func(*WhoIsIAmServices)) (*WhoIsIAmServices, error) {
+func NewWhoIsIAmServices(localLog zerolog.Logger, whoIsIAmServicesRequirements WhoIsIAmServicesRequirements, options ...Option) (*WhoIsIAmServices, error) {
 	w := &WhoIsIAmServices{
 		_requirements: whoIsIAmServicesRequirements,
 		log:           localLog,
 	}
-	for _, opt := range opts {
-		opt(w)
-	}
+	ApplyAppliers(options, w)
+	optionsForParent := AddLeafTypeIfAbundant(options, w)
 	if _debug != nil {
 		_debug("__init__")
 	}
-	w.Capability = NewCapability()
+	w.Capability = NewCapability(optionsForParent...)
 	if err := w._requirements.RegisterHelperFn(fmt.Sprintf("Do_%T", &WhoIsRequest{}), w.DoWhoIsRequest); err != nil {
 		return nil, errors.Wrap(err, "registering function failed")
 	}
@@ -70,10 +69,8 @@ func NewWhoIsIAmServices(localLog zerolog.Logger, whoIsIAmServicesRequirements W
 	return w, nil
 }
 
-func WithWhoIsIAmServicesLocalDevice(localDevice LocalDeviceObject) func(*WhoIsIAmServices) {
-	return func(w *WhoIsIAmServices) {
-		w.localDevice = localDevice
-	}
+func WithWhoIsIAmServicesLocalDevice(localDevice LocalDeviceObject) GenericApplier[*WhoIsIAmServices] {
+	return WrapGenericApplier(func(w *WhoIsIAmServices) { w.localDevice = localDevice })
 }
 
 func (w *WhoIsIAmServices) Startup() error {
diff --git a/plc4go/internal/bacnetip/bacgopes/service/service_object_ReadWritePropertyServices.go b/plc4go/internal/bacnetip/bacgopes/service/service_object_ReadWritePropertyServices.go
index 8c56f11f011..2c118850068 100644
--- a/plc4go/internal/bacnetip/bacgopes/service/service_object_ReadWritePropertyServices.go
+++ b/plc4go/internal/bacnetip/bacgopes/service/service_object_ReadWritePropertyServices.go
@@ -25,7 +25,7 @@ import . "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/comp"
 type ReadWritePropertyServices struct {
 }
 
-func NewReadWritePropertyServices() (*ReadWritePropertyServices, error) {
+func NewReadWritePropertyServices(options ...Option) (*ReadWritePropertyServices, error) {
 	// TODO: implement me
 	return nil, nil
 }
diff --git a/plc4go/internal/bacnetip/bacgopes/task/task_OneShotDeleteTask.go b/plc4go/internal/bacnetip/bacgopes/task/task_OneShotDeleteTask.go
index b1e07e344e7..6e2b44d5533 100644
--- a/plc4go/internal/bacnetip/bacgopes/task/task_OneShotDeleteTask.go
+++ b/plc4go/internal/bacnetip/bacgopes/task/task_OneShotDeleteTask.go
@@ -20,7 +20,7 @@
 package task
 
 import (
-	"time"
+	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/comp"
 )
 
 //go:generate plc4xGenerator -type=OneShotDeleteTask -prefix=task_
@@ -28,11 +28,11 @@ type OneShotDeleteTask struct {
 	*Task
 }
 
-func NewOneShotDeleteTask(taskRequirements TaskRequirements, when *time.Time) *OneShotDeleteTask {
+func NewOneShotDeleteTask(taskRequirements TaskRequirements, options ...Option) *OneShotDeleteTask {
 	o := &OneShotDeleteTask{}
-	o.Task = NewTask(taskRequirements, func(task *Task) {
-		task.taskTime = when
-	})
+	ApplyAppliers(options, o)
+	optionsForParent := AddLeafTypeIfAbundant(options, o)
+	o.Task = NewTask(taskRequirements, optionsForParent...)
 	return o
 }
 
diff --git a/plc4go/internal/bacnetip/bacgopes/task/task_OneShotFunctionTask.go b/plc4go/internal/bacnetip/bacgopes/task/task_OneShotFunctionTask.go
index 1e7454225a4..40726d85d93 100644
--- a/plc4go/internal/bacnetip/bacgopes/task/task_OneShotFunctionTask.go
+++ b/plc4go/internal/bacnetip/bacgopes/task/task_OneShotFunctionTask.go
@@ -31,14 +31,14 @@ type OneShotFunctionTask struct {
 
 func OneShotFunction(fn GenericFunction, args Args, kwArgs KWArgs) *OneShotFunctionTask {
 	task := &OneShotFunctionTask{fn: fn, args: args, kwArgs: kwArgs}
-	task.OneShotDeleteTask = NewOneShotDeleteTask(task, nil)
+	task.OneShotDeleteTask = NewOneShotDeleteTask(task)
 	task.InstallTask(WithInstallTaskOptionsDelta(0))
 	return task
 }
 
 func FunctionTask(fn GenericFunction, args Args, kwArgs KWArgs) *OneShotFunctionTask {
 	task := &OneShotFunctionTask{fn: fn, args: args, kwArgs: kwArgs}
-	task.OneShotDeleteTask = NewOneShotDeleteTask(task, nil)
+	task.OneShotDeleteTask = NewOneShotDeleteTask(task)
 	return task
 }
 
diff --git a/plc4go/internal/bacnetip/bacgopes/task/task_OneShotTask.go b/plc4go/internal/bacnetip/bacgopes/task/task_OneShotTask.go
index 320778cea04..fc8c7e2a74c 100644
--- a/plc4go/internal/bacnetip/bacgopes/task/task_OneShotTask.go
+++ b/plc4go/internal/bacnetip/bacgopes/task/task_OneShotTask.go
@@ -20,7 +20,7 @@
 package task
 
 import (
-	"time"
+	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/comp"
 )
 
 //go:generate plc4xGenerator -type=OneShotTask -prefix=task_
@@ -28,10 +28,10 @@ type OneShotTask struct {
 	*Task
 }
 
-func NewOneShotTask(taskRequirements TaskRequirements, when *time.Time) *OneShotTask {
+func NewOneShotTask(taskRequirements TaskRequirements, options ...Option) *OneShotTask {
 	o := &OneShotTask{}
-	o.Task = NewTask(taskRequirements, func(task *Task) {
-		task.taskTime = when
-	})
+	ApplyAppliers(options, o)
+	optionsForParent := AddLeafTypeIfAbundant(options, o)
+	o.Task = NewTask(taskRequirements, Combine(optionsForParent)...)
 	return o
 }
diff --git a/plc4go/internal/bacnetip/bacgopes/task/task_RecurringFunctionTask.go b/plc4go/internal/bacnetip/bacgopes/task/task_RecurringFunctionTask.go
index 584b3f110f3..b7535ea2128 100644
--- a/plc4go/internal/bacnetip/bacgopes/task/task_RecurringFunctionTask.go
+++ b/plc4go/internal/bacnetip/bacgopes/task/task_RecurringFunctionTask.go
@@ -35,15 +35,14 @@ type RecurringFunctionTask struct {
 	kwArgs KWArgs
 }
 
-func NewRecurringFunctionTask(localLog zerolog.Logger, fn GenericFunction, args Args, kwArgs KWArgs, opts ...func(*RecurringFunctionTask)) *RecurringFunctionTask {
+func NewRecurringFunctionTask(localLog zerolog.Logger, fn GenericFunction, args Args, kwArgs KWArgs, options ...Option) *RecurringFunctionTask {
 	r := &RecurringFunctionTask{fn: fn, args: args, kwArgs: kwArgs}
-	for _, opt := range opts {
-		opt(r)
-	}
+	ApplyAppliers(options, r)
+	optionsForParent := AddLeafTypeIfAbundant(options, r)
 	if _debug != nil {
 		_debug("RecurringFunctionTask %r %r %r", fn, args, kwArgs)
 	}
-	r.RecurringTask = NewRecurringTask(localLog, r)
+	r.RecurringTask = NewRecurringTask(localLog, r, optionsForParent...)
 	if _debug != nil {
 		_debug("    - task: %r", r)
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/task/task_RecurringTask.go b/plc4go/internal/bacnetip/bacgopes/task/task_RecurringTask.go
index 9b5b2e25640..fc0c9d1609e 100644
--- a/plc4go/internal/bacnetip/bacgopes/task/task_RecurringTask.go
+++ b/plc4go/internal/bacnetip/bacgopes/task/task_RecurringTask.go
@@ -20,10 +20,11 @@
 package task
 
 import (
-	"fmt"
 	"time"
 
 	"github.com/rs/zerolog"
+
+	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/comp"
 )
 
 type RecurringTask struct {
@@ -35,17 +36,16 @@ type RecurringTask struct {
 	log zerolog.Logger
 }
 
-func NewRecurringTask(localLog zerolog.Logger, taskRequirements TaskRequirements, opts ...func(*RecurringTask)) *RecurringTask {
+func NewRecurringTask(localLog zerolog.Logger, taskRequirements TaskRequirements, options ...Option) *RecurringTask {
 	r := &RecurringTask{
 		log: localLog,
 	}
-	for _, opt := range opts {
-		opt(r)
-	}
+	ApplyAppliers(options, r)
+	optionsForParent := AddLeafTypeIfAbundant(options, r)
 	if _debug != nil {
 		_debug("__init__ interval=%r offset=%r", r.taskInterval, r.taskIntervalOffset)
 	}
-	r.Task = NewTask(taskRequirements)
+	r.Task = NewTask(taskRequirements, optionsForParent...)
 	r.AddDebugContents(r, "taskInterval", "taskIntervalOffset")
 	return r
 }
@@ -64,16 +64,12 @@ func (r *RecurringTask) GetDebugAttr(attr string) any {
 	return nil
 }
 
-func WithRecurringTaskInterval(interval time.Duration) func(task *RecurringTask) {
-	return func(task *RecurringTask) {
-		task.taskInterval = &interval
-	}
+func WithRecurringTaskInterval(interval time.Duration) GenericApplier[*RecurringTask] {
+	return WrapGenericApplier(func(task *RecurringTask) { task.taskInterval = &interval })
 }
 
-func WithRecurringTaskOffset(offset time.Duration) func(task *RecurringTask) {
-	return func(task *RecurringTask) {
-		task.taskIntervalOffset = &offset
-	}
+func WithRecurringTaskOffset(offset time.Duration) GenericApplier[*RecurringTask] {
+	return WrapGenericApplier(func(task *RecurringTask) { task.taskIntervalOffset = &offset })
 }
 
 func (r *RecurringTask) InstallTask(options InstallTaskOptions) {
@@ -140,7 +136,3 @@ func (r *RecurringTask) InstallTask(options InstallTaskOptions) {
 func (r *RecurringTask) IsRecurringTask() bool {
 	return true
 }
-
-func (r *RecurringTask) String() string {
-	return fmt.Sprintf("RecurringTask(%v, taskInterval: %v, taskIntervalOffset: %v)", r.Task, r.taskInterval, r.taskIntervalOffset)
-}
diff --git a/plc4go/internal/bacnetip/bacgopes/task/task_Task.go b/plc4go/internal/bacnetip/bacgopes/task/task_Task.go
index ebc07359617..f22564cae0f 100644
--- a/plc4go/internal/bacnetip/bacgopes/task/task_Task.go
+++ b/plc4go/internal/bacnetip/bacgopes/task/task_Task.go
@@ -23,6 +23,7 @@ import (
 	"fmt"
 	"time"
 
+	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/comp"
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/debugging"
 )
 
@@ -41,17 +42,26 @@ type Task struct {
 	TaskRequirements `ignore:"true"`
 	taskTime         *time.Time
 	isScheduled      bool
+
+	_leafName string
 }
 
-func NewTask(taskRequirements TaskRequirements, opts ...func(*Task)) *Task {
-	t := &Task{TaskRequirements: taskRequirements}
-	t.DebugContents = NewDebugContents(t, "taskTime", "isScheduled")
-	for _, opt := range opts {
-		opt(t)
+func NewTask(taskRequirements TaskRequirements, options ...Option) *Task {
+	t := &Task{
+		TaskRequirements: taskRequirements,
+		_leafName:        ExtractLeafName(options, StructName()),
 	}
+	ApplyAppliers(options, t)
+	t.DebugContents = NewDebugContents(t, "taskTime", "isScheduled")
 	return t
 }
 
+func WithTaskTime(taskTime time.Time) GenericApplier[*Task] {
+	return WrapGenericApplier(func(t *Task) {
+		t.taskTime = &taskTime
+	})
+}
+
 func (t *Task) GetDebugAttr(attr string) any {
 	switch attr {
 	case "taskTime":
@@ -64,6 +74,10 @@ func (t *Task) GetDebugAttr(attr string) any {
 	return nil
 }
 
+func (t *Task) GetLeafName() string {
+	return t._leafName
+}
+
 func (t *Task) InstallTask(options InstallTaskOptions) {
 	when := options.When
 	delta := options.Delta
diff --git a/plc4go/internal/bacnetip/bacgopes/task/task_Task_plc4xgen.go b/plc4go/internal/bacnetip/bacgopes/task/task_Task_plc4xgen.go
index 4d246482b34..7545cbe8119 100644
--- a/plc4go/internal/bacnetip/bacgopes/task/task_Task_plc4xgen.go
+++ b/plc4go/internal/bacnetip/bacgopes/task/task_Task_plc4xgen.go
@@ -57,6 +57,10 @@ func (d *Task) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.W
 	if err := writeBuffer.WriteBit("isScheduled", d.isScheduled); err != nil {
 		return err
 	}
+
+	if err := writeBuffer.WriteString("_leafName", uint32(len(d._leafName)*8), d._leafName); err != nil {
+		return err
+	}
 	if err := writeBuffer.PopContext("Task"); err != nil {
 		return err
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_ClientStateMachine.go b/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_ClientStateMachine.go
index d70e75f9b31..ffde13e7226 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_ClientStateMachine.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_ClientStateMachine.go
@@ -58,13 +58,12 @@ type ClientStateMachine struct {
 
 var _ ClientStateMachineContract = (*ClientStateMachine)(nil)
 
-func NewClientStateMachine(localLog zerolog.Logger, opts ...func(*ClientStateMachine)) (*ClientStateMachine, error) {
+func NewClientStateMachine(localLog zerolog.Logger, options ...Option) (*ClientStateMachine, error) {
 	c := &ClientStateMachine{
 		log: localLog,
 	}
-	for _, opt := range opts {
-		opt(c)
-	}
+	ApplyAppliers(options, c)
+	optionsForParent := AddLeafTypeIfAbundant(options, c)
 	if c.contract == nil {
 		c.contract = c
 	}
@@ -75,26 +74,22 @@ func NewClientStateMachine(localLog zerolog.Logger, opts ...func(*ClientStateMac
 		c.log = c.log.With().Str("name", c.name).Logger()
 	}
 	var err error
-	c.ClientContract, err = NewClient(localLog) // TODO: do we need to pass cid?
+	c.ClientContract, err = NewClient(localLog, optionsForParent...) // TODO: do we need to pass cid?
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating client")
 	}
 	var init func()
-	c.StateMachineContract, init = NewStateMachine(localLog, c.contract, WithStateMachineName(c.name))
+	c.StateMachineContract, init = NewStateMachine(localLog, c.contract, Combine(optionsForParent, WithStateMachineName(c.name))...)
 	init()
 	return c, nil
 }
 
-func WithClientStateMachineName(name string) func(*ClientStateMachine) {
-	return func(c *ClientStateMachine) {
-		c.name = name
-	}
+func WithClientStateMachineName(name string) GenericApplier[*ClientStateMachine] {
+	return WrapGenericApplier(func(c *ClientStateMachine) { c.name = name })
 }
 
-func WithClientStateMachineExtension(contract ClientStateMachineContract) func(*ClientStateMachine) {
-	return func(c *ClientStateMachine) {
-		c.contract = contract
-	}
+func WithClientStateMachineExtension(contract ClientStateMachineContract) GenericApplier[*ClientStateMachine] {
+	return WrapGenericApplier(func(c *ClientStateMachine) { c.contract = contract })
 }
 
 func (s *ClientStateMachine) Send(args Args, kwArgs KWArgs) error {
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_ServerStateMachine.go b/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_ServerStateMachine.go
index 934511a8a28..ab54230b19e 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_ServerStateMachine.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_ServerStateMachine.go
@@ -37,28 +37,25 @@ type ServerStateMachine struct {
 	log zerolog.Logger
 }
 
-func NewServerStateMachine(localLog zerolog.Logger, opts ...func(*ServerStateMachine)) (*ServerStateMachine, error) {
+func NewServerStateMachine(localLog zerolog.Logger, options ...Option) (*ServerStateMachine, error) {
 	c := &ServerStateMachine{
 		log: localLog,
 	}
-	for _, opt := range opts {
-		opt(c)
-	}
+	ApplyAppliers(options, c)
+	optionsForParent := AddLeafTypeIfAbundant(options, c)
 	var err error
-	c.ServerContract, err = NewServer(localLog) // TODO: do we need to pass server id
+	c.ServerContract, err = NewServer(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating Server")
 	}
 	var init func()
-	c.StateMachineContract, init = NewStateMachine(localLog, c, WithStateMachineName(c.name))
+	c.StateMachineContract, init = NewStateMachine(localLog, c, Combine(options, WithStateMachineName(c.name))...)
 	init()
 	return c, nil
 }
 
-func WithServerStateMachineName(name string) func(*ServerStateMachine) {
-	return func(s *ServerStateMachine) {
-		s.name = name
-	}
+func WithServerStateMachineName(name string) GenericApplier[*ServerStateMachine] {
+	return WrapGenericApplier(func(s *ServerStateMachine) { s.name = name })
 }
 
 func (s *ServerStateMachine) Send(args Args, kwArgs KWArgs) error {
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_StateMachine.go b/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_StateMachine.go
index 4e013a23092..ce81f493562 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_StateMachine.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_StateMachine.go
@@ -109,6 +109,8 @@ type stateMachine struct {
 	currentState           State
 	transactionLog         []TransactionLogEntry
 
+	_leafName string
+
 	log zerolog.Logger
 }
 
@@ -124,15 +126,14 @@ func (t TransactionLogEntry) String() string {
 var _ StateMachineContract = (*stateMachine)(nil)
 
 // NewStateMachine creates a new state machine. Make sure to call the init function (Init must be called after a new (can't be done in constructor as initialization is then not yet finished))
-func NewStateMachine(localLog zerolog.Logger, requirements StateMachineRequirements, opts ...func(machine *stateMachine)) (sm StateMachineContract, init func()) {
+func NewStateMachine(localLog zerolog.Logger, requirements StateMachineRequirements, options ...Option) (sm StateMachineContract, init func()) {
 	s := &stateMachine{
 		requirements: requirements,
 
 		log: localLog,
 	}
-	for _, opt := range opts {
-		opt(s)
-	}
+	ApplyAppliers(options, s)
+	s._leafName = ExtractLeafName(options, StructName())
 	if _debug != nil {
 		_debug("__init__(%s)", s.name)
 	}
@@ -171,55 +172,41 @@ func NewStateMachine(localLog zerolog.Logger, requirements StateMachineRequireme
 
 		s.transitionQueue = make(chan PDU, 100)
 
-		s.stateTimeoutTask = NewTimeoutTask(s.StateTimeout, NoArgs, NoKWArgs(), nil)
+		s.stateTimeoutTask = NewTimeoutTask(s.StateTimeout, NoArgs, NoKWArgs())
 
 		if s.timeout != 0 {
 			s.timeoutState = s.NewState("state machine timeout").Fail("")
-			s.timeoutTask = NewTimeoutTask(s.StateMachineTimeout, NoArgs, NoKWArgs(), s.stateMachineTimeout)
+			s.timeoutTask = NewTimeoutTask(s.StateMachineTimeout, NoArgs, NoKWArgs(), WithTaskTime(*s.stateMachineTimeout))
 		}
 	}
 }
 
-func WithStateMachineName(name string) func(stateMachine *stateMachine) {
-	return func(stateMachine *stateMachine) {
-		stateMachine.name = name
-	}
+func WithStateMachineName(name string) GenericApplier[*stateMachine] {
+	return WrapGenericApplier(func(stateMachine *stateMachine) { stateMachine.name = name })
 }
 
-func WithStateMachineStateInterceptor(interceptor StateInterceptor) func(stateMachine *stateMachine) {
-	return func(stateMachine *stateMachine) {
-		stateMachine.interceptor = interceptor
-	}
+func WithStateMachineStateInterceptor(interceptor StateInterceptor) GenericApplier[*stateMachine] {
+	return WrapGenericApplier(func(stateMachine *stateMachine) { stateMachine.interceptor = interceptor })
 }
 
-func WithStateMachineTimeout(timeout time.Duration) func(stateMachine *stateMachine) {
-	return func(stateMachine *stateMachine) {
-		stateMachine.timeout = timeout
-	}
+func WithStateMachineTimeout(timeout time.Duration) GenericApplier[*stateMachine] {
+	return WrapGenericApplier(func(stateMachine *stateMachine) { stateMachine.timeout = timeout })
 }
 
-func WithStateMachineStartState(startState State) func(stateMachine *stateMachine) {
-	return func(stateMachine *stateMachine) {
-		stateMachine.startState = startState
-	}
+func WithStateMachineStartState(startState State) GenericApplier[*stateMachine] {
+	return WrapGenericApplier(func(stateMachine *stateMachine) { stateMachine.startState = startState })
 }
 
-func WithStateMachineUnexpectedReceiveState(unexpectedReceiveState State) func(stateMachine *stateMachine) {
-	return func(stateMachine *stateMachine) {
-		stateMachine.unexpectedReceiveState = unexpectedReceiveState
-	}
+func WithStateMachineUnexpectedReceiveState(unexpectedReceiveState State) GenericApplier[*stateMachine] {
+	return WrapGenericApplier(func(stateMachine *stateMachine) { stateMachine.unexpectedReceiveState = unexpectedReceiveState })
 }
 
-func WithStateMachineMachineGroup(machineGroup *StateMachineGroup) func(stateMachine *stateMachine) {
-	return func(stateMachine *stateMachine) {
-		stateMachine.machineGroup = machineGroup
-	}
+func WithStateMachineMachineGroup(machineGroup *StateMachineGroup) GenericApplier[*stateMachine] {
+	return WrapGenericApplier(func(stateMachine *stateMachine) { stateMachine.machineGroup = machineGroup })
 }
 
-func WithStateMachineStateDecorator(stateDecorator func(state State) State) func(stateMachine *stateMachine) {
-	return func(stateMachine *stateMachine) {
-		stateMachine.stateDecorator = stateDecorator
-	}
+func WithStateMachineStateDecorator(stateDecorator func(state State) State) GenericApplier[*stateMachine] {
+	return WrapGenericApplier(func(stateMachine *stateMachine) { stateMachine.stateDecorator = stateDecorator })
 }
 
 func (s *stateMachine) getStateTimeoutTask() *TimeoutTask {
@@ -869,7 +856,7 @@ func (s *stateMachine) AlternateString() (string, bool) {
 			stateText += " " + s.currentState.String()
 		}
 
-		return fmt.Sprintf("<%s(%s) %s at %p>", TypeName(s.requirements), s.name, stateText, s), true
+		return fmt.Sprintf("<%s(%s) %s at %p>", s._leafName, s.name, stateText, s), true
 	}
 	return "", false
 }
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_TimeoutTask.go b/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_TimeoutTask.go
index 9679db20cd2..5a433dd8616 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_TimeoutTask.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_TimeoutTask.go
@@ -21,7 +21,6 @@ package state_machine
 
 import (
 	"fmt"
-	"time"
 
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/comp"
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/task"
@@ -36,17 +35,19 @@ type TimeoutTask struct {
 	kwArgs KWArgs
 }
 
-func NewTimeoutTask(fn GenericFunction, args Args, kwArgs KWArgs, when *time.Time) *TimeoutTask {
+func NewTimeoutTask(fn GenericFunction, args Args, kwArgs KWArgs, options ...Option) *TimeoutTask {
 	if _debug != nil {
 		_debug("__init__ %r %r %r", fn, args, kwArgs)
 	}
-	_task := &TimeoutTask{
+	t := &TimeoutTask{
 		fn:     fn,
 		args:   args,
 		kwArgs: kwArgs,
 	}
-	_task.OneShotTask = NewOneShotTask(_task, when)
-	return _task
+	ApplyAppliers(options, t)
+	optionsForParent := AddLeafTypeIfAbundant(options, t)
+	t.OneShotTask = NewOneShotTask(t, optionsForParent...)
+	return t
 }
 
 func (t *TimeoutTask) ProcessTask() error {
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_stateMachine_plc4xgen.go b/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_stateMachine_plc4xgen.go
index d80fadeef57..0f1257af973 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_stateMachine_plc4xgen.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/state_machine/state_machine_stateMachine_plc4xgen.go
@@ -179,6 +179,10 @@ func (d *stateMachine) SerializeWithWriteBuffer(ctx context.Context, writeBuffer
 	if err := writeBuffer.PopContext("transactionLog", utils.WithRenderAsList(true)); err != nil {
 		return err
 	}
+
+	if err := writeBuffer.WriteString("_leafName", uint32(len(d._leafName)*8), d._leafName); err != nil {
+		return err
+	}
 	if err := writeBuffer.PopContext("stateMachine"); err != nil {
 		return err
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPBBMDApplication.go b/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPBBMDApplication.go
index 7be5836a58b..fa39249a0b0 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPBBMDApplication.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPBBMDApplication.go
@@ -82,7 +82,7 @@ func NewBIPBBMDApplication(localLog zerolog.Logger, address string, vlan *IPNetw
 	}
 
 	// continue with initialization
-	b.Application, err = NewApplication(localLog, WithApplicationLocalDeviceObject(localDevice.LocalDeviceObject)) //TODO: this is a indirection that wasn't intended... we don't use the annotation yet so that might be fine
+	b.Application, err = NewApplication(localLog, WithApplicationLocalDeviceObject(localDevice))
 	if err != nil {
 		return nil, errors.Wrap(err, "error building application")
 	}
@@ -95,13 +95,15 @@ func NewBIPBBMDApplication(localLog zerolog.Logger, address string, vlan *IPNetw
 
 	// pass the device object to the state machine access point so it
 	// can know if it should support segmentation
-	// the segmentation state machines need access to the same device
-	// information cache as the application
-	b.smap, err = NewStateMachineAccessPoint(localLog, localDevice.LocalDeviceObject, WithStateMachineAccessPointDeviceInfoCache(b.GetDeviceInfoCache())) //TODO: this is a indirection that wasn't intended... we don't use the annotation yet so that might be fine
+	b.smap, err = NewStateMachineAccessPoint(localLog, localDevice)
 	if err != nil {
 		return nil, errors.Wrap(err, "error building state machine access point")
 	}
 
+	// the segmentation state machines need access to the same device
+	// information cache as the application
+	b.smap.SetDeviceInfoCache(b.GetDeviceInfoCache())
+
 	// a network service access point will be needed
 	b.nsap, err = NewNetworkServiceAccessPoint(localLog)
 	if err != nil {
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPBBMDStateMachine.go b/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPBBMDStateMachine.go
index dcf4ea16b72..a6e9e8f396e 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPBBMDStateMachine.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPBBMDStateMachine.go
@@ -53,7 +53,7 @@ func NewBIPBBMDStateMachine(localLog zerolog.Logger, address string, vlan *IPNet
 		_debug("__init__ %r %r", address, vlan)
 	}
 	var err error
-	b.ClientStateMachine, err = NewClientStateMachine(localLog, WithClientStateMachineName(address), WithClientStateMachineExtension(b))
+	b.ClientStateMachine, err = NewClientStateMachine(localLog, WithClientStateMachineName(address), WithClientStateMachineExtension(b), WithLeafType(b))
 	if err != nil {
 		return nil, errors.New("error building client state machine")
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPForeignStateMachine.go b/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPForeignStateMachine.go
index 339008423ee..dc5912e6eff 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPForeignStateMachine.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPForeignStateMachine.go
@@ -53,7 +53,7 @@ func NewBIPForeignStateMachine(localLog zerolog.Logger, address string, vlan *IP
 		_debug("__init__ %s %r", address, vlan)
 	}
 	var err error
-	b.ClientStateMachine, err = NewClientStateMachine(localLog, WithClientStateMachineName(address), WithClientStateMachineExtension(b))
+	b.ClientStateMachine, err = NewClientStateMachine(localLog, WithClientStateMachineName(address), WithClientStateMachineExtension(b), WithLeafType(b))
 	if err != nil {
 		return nil, errors.New("error building client state machine")
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPSimpleApplicationLayerStateMachine.go b/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPSimpleApplicationLayerStateMachine.go
index 6fd99d7cf36..52ce0274d4d 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPSimpleApplicationLayerStateMachine.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPSimpleApplicationLayerStateMachine.go
@@ -81,7 +81,7 @@ func NewBIPSimpleApplicationLayerStateMachine(localLog zerolog.Logger, address s
 	if err != nil {
 		return nil, errors.Wrap(err, "error building application")
 	}
-	b.ClientStateMachine, err = NewClientStateMachine(localLog, WithClientStateMachineName(b.name), WithClientStateMachineExtension(b))
+	b.ClientStateMachine, err = NewClientStateMachine(localLog, WithClientStateMachineName(b.name), WithClientStateMachineExtension(b), WithLeafType(b))
 
 	// include a application decoder
 	b.asap, err = NewApplicationServiceAccessPoint(localLog)
@@ -91,13 +91,15 @@ func NewBIPSimpleApplicationLayerStateMachine(localLog zerolog.Logger, address s
 
 	// pass the device object to the state machine access point so it
 	// can know if it should support segmentation
-	// the segmentation state machines need access to the same device
-	// information cache as the application
-	b.smap, err = NewStateMachineAccessPoint(localLog, localDevice.LocalDeviceObject, WithStateMachineAccessPointDeviceInfoCache(NewDeviceInfoCache(localLog))) //TODO: this is a indirection that wasn't intended... we don't use the annotation yet so that might be fine
+	b.smap, err = NewStateMachineAccessPoint(localLog, localDevice)
 	if err != nil {
 		return nil, errors.Wrap(err, "error building state machine access point")
 	}
 
+	// the segmentation state machines need access to the same device
+	// information cache as the application
+	b.smap.SetDeviceInfoCache(NewDeviceInfoCache(localLog))
+
 	// a network service access point will be needed
 	b.nsap, err = NewNetworkServiceAccessPoint(localLog)
 	if err != nil {
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPSimpleStateMachine.go b/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPSimpleStateMachine.go
index 8ca3e29e147..1ccfa0e97ab 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPSimpleStateMachine.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPSimpleStateMachine.go
@@ -49,7 +49,7 @@ func NewBIPSimpleStateMachine(localLog zerolog.Logger, netstring string, vlan *I
 		log: localLog,
 	}
 	var err error
-	b.ClientStateMachine, err = NewClientStateMachine(localLog, WithClientStateMachineName(netstring), WithClientStateMachineExtension(b))
+	b.ClientStateMachine, err = NewClientStateMachine(localLog, WithClientStateMachineName(netstring), WithClientStateMachineExtension(b), WithLeafType(b))
 	if err != nil {
 		return nil, errors.Wrap(err, "error building client state machine")
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPStateMachine.go b/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPStateMachine.go
index dba5c21a75a..ca2ca1d7f70 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPStateMachine.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_BIPStateMachine.go
@@ -50,7 +50,7 @@ func NewBIPStateMachine(localLog zerolog.Logger, address string, vlan *IPNetwork
 		_debug("__init__ %r %r", address, vlan)
 	}
 	var err error
-	b.ClientStateMachine, err = NewClientStateMachine(localLog, WithClientStateMachineName(address), WithClientStateMachineExtension(b))
+	b.ClientStateMachine, err = NewClientStateMachine(localLog, WithClientStateMachineName(address), WithClientStateMachineExtension(b), WithLeafType(b))
 	if err != nil {
 		return nil, errors.Wrap(err, "error building client state machine")
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_SnifferStateMachine.go b/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_SnifferStateMachine.go
index 4ba2502bbf5..40d458678f1 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_SnifferStateMachine.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/helpers_SnifferStateMachine.go
@@ -48,7 +48,7 @@ func NewSnifferStateMachine(localLog zerolog.Logger, address string, vlan *IPNet
 	if _debug != nil {
 		_debug("__init__ %r %r", address, vlan)
 	}
-	machine, err := NewClientStateMachine(localLog, WithClientStateMachineName(address), WithClientStateMachineExtension(s))
+	machine, err := NewClientStateMachine(localLog, WithClientStateMachineName(address), WithClientStateMachineExtension(s), WithLeafType(s))
 	if err != nil {
 		return nil, errors.Wrap(err, "error building client state machine")
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_ApplicationLayerStateMachine.go b/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_ApplicationLayerStateMachine.go
index ff15caa2dff..bdf7332e1ca 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_ApplicationLayerStateMachine.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_ApplicationLayerStateMachine.go
@@ -28,7 +28,6 @@ import (
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/appservice"
 	. "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"
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/tests/state_machine"
@@ -66,13 +65,11 @@ func NewApplicationLayerStateMachine(localLog zerolog.Logger, address string, vl
 	}
 
 	// build a local device object
-	localDevice := TestDeviceObject{
-		NewLocalDeviceObject(NoArgs,
-			NKW(KWObjectName, a.name,
-				KWObjectIdentifier, "device:"+address,
-				KWVendorIdentifier, 999,
-			)),
-	}
+	localDevice := NewTestDeviceObject(NoArgs,
+		NKW(KWObjectName, a.name,
+			KWObjectIdentifier, "device:"+address,
+			KWVendorIdentifier, 999,
+		))
 
 	if LogTestNetwork {
 		a.log.Debug().Stringer("address", a.address).Msg("address")
@@ -83,7 +80,12 @@ func NewApplicationLayerStateMachine(localLog zerolog.Logger, address string, vl
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating application service")
 	}
-	a.ClientStateMachine, err = NewClientStateMachine(a.log, WithClientStateMachineName(localDevice.GetObjectName()), WithClientStateMachineExtension(a))
+	a.ClientStateMachine, err = NewClientStateMachine(a.log,
+		WithClientStateMachineName(localDevice.GetObjectName()),
+		WithClientStateMachineExtension(a),
+		WithClientStateMachineName(a.name),
+		WithLeafType(a),
+	)
 	if err != nil {
 		return nil, errors.Wrap(err, "error building client state machine")
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_ApplicationNode.go b/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_ApplicationNode.go
index 35a611c2da2..5f243a08720 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_ApplicationNode.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_ApplicationNode.go
@@ -30,7 +30,6 @@ import (
 	. "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/debugging"
-	. "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"
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/service"
@@ -70,15 +69,13 @@ func NewApplicationNode(localLog zerolog.Logger, address string, vlan *Network)
 	}
 
 	// build a local device object
-	localDevice := &TestDeviceObject{
-		LocalDeviceObject: NewLocalDeviceObject(NoArgs,
-			NKW(
-				KWObjectName, a.name,
-				KWObjectIdentifier, "device:999",
-				KWVendorIdentifier, 999,
-			),
+	localDevice := NewTestDeviceObject(NoArgs,
+		NKW(
+			KWObjectName, a.name,
+			KWObjectIdentifier, "device:999",
+			KWVendorIdentifier, 999,
 		),
-	}
+	)
 
 	// continue with initialization
 	a.Application, err = NewApplication(localLog, WithApplicationLocalDeviceObject(localDevice))
@@ -99,13 +96,15 @@ func NewApplicationNode(localLog zerolog.Logger, address string, vlan *Network)
 
 	// pass the device object to the state machine access point so it
 	// can know if it should support segmentation
-	// the segmentation state machines need access to the same device
-	// information cache as the application
-	a.smap, err = NewStateMachineAccessPoint(localLog, localDevice.LocalDeviceObject, WithStateMachineAccessPointDeviceInfoCache(a.GetDeviceInfoCache())) //TODO: this is a indirection that wasn't intended... we don't use the annotation yet so that might be fine
+	a.smap, err = NewStateMachineAccessPoint(localLog, localDevice)
 	if err != nil {
 		return nil, errors.Wrap(err, "error building state machine access point")
 	}
 
+	// the segmentation state machines need access to the same device
+	// information cache as the application
+	a.smap.SetDeviceInfoCache(a.GetDeviceInfoCache())
+
 	// a network service access point will be needed
 	a.nsap, err = NewNetworkServiceAccessPoint(localLog)
 	if err != nil {
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_NetworkLayerStateMachine.go b/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_NetworkLayerStateMachine.go
index 87b002be709..7cd2c64f954 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_NetworkLayerStateMachine.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_NetworkLayerStateMachine.go
@@ -45,7 +45,7 @@ func NewNetworkLayerStateMachine(localLog zerolog.Logger, address string, vlan *
 		log: localLog,
 	}
 	var err error
-	n.ClientStateMachine, err = NewClientStateMachine(localLog, WithClientStateMachineName(address), WithClientStateMachineExtension(n))
+	n.ClientStateMachine, err = NewClientStateMachine(localLog, WithClientStateMachineName(address), WithClientStateMachineExtension(n), WithLeafType(n))
 	if err != nil {
 		return nil, errors.Wrap(err, "error building client state machine")
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_RouterStaterMachine.go b/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_RouterStaterMachine.go
index 27ddc431bb6..e7944e8ee6d 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_RouterStaterMachine.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_RouterStaterMachine.go
@@ -32,15 +32,17 @@ type RouterStateMachine struct {
 	StateMachineContract
 }
 
-func NewRouterStateMachine(localLog zerolog.Logger) (*RouterStateMachine, error) {
+func NewRouterStateMachine(localLog zerolog.Logger, options ...Option) (*RouterStateMachine, error) {
 	r := &RouterStateMachine{}
+	ApplyAppliers(options, r)
+	optionsForParent := AddLeafTypeIfAbundant(options, r)
 	var err error
 	r.RouterNode, err = NewRouterNode(localLog)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating router node")
 	}
 	var initFunc func()
-	r.StateMachineContract, initFunc = NewStateMachine(localLog, r)
+	r.StateMachineContract, initFunc = NewStateMachine(localLog, r, optionsForParent...)
 	initFunc()
 	if !LogTestNetwork {
 		r.log = zerolog.Nop()
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_SnifferStateMachine.go b/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_SnifferStateMachine.go
index d4760d2426c..1de82b24bf8 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_SnifferStateMachine.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_SnifferStateMachine.go
@@ -44,7 +44,7 @@ func NewSnifferStateMachine(localLog zerolog.Logger, address string, vlan *Netwo
 		log: localLog,
 	}
 	var err error
-	s.ClientStateMachine, err = NewClientStateMachine(s.log, WithClientStateMachineName(address), WithClientStateMachineExtension(s))
+	s.ClientStateMachine, err = NewClientStateMachine(s.log, WithClientStateMachineName(address), WithClientStateMachineExtension(s), WithLeafType(s))
 	if err != nil {
 		return nil, errors.Wrap(err, "error building client state machine")
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_TestDeviceObject.go b/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_TestDeviceObject.go
index 693e903a20b..98e5a863330 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_TestDeviceObject.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/test_network/helpers_TestDeviceObject.go
@@ -19,8 +19,30 @@
 
 package test_network
 
-import "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/local/device"
+import (
+	"fmt"
+
+	"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/local/device"
+)
 
 type TestDeviceObject struct {
 	device.LocalDeviceObject
+	*DefaultRFormatter
+}
+
+func NewTestDeviceObject(args comp.Args, kwArgs comp.KWArgs) *TestDeviceObject {
+	return &TestDeviceObject{
+		LocalDeviceObject: device.NewLocalDeviceObject(args, kwArgs),
+		DefaultRFormatter: NewDefaultRFormatter(),
+	}
+}
+
+func (t *TestDeviceObject) Format(s fmt.State, v rune) {
+	t.DefaultRFormatter.Format(s, v)
+}
+
+func (t *TestDeviceObject) String() string {
+	return t.DefaultRFormatter.String()
 }
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/test_segmentation/test_1_test.go b/plc4go/internal/bacnetip/bacgopes/tests/test_segmentation/test_1_test.go
index e42eeb5d361..9a204b627c0 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/test_segmentation/test_1_test.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/test_segmentation/test_1_test.go
@@ -53,10 +53,12 @@ type _NetworkServiceElement struct {
 	*NetworkServiceElement
 }
 
-func new_NetworkServiceElement(localLog zerolog.Logger) (*_NetworkServiceElement, error) {
+func new_NetworkServiceElement(localLog zerolog.Logger, options ...Option) (*_NetworkServiceElement, error) {
 	n := &_NetworkServiceElement{}
+	ApplyAppliers(options, n)
+	optionsForParent := AddLeafTypeIfAbundant(options, n)
 	var err error
-	n.NetworkServiceElement, err = NewNetworkServiceElement(localLog, WithNetworkServiceElementStartupDisabled(true))
+	n.NetworkServiceElement, err = NewNetworkServiceElement(localLog, Combine(optionsForParent, WithNetworkServiceElementStartupDisabled(true))...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating network service element")
 	}
@@ -247,13 +249,12 @@ type ApplicationStateMachine struct {
 	log zerolog.Logger
 }
 
-func NewApplicationStateMachine(localLog zerolog.Logger, localDevice LocalDeviceObject, vlan *Network, opts ...func(*ApplicationStateMachine)) (*ApplicationStateMachine, error) {
+func NewApplicationStateMachine(localLog zerolog.Logger, localDevice LocalDeviceObject, vlan *Network, options ...Option) (*ApplicationStateMachine, error) {
 	a := &ApplicationStateMachine{
 		log: localLog,
 	}
-	for _, opt := range opts {
-		opt(a)
-	}
+	ApplyAppliers(options, a)
+	optionsForParent := AddLeafTypeIfAbundant(options, a)
 	// build and address and save it
 	_, instance := ObjectIdentifierStringToTuple(localDevice.GetObjectIdentifier())
 	var err error
@@ -264,16 +265,16 @@ func NewApplicationStateMachine(localLog zerolog.Logger, localDevice LocalDevice
 	a.log.Debug().Stringer("address", a.address).Msg("address")
 
 	// continue with initialization
-	a.Application, err = NewApplication(a.log, WithApplicationLocalDeviceObject(localDevice))
+	a.Application, err = NewApplication(a.log, Combine(optionsForParent, WithApplicationLocalDeviceObject(localDevice))...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating application io controller")
 	}
 	var init func()
-	a.StateMachineContract, init = NewStateMachine(a.log, a, WithStateMachineName(localDevice.GetObjectName()))
+	a.StateMachineContract, init = NewStateMachine(a.log, a, Combine(optionsForParent, WithStateMachineName(localDevice.GetObjectName()))...)
 	init()
 
 	// include a application decoder
-	a.asap, err = NewApplicationServiceAccessPoint(a.log)
+	a.asap, err = NewApplicationServiceAccessPoint(a.log, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating application service access point")
 	}
@@ -284,19 +285,19 @@ func NewApplicationStateMachine(localLog zerolog.Logger, localDevice LocalDevice
 	// the segmentation state machines need access to the same device
 	// information cache as the application
 	deviceInfoCache := a.GetDeviceInfoCache()
-	a.smap, err = NewStateMachineAccessPoint(a.log, localDevice, WithStateMachineAccessPointDeviceInfoCache(deviceInfoCache))
+	a.smap, err = NewStateMachineAccessPoint(a.log, localDevice, Combine(options, WithStateMachineAccessPointDeviceInfoCache(deviceInfoCache))...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating state machine access point")
 	}
 
 	// a network service access point will be needed
-	a.nsap, err = NewNetworkServiceAccessPoint(a.log)
+	a.nsap, err = NewNetworkServiceAccessPoint(a.log, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating network service access point")
 	}
 
 	// give the NSAP a generic network layer service element
-	a.nse, err = new_NetworkServiceElement(a.log)
+	a.nse, err = new_NetworkServiceElement(a.log, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating network service element")
 	}
@@ -312,7 +313,7 @@ func NewApplicationStateMachine(localLog zerolog.Logger, localDevice LocalDevice
 	}
 
 	// create a node, added to the network
-	a.node, err = NewNode(a.log, a.address, WithNodeLan(vlan))
+	a.node, err = NewNode(a.log, a.address, Combine(options, WithNodeLan(vlan))...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating node")
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/test_service/helpers.go b/plc4go/internal/bacnetip/bacgopes/tests/test_service/helpers.go
index b991fa5bd0c..219060a7001 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/test_service/helpers.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/test_service/helpers.go
@@ -48,10 +48,12 @@ type _NetworkServiceElement struct {
 	*NetworkServiceElement
 }
 
-func new_NetworkServiceElement(localLog zerolog.Logger) (*_NetworkServiceElement, error) {
+func new_NetworkServiceElement(localLog zerolog.Logger, options ...Option) (*_NetworkServiceElement, error) {
 	n := &_NetworkServiceElement{}
+	ApplyAppliers(options, n)
+	optionsForParent := AddLeafTypeIfAbundant(options, n)
 	var err error
-	n.NetworkServiceElement, err = NewNetworkServiceElement(localLog, WithNetworkServiceElementStartupDisabled(true))
+	n.NetworkServiceElement, err = NewNetworkServiceElement(localLog, Combine(optionsForParent, WithNetworkServiceElementStartupDisabled(true))...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating network service element")
 	}
@@ -270,16 +272,18 @@ type SnifferStateMachine struct {
 	log zerolog.Logger
 }
 
-func NewSnifferStateMachine(localLog zerolog.Logger, vlan *Network) (*SnifferStateMachine, error) {
+func NewSnifferStateMachine(localLog zerolog.Logger, vlan *Network, options ...Option) (*SnifferStateMachine, error) {
 	s := &SnifferStateMachine{
 		name: "sniffer",
 		log:  localLog,
 	}
+	ApplyAppliers(options, s)
+	optionsForParent := AddLeafTypeIfAbundant(options, s)
 	s.address, _ = NewAddress(NoArgs)
 
 	// continue with initialization
 	var err error
-	s.ClientContract, err = NewClient(localLog)
+	s.ClientContract, err = NewClient(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating client")
 	}
@@ -288,7 +292,7 @@ func NewSnifferStateMachine(localLog zerolog.Logger, vlan *Network) (*SnifferSta
 	init()
 
 	// create a promiscuous node, added to the network
-	s.node, err = NewNode(localLog, s.address, WithNodeLan(vlan), WithNodePromiscuous(true))
+	s.node, err = NewNode(localLog, s.address, Combine(options, WithNodeLan(vlan), WithNodePromiscuous(true))...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating node")
 	}
@@ -358,10 +362,12 @@ type ApplicationStateMachine struct {
 	log zerolog.Logger
 }
 
-func NewApplicationStateMachine(localLog zerolog.Logger, localDevice LocalDeviceObject, vlan *Network) (*ApplicationStateMachine, error) {
+func NewApplicationStateMachine(localLog zerolog.Logger, localDevice LocalDeviceObject, vlan *Network, options ...Option) (*ApplicationStateMachine, error) {
 	a := &ApplicationStateMachine{
 		log: localLog,
 	}
+	ApplyAppliers(options, a)
+	optionsForParent := AddLeafTypeIfAbundant(options, a)
 
 	// build and address and save it
 	_, instance := ObjectIdentifierStringToTuple(localDevice.GetObjectIdentifier())
@@ -373,16 +379,16 @@ func NewApplicationStateMachine(localLog zerolog.Logger, localDevice LocalDevice
 	a.log.Debug().Stringer("address", a.address).Msg("address")
 
 	// continue with initialization
-	a.ApplicationIOController, err = NewApplicationIOController(a.log, localDevice)
+	a.ApplicationIOController, err = NewApplicationIOController(a.log, Combine(optionsForParent, WithApplicationLocalDeviceObject(localDevice))...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating application io controller")
 	}
 	var init func()
-	a.StateMachineContract, init = NewStateMachine(a.log, a, WithStateMachineName(localDevice.GetObjectName()))
+	a.StateMachineContract, init = NewStateMachine(a.log, a, Combine(optionsForParent, WithStateMachineName(localDevice.GetObjectName()))...)
 	init()
 
 	// include a application decoder
-	a.asap, err = NewApplicationServiceAccessPoint(a.log)
+	a.asap, err = NewApplicationServiceAccessPoint(a.log, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating application service access point")
 	}
@@ -393,19 +399,19 @@ func NewApplicationStateMachine(localLog zerolog.Logger, localDevice LocalDevice
 	// the segmentation state machines need access to the same device
 	// information cache as the application
 	deviceInfoCache := a.GetDeviceInfoCache()
-	a.smap, err = NewStateMachineAccessPoint(a.log, localDevice, WithStateMachineAccessPointDeviceInfoCache(deviceInfoCache))
+	a.smap, err = NewStateMachineAccessPoint(a.log, localDevice, Combine(options, WithStateMachineAccessPointDeviceInfoCache(deviceInfoCache))...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating state machine access point")
 	}
 
 	// a network service access point will be needed
-	a.nsap, err = NewNetworkServiceAccessPoint(a.log)
+	a.nsap, err = NewNetworkServiceAccessPoint(a.log, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating network service access point")
 	}
 
 	// give the NSAP a generic network layer service element
-	a.nse, err = new_NetworkServiceElement(a.log)
+	a.nse, err = new_NetworkServiceElement(a.log, options...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating network service element")
 	}
@@ -421,7 +427,7 @@ func NewApplicationStateMachine(localLog zerolog.Logger, localDevice LocalDevice
 	}
 
 	// create a node, added to the network
-	a.node, err = NewNode(a.log, a.address, WithNodeLan(vlan))
+	a.node, err = NewNode(a.log, a.address, Combine(options, WithNodeLan(vlan))...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating node")
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedApplicationServiceElement.go b/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedApplicationServiceElement.go
index 21018178f2d..d172e931a62 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedApplicationServiceElement.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedApplicationServiceElement.go
@@ -61,29 +61,26 @@ type TrappedApplicationServiceElement struct {
 	responseSent         PDU
 	confirmationReceived PDU
 
-	elementID int // TODO: temporary where from?????????
-
-	// args
-	argAseId *int //TODO: hook up
-
 	log zerolog.Logger
 }
 
 var _ ApplicationServiceElement = (*TrappedApplicationServiceElement)(nil)
 
-func NewTrappedApplicationServiceElement(localLog zerolog.Logger, requirements TrappedApplicationServiceElementRequirements) (*TrappedApplicationServiceElement, error) {
+func NewTrappedApplicationServiceElement(localLog zerolog.Logger, requirements TrappedApplicationServiceElementRequirements, options ...Option) (*TrappedApplicationServiceElement, error) {
 	t := &TrappedApplicationServiceElement{
 		requirements: requirements,
 		log:          localLog,
 	}
-	if _debug != nil {
-		_debug("__init__(%s)", t.argAseId)
-	}
+	ApplyAppliers(options, t)
+	optionsForParent := AddLeafTypeIfAbundant(options, t)
 	var err error
-	t.ApplicationServiceElementContract, err = NewApplicationServiceElement(localLog)
+	t.ApplicationServiceElementContract, err = NewApplicationServiceElement(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating SAP")
 	}
+	if _debug != nil {
+		_debug("__init__(%s)", t.GetElementId())
+	}
 	return t, nil
 }
 
@@ -111,7 +108,7 @@ func (s *TrappedApplicationServiceElement) Request(args Args, kwArgs KWArgs) err
 	s.log.Debug().Stringer("args", args).Stringer("kwArgs", kwArgs).Msg("Request")
 	pdu := GA[PDU](args, 0)
 	if _debug != nil {
-		_debug("request(%s) %r", s.elementID, pdu)
+		_debug("request(%s) %r", s.GetElementId(), pdu)
 	}
 	s.requestSent = pdu
 	return s.ApplicationServiceElementContract.Request(args, kwArgs)
@@ -121,7 +118,7 @@ func (s *TrappedApplicationServiceElement) Indication(args Args, kwArgs KWArgs)
 	s.log.Debug().Stringer("args", args).Stringer("kwArgs", kwArgs).Msg("Indication")
 	pdu := GA[PDU](args, 0)
 	if _debug != nil {
-		_debug("indication(%s) %r", s.elementID, pdu)
+		_debug("indication(%s) %r", s.GetElementId(), pdu)
 	}
 	s.indicationReceived = pdu
 	return s.requirements.Indication(args, kwArgs)
@@ -131,7 +128,7 @@ func (s *TrappedApplicationServiceElement) Response(args Args, kwArgs KWArgs) er
 	s.log.Debug().Stringer("args", args).Stringer("kwArgs", kwArgs).Msg("Response")
 	pdu := GA[PDU](args, 0)
 	if _debug != nil {
-		_debug("response(%s) %r", s.elementID, pdu)
+		_debug("response(%s) %r", s.GetElementId(), pdu)
 	}
 	s.responseSent = pdu
 	return s.ApplicationServiceElementContract.Response(args, kwArgs)
@@ -141,7 +138,7 @@ func (s *TrappedApplicationServiceElement) Confirmation(args Args, kwArgs KWArgs
 	s.log.Debug().Stringer("args", args).Stringer("kwArgs", kwArgs).Msg("Confirmation")
 	pdu := GA[PDU](args, 0)
 	if _debug != nil {
-		_debug("confirmation(%s) %r", s.elementID, pdu)
+		_debug("confirmation(%s) %r", s.GetElementId(), pdu)
 	}
 	s.confirmationReceived = pdu
 	return s.requirements.Confirmation(args, kwArgs)
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedClient.go b/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedClient.go
index ecbd5e77c57..70e3bd8f7e6 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedClient.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedClient.go
@@ -49,19 +49,18 @@ type TrappedClient struct {
 	log zerolog.Logger
 }
 
-func NewTrappedClient(localLog zerolog.Logger, opts ...func(*TrappedClient)) (*TrappedClient, error) {
+func NewTrappedClient(localLog zerolog.Logger, options ...Option) (*TrappedClient, error) {
 	t := &TrappedClient{
 		log: localLog,
 	}
 	t.TrappedClientContract = t
-	for _, opt := range opts {
-		opt(t)
-	}
+	ApplyAppliers(options, t)
+	optionsForParent := AddLeafTypeIfAbundant(options, t)
 	if _debug != nil {
 		_debug("__init__")
 	}
 	var err error
-	t.ClientContract, err = NewClient(localLog) // TODO: do we need to pass client id?
+	t.ClientContract, err = NewClient(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error building client")
 	}
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedClientStateMachine.go b/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedClientStateMachine.go
index cfc6e0607c4..7bc8c75f135 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedClientStateMachine.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedClientStateMachine.go
@@ -34,17 +34,19 @@ type TrappedClientStateMachine struct {
 	log zerolog.Logger
 }
 
-func NewTrappedClientStateMachine(localLog zerolog.Logger) (*TrappedClientStateMachine, error) {
+func NewTrappedClientStateMachine(localLog zerolog.Logger, options ...Option) (*TrappedClientStateMachine, error) {
 	t := &TrappedClientStateMachine{log: localLog}
+	ApplyAppliers(options, t)
+	optionsForParent := AddLeafTypeIfAbundant(options, t)
 	if _debug != nil {
 		_debug("__init__")
 	}
 	var err error
-	t.TrappedServer, err = NewTrappedServer(localLog, WithTrappedServerContract(t))
+	t.TrappedServer, err = NewTrappedServer(localLog, Combine(optionsForParent, WithTrappedServerContract(t))...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error building trapped server")
 	}
-	t.TrappedStateMachine = NewTrappedStateMachine(localLog)
+	t.TrappedStateMachine = NewTrappedStateMachine(localLog, optionsForParent...)
 	return t, nil
 }
 
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedServer.go b/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedServer.go
index f961a576e97..ef92e091bf2 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedServer.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedServer.go
@@ -49,29 +49,26 @@ type TrappedServer struct {
 	log zerolog.Logger
 }
 
-func NewTrappedServer(localLog zerolog.Logger, opts ...func(*TrappedServer)) (*TrappedServer, error) {
+func NewTrappedServer(localLog zerolog.Logger, options ...Option) (*TrappedServer, error) {
 	t := &TrappedServer{
 		log: localLog,
 	}
 	t.TrappedServerContract = t
-	for _, opt := range opts {
-		opt(t)
-	}
+	ApplyAppliers(options, t)
+	optionsForParent := AddLeafTypeIfAbundant(options, t)
 	if _debug != nil {
 		_debug("__init__")
 	}
 	var err error
-	t.ServerContract, err = NewServer(localLog) // TODO: do we need to pass server id
+	t.ServerContract, err = NewServer(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error building server")
 	}
 	return t, nil
 }
 
-func WithTrappedServerContract(trappedServerContract TrappedServerContract) func(*TrappedServer) {
-	return func(t *TrappedServer) {
-		t.TrappedServerContract = trappedServerContract
-	}
+func WithTrappedServerContract(trappedServerContract TrappedServerContract) GenericApplier[*TrappedServer] {
+	return WrapGenericApplier(func(t *TrappedServer) { t.TrappedServerContract = trappedServerContract })
 }
 
 func (t *TrappedServer) GetIndicationReceived() PDU {
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedServiceAccessPoint.go b/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedServiceAccessPoint.go
index 9db02daaa13..a4a69dc68b4 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedServiceAccessPoint.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedServiceAccessPoint.go
@@ -61,27 +61,24 @@ type TrappedServiceAccessPoint struct {
 	sapResponseSent         PDU
 	sapConfirmationReceived PDU
 
-	serviceID int // TODO: temporary where from?????????
-
-	// args
-	argSapId *int //TODO: hook up
-
 	log zerolog.Logger
 }
 
-func NewTrappedServiceAccessPoint(localLog zerolog.Logger, requirements TrappedServiceAccessPointRequirements) (*TrappedServiceAccessPoint, error) {
+func NewTrappedServiceAccessPoint(localLog zerolog.Logger, requirements TrappedServiceAccessPointRequirements, options ...Option) (*TrappedServiceAccessPoint, error) {
 	t := &TrappedServiceAccessPoint{
 		requirements: requirements,
 		log:          localLog,
 	}
-	if _debug != nil {
-		_debug("__init__(%s)", t.argSapId)
-	}
+	ApplyAppliers(options, t)
+	optionsForParent := AddLeafTypeIfAbundant(options, t)
 	var err error
-	t.ServiceAccessPointContract, err = NewServiceAccessPoint(localLog)
+	t.ServiceAccessPointContract, err = NewServiceAccessPoint(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating SAP")
 	}
+	if _debug != nil {
+		_debug("__init__(%s)", t.GetServiceID())
+	}
 	return t, nil
 }
 
@@ -105,7 +102,7 @@ func (s *TrappedServiceAccessPoint) SapRequest(args Args, kwArgs KWArgs) error {
 	s.log.Debug().Stringer("args", args).Stringer("kwArgs", kwArgs).Msg("SapRequest")
 	pdu := GA[PDU](args, 0)
 	if _debug != nil {
-		_debug("sap_request(%s) %r", s.serviceID, pdu)
+		_debug("sap_request(%s) %r", s.GetServiceID(), pdu)
 	}
 	s.sapRequestSent = pdu
 	return s.ServiceAccessPointContract.SapRequest(args, kwArgs)
@@ -115,7 +112,7 @@ func (s *TrappedServiceAccessPoint) SapIndication(args Args, kwArgs KWArgs) erro
 	s.log.Debug().Stringer("args", args).Stringer("kwArgs", kwArgs).Msg("SapIndication")
 	pdu := GA[PDU](args, 0)
 	if _debug != nil {
-		_debug("sap_indication(%s) %r", s.serviceID, pdu)
+		_debug("sap_indication(%s) %r", s.GetServiceID(), pdu)
 	}
 	s.sapIndicationReceived = pdu
 	return s.requirements.SapIndication(args, kwArgs)
@@ -125,7 +122,7 @@ func (s *TrappedServiceAccessPoint) SapResponse(args Args, kwArgs KWArgs) error
 	s.log.Debug().Stringer("args", args).Stringer("kwArgs", kwArgs).Msg("SapResponse")
 	pdu := GA[PDU](args, 0)
 	if _debug != nil {
-		_debug("sap_response(%s) %r", s.serviceID, pdu)
+		_debug("sap_response(%s) %r", s.GetServiceID(), pdu)
 	}
 	s.sapResponseSent = pdu
 	return s.ServiceAccessPointContract.SapResponse(args, kwArgs)
@@ -135,7 +132,7 @@ func (s *TrappedServiceAccessPoint) SapConfirmation(args Args, kwArgs KWArgs) er
 	s.log.Debug().Stringer("args", args).Stringer("kwArgs", kwArgs).Msg("SapConfirmation")
 	pdu := GA[PDU](args, 0)
 	if _debug != nil {
-		_debug("sap_confirmation(%s) %r", s.serviceID, pdu)
+		_debug("sap_confirmation(%s) %r", s.GetServiceID(), pdu)
 	}
 	s.sapConfirmationReceived = pdu
 	return s.requirements.SapConfirmation(args, kwArgs)
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedStateMachine.go b/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedStateMachine.go
index 644ea4446ac..be3a62940b0 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedStateMachine.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/trapped_classes/trapped_classes_TrappedStateMachine.go
@@ -24,7 +24,7 @@ import (
 
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/comp"
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/pdu"
-	"github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/tests/state_machine"
+	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/tests/state_machine"
 )
 
 // TrappedStateMachine This class is a simple wrapper around the stateMachine class that keeps the
@@ -35,22 +35,24 @@ import (
 //	throw an exception.
 type TrappedStateMachine struct {
 	*Trapper
-	state_machine.StateMachineContract
+	StateMachineContract
 
 	sent PDU
 
 	log zerolog.Logger
 }
 
-func NewTrappedStateMachine(localLog zerolog.Logger) *TrappedStateMachine {
+func NewTrappedStateMachine(localLog zerolog.Logger, options ...Option) *TrappedStateMachine {
 	t := &TrappedStateMachine{
 		log: localLog,
 	}
+	ApplyAppliers(options, t)
+	optionsForParent := AddLeafTypeIfAbundant(options, t)
 	if _debug != nil {
 		_debug("__init__ %r", nil) //TODO: kwargs
 	}
 	var init func()
-	t.StateMachineContract, init = state_machine.NewStateMachine(localLog, t, state_machine.WithStateMachineStateInterceptor(t), state_machine.WithStateMachineStateDecorator(t.DecorateState))
+	t.StateMachineContract, init = NewStateMachine(localLog, t, Combine(optionsForParent, WithStateMachineStateInterceptor(t), WithStateMachineStateDecorator(t.DecorateState))...)
 	t.Trapper = NewTrapper(localLog, t.StateMachineContract)
 	init() // bit later so everything is set up
 	return t
@@ -92,6 +94,6 @@ func (t *TrappedStateMachine) UnexpectedReceive(pdu PDU) {
 	t.Trapper.UnexpectedReceive(pdu)
 }
 
-func (t *TrappedStateMachine) DecorateState(state state_machine.State) state_machine.State {
+func (t *TrappedStateMachine) DecorateState(state State) State {
 	return NewTrappedState(state, t.Trapper)
 }
diff --git a/plc4go/internal/bacnetip/bacgopes/udp/udp_UDPDirector.go b/plc4go/internal/bacnetip/bacgopes/udp/udp_UDPDirector.go
index 9bf6d341f5f..72dbea055a4 100644
--- a/plc4go/internal/bacnetip/bacgopes/udp/udp_UDPDirector.go
+++ b/plc4go/internal/bacnetip/bacgopes/udp/udp_UDPDirector.go
@@ -53,27 +53,20 @@ type UDPDirector struct {
 
 	wg sync.WaitGroup
 
-	// Pass through args
-	argTimeout *int                `ignore:"true"`
-	argSid     *int                `ignore:"true"`
-	argSapID   *int                `ignore:"true"`
-	argSap     *ServiceAccessPoint `ignore:"true"`
-
 	passLogToModel bool
 	log            zerolog.Logger
 }
 
-func NewUDPDirector(localLog zerolog.Logger, address AddressTuple[string, uint16], opts ...func(*UDPDirector)) (*UDPDirector, error) {
+func NewUDPDirector(localLog zerolog.Logger, address AddressTuple[string, uint16], options ...Option) (*UDPDirector, error) {
 	d := &UDPDirector{}
-	for _, opt := range opts {
-		opt(d)
-	}
+	ApplyAppliers(options, d)
+	optionsForParent := AddLeafTypeIfAbundant(options, d)
 	var err error
-	d.ServerContract, err = NewServer(localLog, OptionalOption2(d.argSid, ToPtr[ServerRequirements](d), WithServerSID))
+	d.ServerContract, err = NewServer(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating server")
 	}
-	d.ServiceAccessPointContract, err = NewServiceAccessPoint(localLog, OptionalOption2(d.argSapID, d.argSap, WithServiceAccessPointSapID))
+	d.ServiceAccessPointContract, err = NewServiceAccessPoint(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating service access point")
 	}
@@ -145,10 +138,8 @@ func NewUDPDirector(localLog zerolog.Logger, address AddressTuple[string, uint16
 	return d, nil
 }
 
-func WithUDPDirectorReuse(reuse bool) func(*UDPDirector) {
-	return func(d *UDPDirector) {
-		d.reuse = reuse
-	}
+func WithUDPDirectorReuse(reuse bool) GenericApplier[*UDPDirector] {
+	return WrapGenericApplier(func(d *UDPDirector) { d.reuse = reuse })
 }
 
 // AddActor adds an actor when a new one is connected
diff --git a/plc4go/internal/bacnetip/bacgopes/vlan/vlan_IPNetwork.go b/plc4go/internal/bacnetip/bacgopes/vlan/vlan_IPNetwork.go
index bf83931fe0e..ef2f2446d3a 100644
--- a/plc4go/internal/bacnetip/bacgopes/vlan/vlan_IPNetwork.go
+++ b/plc4go/internal/bacnetip/bacgopes/vlan/vlan_IPNetwork.go
@@ -35,13 +35,15 @@ type IPNetwork struct {
 	*Network
 }
 
-func NewIPNetwork(localLog zerolog.Logger, opts ...func(*Network)) *IPNetwork {
+func NewIPNetwork(localLog zerolog.Logger, options ...Option) *IPNetwork {
 	if _debug != nil {
 		_debug("__init__")
 	}
-	return &IPNetwork{
-		Network: NewNetwork(localLog, opts...),
-	}
+	i := &IPNetwork{}
+	ApplyAppliers(options, i)
+	optionsForParent := AddLeafTypeIfAbundant(options, i)
+	i.Network = NewNetwork(localLog, optionsForParent...)
+	return i
 }
 
 // AddNode Add a node to this network, let the node know which network it's on.
diff --git a/plc4go/internal/bacnetip/bacgopes/vlan/vlan_IPNode.go b/plc4go/internal/bacnetip/bacgopes/vlan/vlan_IPNode.go
index 17a2b1a6051..05b1f81258e 100644
--- a/plc4go/internal/bacnetip/bacgopes/vlan/vlan_IPNode.go
+++ b/plc4go/internal/bacnetip/bacgopes/vlan/vlan_IPNode.go
@@ -20,12 +20,10 @@
 package vlan
 
 import (
-	"fmt"
-
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog"
 
-	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/debugging"
+	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/comp"
 	. "github.com/apache/plc4x/plc4go/internal/bacnetip/bacgopes/pdu"
 )
 
@@ -40,17 +38,19 @@ type IPNode struct {
 	addrBroadcastTuple *AddressTuple[string, uint16] `stringer:"true"`
 }
 
-func NewIPNode(localLog zerolog.Logger, addr *Address, lan *IPNetwork, opts ...func(*Node)) (*IPNode, error) {
+func NewIPNode(localLog zerolog.Logger, addr *Address, lan *IPNetwork, options ...Option) (*IPNode, error) {
 	i := &IPNode{
 		// save the address information
 		addrTuple:          addr.AddrTuple,
 		addrBroadcastTuple: addr.AddrBroadcastTuple,
 	}
+	ApplyAppliers(options, i)
+	optionsForParent := AddLeafTypeIfAbundant(options, i)
 	if _debug != nil {
 		_debug("__init__ %r lan=%r", addr, lan)
 	}
 	var err error
-	i.Node, err = NewNode(localLog, addr, opts...)
+	i.Node, err = NewNode(localLog, addr, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating node")
 	}
@@ -62,10 +62,3 @@ func (n *IPNode) bind(lan NodeNetworkReference) { // This is used to preserve th
 	n.log.Debug().Interface("lan", lan).Msg("binding lan")
 	lan.AddNode(n)
 }
-
-func (n *IPNode) Format(s fmt.State, v rune) {
-	switch v {
-	case 's', 'v', 'r':
-		_, _ = fmt.Fprintf(s, "<%s(%s) at %p>", StructName(), n.name, n)
-	}
-}
diff --git a/plc4go/internal/bacnetip/bacgopes/vlan/vlan_IPRouterNode.go b/plc4go/internal/bacnetip/bacgopes/vlan/vlan_IPRouterNode.go
index 09d5ace5cd2..50ac945effe 100644
--- a/plc4go/internal/bacnetip/bacgopes/vlan/vlan_IPRouterNode.go
+++ b/plc4go/internal/bacnetip/bacgopes/vlan/vlan_IPRouterNode.go
@@ -41,13 +41,10 @@ type IPRouterNode struct {
 	addrMask   *uint32
 	addrSubnet *uint32
 
-	// pass through args
-	argCid *int `ignore:"true"`
-
 	log zerolog.Logger
 }
 
-func NewIPRouterNode(localLog zerolog.Logger, router *IPRouter, addr *Address, lan *IPNetwork, opts ...func(*IPRouterNode)) (*IPRouterNode, error) {
+func NewIPRouterNode(localLog zerolog.Logger, router *IPRouter, addr *Address, lan *IPNetwork, options ...Option) (*IPRouterNode, error) {
 	i := &IPRouterNode{
 		// save the references to the router for packets and the lan for debugging
 		router: router,
@@ -55,14 +52,13 @@ func NewIPRouterNode(localLog zerolog.Logger, router *IPRouter, addr *Address, l
 
 		log: localLog,
 	}
-	for _, opt := range opts {
-		opt(i)
-	}
+	ApplyAppliers(options, i)
+	optionsForParent := AddLeafTypeIfAbundant(options, i)
 	if _debug != nil {
 		_debug("__init__ %r %r lan=%r", router, addr, lan)
 	}
 	var err error
-	i.ClientContract, err = NewClient(localLog, OptionalOption2(i.argCid, ToPtr[ClientRequirements](i), WithClientCID))
+	i.ClientContract, err = NewClient(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error building client")
 	}
@@ -81,12 +77,6 @@ func NewIPRouterNode(localLog zerolog.Logger, router *IPRouter, addr *Address, l
 	return i, nil
 }
 
-func WithIPRouterNodeCid(cid int) func(*IPRouterNode) {
-	return func(n *IPRouterNode) {
-		n.argCid = &cid
-	}
-}
-
 func (n *IPRouterNode) Confirmation(args Args, kwArgs KWArgs) error {
 	pdu := GA[PDU](args, 0)
 	if _debug != nil {
diff --git a/plc4go/internal/bacnetip/bacgopes/vlan/vlan_Network.go b/plc4go/internal/bacnetip/bacgopes/vlan/vlan_Network.go
index 8689a3ac464..a54acccb2f5 100644
--- a/plc4go/internal/bacnetip/bacgopes/vlan/vlan_Network.go
+++ b/plc4go/internal/bacnetip/bacgopes/vlan/vlan_Network.go
@@ -52,45 +52,38 @@ type Network struct {
 
 	trafficLogger TrafficLogger
 
+	_leafName string
+
 	log zerolog.Logger
 }
 
-func NewNetwork(localLog zerolog.Logger, opts ...func(*Network)) *Network {
+func NewNetwork(localLog zerolog.Logger, options ...Option) *Network {
 	n := &Network{
 		DefaultRFormatter: NewDefaultRFormatter(),
+		_leafName:         ExtractLeafName(options, StructName()),
 		log:               localLog,
 	}
-	for _, opt := range opts {
-		opt(n)
-	}
+	ApplyAppliers(options, n)
 	if _debug != nil {
 		_debug("__init__ name=%r broadcast_address=%r drop_percent=%r", n.name, n.broadcastAddress, n.dropPercent)
 	}
 	return n
 }
 
-func WithNetworkName(name string) func(*Network) {
-	return func(n *Network) {
-		n.name = name
-	}
+func WithNetworkName(name string) GenericApplier[*Network] {
+	return WrapGenericApplier(func(n *Network) { n.name = name })
 }
 
-func WithNetworkBroadcastAddress(broadcastAddress *Address) func(*Network) {
-	return func(n *Network) {
-		n.broadcastAddress = broadcastAddress
-	}
+func WithNetworkBroadcastAddress(broadcastAddress *Address) GenericApplier[*Network] {
+	return WrapGenericApplier(func(n *Network) { n.broadcastAddress = broadcastAddress })
 }
 
-func WithNetworkDropPercent(dropPercent float32) func(*Network) {
-	return func(n *Network) {
-		n.dropPercent = dropPercent
-	}
+func WithNetworkDropPercent(dropPercent float32) GenericApplier[*Network] {
+	return WrapGenericApplier(func(n *Network) { n.dropPercent = dropPercent })
 }
 
-func WithNetworkTrafficLogger(trafficLogger TrafficLogger) func(*Network) {
-	return func(n *Network) {
-		n.trafficLogger = trafficLogger
-	}
+func WithNetworkTrafficLogger(trafficLogger TrafficLogger) GenericApplier[*Network] {
+	return WrapGenericApplier(func(n *Network) { n.trafficLogger = trafficLogger })
 }
 
 // AddNode Add a node to this network, let the node know which network it's on.
@@ -183,5 +176,5 @@ func (n *Network) ProcessPDU(pdu PDU) error {
 }
 
 func (n *Network) String() string {
-	return fmt.Sprintf("<Network name=%s>", n.name)
+	return fmt.Sprintf("<%s name=%s>", n._leafName, n.name)
 }
diff --git a/plc4go/internal/bacnetip/bacgopes/vlan/vlan_Node.go b/plc4go/internal/bacnetip/bacgopes/vlan/vlan_Node.go
index e637dae0be9..0543a982a2d 100644
--- a/plc4go/internal/bacnetip/bacgopes/vlan/vlan_Node.go
+++ b/plc4go/internal/bacnetip/bacgopes/vlan/vlan_Node.go
@@ -50,31 +50,30 @@ type Node struct {
 	promiscuous bool
 	spoofing    bool
 
-	// pass through args
-	argSid *int `ignore:"true"`
+	_leafName string
 
 	log zerolog.Logger
 }
 
-func NewNode(localLog zerolog.Logger, addr *Address, opts ...func(*Node)) (*Node, error) {
+func NewNode(localLog zerolog.Logger, addr *Address, options ...Option) (*Node, error) {
 	n := &Node{
-		address: addr,
-		log:     localLog,
-	}
-	for _, opt := range opts {
-		opt(n)
-	}
-	if _debug != nil {
-		_debug("__init__ %r lan=%r name=%r, promiscuous=%r spoofing=%r sid=%r", addr, n.lan, n.name, n.promiscuous, n.spoofing, n.argSid)
+		address:   addr,
+		_leafName: ExtractLeafName(options, StructName()),
+		log:       localLog,
 	}
+	ApplyAppliers(options, n)
+	optionsForParent := AddLeafTypeIfAbundant(options, n)
 	if n.name != "" {
 		n.log = n.log.With().Str("name", n.name).Logger()
 	}
 	var err error
-	n.ServerContract, err = NewServer(localLog, OptionalOption2(n.argSid, ToPtr[ServerRequirements](n), WithServerSID))
+	n.ServerContract, err = NewServer(localLog, optionsForParent...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating server")
 	}
+	if _debug != nil {
+		_debug("__init__ %r lan=%r name=%r, promiscuous=%r spoofing=%r sid=%r", addr, n.lan, n.name, n.promiscuous, n.spoofing, n.GetServerId())
+	}
 
 	// bind to a lan if it was provided
 	if n.lan != nil {
@@ -83,34 +82,20 @@ func NewNode(localLog zerolog.Logger, addr *Address, opts ...func(*Node)) (*Node
 	return n, nil
 }
 
-func WithNodeName(name string) func(*Node) {
-	return func(n *Node) {
-		n.name = name
-	}
+func WithNodeName(name string) GenericApplier[*Node] {
+	return WrapGenericApplier(func(n *Node) { n.name = name })
 }
 
-func WithNodeLan(lan NodeNetworkReference) func(*Node) {
-	return func(n *Node) {
-		n.lan = lan
-	}
+func WithNodeLan(lan NodeNetworkReference) GenericApplier[*Node] {
+	return WrapGenericApplier(func(n *Node) { n.lan = lan })
 }
 
-func WithNodePromiscuous(promiscuous bool) func(*Node) {
-	return func(n *Node) {
-		n.promiscuous = promiscuous
-	}
+func WithNodePromiscuous(promiscuous bool) GenericApplier[*Node] {
+	return WrapGenericApplier(func(n *Node) { n.promiscuous = promiscuous })
 }
 
-func WithNodeSpoofing(spoofing bool) func(*Node) {
-	return func(n *Node) {
-		n.spoofing = spoofing
-	}
-}
-
-func WithNodeSid(sid int) func(*Node) {
-	return func(n *Node) {
-		n.argSid = &sid
-	}
+func WithNodeSpoofing(spoofing bool) GenericApplier[*Node] {
+	return WrapGenericApplier(func(n *Node) { n.spoofing = spoofing })
 }
 
 func (n *Node) setLan(lan *Network) {
@@ -179,6 +164,13 @@ func (n *Node) Indication(args Args, kwArgs KWArgs) error {
 func (n *Node) Format(s fmt.State, v rune) {
 	switch v {
 	case 's', 'v', 'r':
-		_, _ = fmt.Fprintf(s, "<%s(%s) at %p>", StructName(), n.name, n)
+		_, _ = fmt.Fprintf(s, "<%s(%s) at %p>", n._leafName, n.name, n)
+	}
+}
+
+func (n *Node) AlternateString() (string, bool) {
+	if IsDebuggingActive() {
+		return fmt.Sprintf("%s", n), true // Delegate to debugging format
 	}
+	return "", false
 }
diff --git a/plc4go/internal/bacnetip/bacgopes/vlan/vlan_Node_plc4xgen.go b/plc4go/internal/bacnetip/bacgopes/vlan/vlan_Node_plc4xgen.go
index 2c63753931f..ea24719d3e2 100644
--- a/plc4go/internal/bacnetip/bacgopes/vlan/vlan_Node_plc4xgen.go
+++ b/plc4go/internal/bacnetip/bacgopes/vlan/vlan_Node_plc4xgen.go
@@ -79,6 +79,10 @@ func (d *Node) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.W
 	if err := writeBuffer.WriteBit("spoofing", d.spoofing); err != nil {
 		return err
 	}
+
+	if err := writeBuffer.WriteString("_leafName", uint32(len(d._leafName)*8), d._leafName); err != nil {
+		return err
+	}
 	if err := writeBuffer.PopContext("Node"); err != nil {
 		return err
 	}