fix(plc4go): fixed code smells

plc4go/internal/ads/Writer.go

@@ -190,10 +190,9 @@ func (m *Writer) ToPlc4xWriteResponse(requestTcpPaket readWriteModel.AmsTCPPacke
 
 	// we default to an error until its proven wrong
 	responseCodes[fieldName] = model.PlcResponseCode_INTERNAL_ERROR
-	switch responseTcpPaket.GetUserdata().(type) {
-	case readWriteModel.AdsWriteResponse:
-		resp := readWriteModel.CastAdsWriteResponse(responseTcpPaket.GetUserdata())
-		responseCodes[fieldName] = model.PlcResponseCode(resp.GetResult())
+	switch writeResponse := responseTcpPaket.GetUserdata().(type) {
+	case readWriteModel.AdsWriteResponseExactly:
+		responseCodes[fieldName] = model.PlcResponseCode(writeResponse.GetResult())
 	default:
 		return nil, errors.Errorf("unsupported response type %T", responseTcpPaket.GetUserdata())
 	}

plc4go/internal/bacnetip/Connection.go

@@ -106,8 +106,8 @@ func (c *Connection) GetMessageCodec() spi.MessageCodec {
 	return c.messageCodec
 }
 
-func (m *Connection) ReadRequestBuilder() apiModel.PlcReadRequestBuilder {
-	return internalModel.NewDefaultPlcReadRequestBuilder(m.GetPlcFieldHandler(), NewReader(&m.invokeIdGenerator, m.messageCodec, m.tm))
+func (c *Connection) ReadRequestBuilder() apiModel.PlcReadRequestBuilder {
+	return internalModel.NewDefaultPlcReadRequestBuilder(c.GetPlcFieldHandler(), NewReader(&c.invokeIdGenerator, c.messageCodec, c.tm))
 }
 
 func (c *Connection) SubscriptionRequestBuilder() apiModel.PlcSubscriptionRequestBuilder {

plc4go/internal/bacnetip/Discoverer.go

@@ -536,7 +536,7 @@ func extractProtocolSpecificOptions(discoveryOptions []options.WithDiscoveryOpti
 					prefix := strings.TrimSuffix(otherKey.key, "*")
 					mustBePresent := otherKey.mustBePresent
 					var found bool
-					for key, _ := range filteredOptionMap {
+					for key := range filteredOptionMap {
 						found = found || strings.HasPrefix(key, prefix)
 					}
 					if mustBePresent && !found {
@@ -575,7 +575,7 @@ func extractProtocolSpecificOptions(discoveryOptions []options.WithDiscoveryOpti
 	} else if err != nil {
 		return nil, err
 	}
-	for key, _ := range filteredOptionMap {
+	for key := range filteredOptionMap {
 		if strings.HasPrefix(key, "who-has-object") {
 			collectedOptions = append(collectedOptions, whoHasOption())
 			break

plc4go/internal/knxnetip/Connection.go

@@ -282,9 +282,7 @@ func (m *Connection) Connect() <-chan plc4go.PlcConnectionConnectResult {
 			switch connectionResponse.GetStatus() {
 			case driverModel.Status_NO_ERROR:
 				// Save the KNX Address the Gateway assigned to us for this connection.
-				tunnelConnectionDataBlock := driverModel.CastConnectionResponseDataBlockTunnelConnection(
-					connectionResponse.GetConnectionResponseDataBlock(),
-				)
+				tunnelConnectionDataBlock := connectionResponse.GetConnectionResponseDataBlock().(driverModel.ConnectionResponseDataBlockTunnelConnection)
 				m.ClientKnxAddress = tunnelConnectionDataBlock.GetKnxAddress()
 
 				// Create a go routine to handle incoming tunneling-requests which haven't been
@@ -295,10 +293,10 @@ func (m *Connection) Connect() <-chan plc4go.PlcConnectionConnectResult {
 					defaultIncomingMessageChannel := m.messageCodec.GetDefaultIncomingMessageChannel()
 					for m.handleTunnelingRequests {
 						incomingMessage := <-defaultIncomingMessageChannel
-						tunnelingRequest := driverModel.CastTunnelingRequest(incomingMessage)
-						if tunnelingRequest == nil {
-							tunnelingResponse := driverModel.CastTunnelingResponse(incomingMessage)
-							if tunnelingResponse != nil {
+						tunnelingRequest, ok := incomingMessage.(driverModel.TunnelingRequestExactly)
+						if !ok {
+							tunnelingResponse, ok := incomingMessage.(driverModel.TunnelingResponseExactly)
+							if ok {
 								log.Warn().Msgf("Got an unhandled TunnelingResponse message %v\n", tunnelingResponse)
 							} else {
 								log.Warn().Msgf("Not a TunnelingRequest or TunnelingResponse message %v\n", incomingMessage)
@@ -311,12 +309,12 @@ func (m *Connection) Connect() <-chan plc4go.PlcConnectionConnectResult {
 							continue
 						}
 
-						lDataInd := driverModel.CastLDataInd(tunnelingRequest.GetCemi())
-						if lDataInd == nil {
+						lDataInd, ok := tunnelingRequest.GetCemi().(driverModel.LDataIndExactly)
+						if !ok {
 							continue
 						}
 						// Get APDU, source and target address
-						lDataFrameData := driverModel.CastLDataExtended(lDataInd.GetDataFrame())
+						lDataFrameData := lDataInd.GetDataFrame().(driverModel.LDataExtended)
 						sourceAddress := lDataFrameData.GetSourceAddress()
 
 						// If this is not an APDU, there is no need to further handle it.
@@ -327,10 +325,10 @@ func (m *Connection) Connect() <-chan plc4go.PlcConnectionConnectResult {
 						// If this is an incoming disconnect request, remove the device
 						// from the device connections, otherwise handle it as normal
 						// incoming message.
-						apduControlContainer := driverModel.CastApduControlContainer(lDataFrameData.GetApdu())
-						if apduControlContainer != nil {
-							disconnectApdu := driverModel.CastApduControlDisconnect(apduControlContainer.GetControlApdu())
-							if disconnectApdu != nil {
+						apduControlContainer, ok := lDataFrameData.GetApdu().(driverModel.ApduControlContainerExactly)
+						if ok {
+							_, ok := apduControlContainer.GetControlApdu().(driverModel.ApduControlDisconnectExactly)
+							if ok {
 								if m.DeviceConnections[sourceAddress] != nil /* && m.ClientKnxAddress == Int8ArrayToKnxAddress(targetAddress)*/ {
 									// Remove the connection
 									delete(m.DeviceConnections, sourceAddress)

plc4go/internal/knxnetip/ConnectionHelper.go

@@ -53,21 +53,21 @@ func (m *Connection) castIpToKnxAddress(ip net.IP) driverModel.IPAddress {
 
 func (m *Connection) handleIncomingTunnelingRequest(ctx context.Context, tunnelingRequest driverModel.TunnelingRequest) {
 	go func() {
-		lDataInd := driverModel.CastLDataInd(tunnelingRequest.GetCemi())
-		if lDataInd == nil {
+		lDataInd, ok := tunnelingRequest.GetCemi().(driverModel.LDataIndExactly)
+		if !ok {
 			return
 		}
 		var destinationAddress []byte
 		switch lDataInd.GetDataFrame().(type) {
-		case driverModel.LDataExtended:
-			dataFrame := driverModel.CastLDataExtended(lDataInd.GetDataFrame())
+		case driverModel.LDataExtendedExactly:
+			dataFrame := lDataInd.GetDataFrame().(driverModel.LDataExtended)
 			destinationAddress = dataFrame.GetDestinationAddress()
 			switch dataFrame.GetApdu().(type) {
-			case driverModel.ApduDataContainer:
-				container := driverModel.CastApduDataContainer(dataFrame.GetApdu())
+			case driverModel.ApduDataContainerExactly:
+				container := dataFrame.GetApdu().(driverModel.ApduDataContainer)
 				switch container.GetDataApdu().(type) {
-				case driverModel.ApduDataGroupValueWrite:
-					groupValueWrite := driverModel.CastApduDataGroupValueWrite(container.GetDataApdu())
+				case driverModel.ApduDataGroupValueWriteExactly:
+					groupValueWrite := container.GetDataApdu().(driverModel.ApduDataGroupValueWrite)
 					if destinationAddress == nil {
 						return
 					}
@@ -80,18 +80,18 @@ func (m *Connection) handleIncomingTunnelingRequest(ctx context.Context, tunneli
 					if dataFrame.GetGroupAddress() {
 						return
 					}
-					// If this is an individual address and it is targeted at us, we need to ack that.
+					// If this is an individual address, and it is targeted at us, we need to ack that.
 					targetAddress := ByteArrayToKnxAddress(dataFrame.GetDestinationAddress())
 					if targetAddress == m.ClientKnxAddress {
 						log.Info().Msg("Acknowleding an unhandled data message.")
 						_ = m.sendDeviceAck(ctx, dataFrame.GetSourceAddress(), dataFrame.GetApdu().GetCounter(), func(err error) {})
 					}
 				}
-			case driverModel.ApduControlContainer:
+			case driverModel.ApduControlContainerExactly:
 				if dataFrame.GetGroupAddress() {
 					return
 				}
-				// If this is an individual address and it is targeted at us, we need to ack that.
+				// If this is an individual address, and it is targeted at us, we need to ack that.
 				targetAddress := ByteArrayToKnxAddress(dataFrame.GetDestinationAddress())
 				if targetAddress == m.ClientKnxAddress {
 					log.Info().Msg("Acknowleding an unhandled contol message.")