From 7d9f3e108112a405c1d3665d955375f3907bdc25 Mon Sep 17 00:00:00 2001 From: Christofer Dutz Date: Sun, 19 Nov 2023 11:38:31 +0100 Subject: [PATCH] fic: Added the missing Go files for S7 --- .../model/S7PayloadUserDataItemClkFRequest.go | 184 +++++++++++ .../S7PayloadUserDataItemClkFResponse.go | 283 ++++++++++++++++ .../model/S7PayloadUserDataItemClkRequest.go | 184 +++++++++++ .../model/S7PayloadUserDataItemClkResponse.go | 283 ++++++++++++++++ .../S7PayloadUserDataItemClkSetRequest.go | 308 ++++++++++++++++++ .../S7PayloadUserDataItemClkSetResponse.go | 184 +++++++++++ 6 files changed, 1426 insertions(+) create mode 100644 plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkFRequest.go create mode 100644 plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkFResponse.go create mode 100644 plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkRequest.go create mode 100644 plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkResponse.go create mode 100644 plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkSetRequest.go create mode 100644 plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkSetResponse.go diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkFRequest.go b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkFRequest.go new file mode 100644 index 00000000000..0e2c74355d6 --- /dev/null +++ b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkFRequest.go @@ -0,0 +1,184 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package model + +import ( + "context" + "fmt" + "github.com/apache/plc4x/plc4go/spi/utils" + "github.com/pkg/errors" + "github.com/rs/zerolog" +) + +// Code generated by code-generation. DO NOT EDIT. + +// S7PayloadUserDataItemClkFRequest is the corresponding interface of S7PayloadUserDataItemClkFRequest +type S7PayloadUserDataItemClkFRequest interface { + fmt.Stringer + utils.LengthAware + utils.Serializable + S7PayloadUserDataItem +} + +// S7PayloadUserDataItemClkFRequestExactly can be used when we want exactly this type and not a type which fulfills S7PayloadUserDataItemClkFRequest. +// This is useful for switch cases. +type S7PayloadUserDataItemClkFRequestExactly interface { + S7PayloadUserDataItemClkFRequest + isS7PayloadUserDataItemClkFRequest() bool +} + +// _S7PayloadUserDataItemClkFRequest is the data-structure of this message +type _S7PayloadUserDataItemClkFRequest struct { + *_S7PayloadUserDataItem +} + +/////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////// +/////////////////////// Accessors for discriminator values. +/////////////////////// + +func (m *_S7PayloadUserDataItemClkFRequest) GetCpuFunctionGroup() uint8 { + return 0x07 +} + +func (m *_S7PayloadUserDataItemClkFRequest) GetCpuFunctionType() uint8 { + return 0x04 +} + +func (m *_S7PayloadUserDataItemClkFRequest) GetCpuSubfunction() uint8 { + return 0x03 +} + +/////////////////////// +/////////////////////// +/////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////// + +func (m *_S7PayloadUserDataItemClkFRequest) InitializeParent(parent S7PayloadUserDataItem, returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) { + m.ReturnCode = returnCode + m.TransportSize = transportSize + m.DataLength = dataLength +} + +func (m *_S7PayloadUserDataItemClkFRequest) GetParent() S7PayloadUserDataItem { + return m._S7PayloadUserDataItem +} + +// NewS7PayloadUserDataItemClkFRequest factory function for _S7PayloadUserDataItemClkFRequest +func NewS7PayloadUserDataItemClkFRequest(returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) *_S7PayloadUserDataItemClkFRequest { + _result := &_S7PayloadUserDataItemClkFRequest{ + _S7PayloadUserDataItem: NewS7PayloadUserDataItem(returnCode, transportSize, dataLength), + } + _result._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _result + return _result +} + +// Deprecated: use the interface for direct cast +func CastS7PayloadUserDataItemClkFRequest(structType any) S7PayloadUserDataItemClkFRequest { + if casted, ok := structType.(S7PayloadUserDataItemClkFRequest); ok { + return casted + } + if casted, ok := structType.(*S7PayloadUserDataItemClkFRequest); ok { + return *casted + } + return nil +} + +func (m *_S7PayloadUserDataItemClkFRequest) GetTypeName() string { + return "S7PayloadUserDataItemClkFRequest" +} + +func (m *_S7PayloadUserDataItemClkFRequest) GetLengthInBits(ctx context.Context) uint16 { + lengthInBits := uint16(m.GetParentLengthInBits(ctx)) + + return lengthInBits +} + +func (m *_S7PayloadUserDataItemClkFRequest) GetLengthInBytes(ctx context.Context) uint16 { + return m.GetLengthInBits(ctx) / 8 +} + +func S7PayloadUserDataItemClkFRequestParse(ctx context.Context, theBytes []byte, cpuFunctionGroup uint8, cpuFunctionType uint8, cpuSubfunction uint8) (S7PayloadUserDataItemClkFRequest, error) { + return S7PayloadUserDataItemClkFRequestParseWithBuffer(ctx, utils.NewReadBufferByteBased(theBytes), cpuFunctionGroup, cpuFunctionType, cpuSubfunction) +} + +func S7PayloadUserDataItemClkFRequestParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, cpuFunctionGroup uint8, cpuFunctionType uint8, cpuSubfunction uint8) (S7PayloadUserDataItemClkFRequest, error) { + positionAware := readBuffer + _ = positionAware + log := zerolog.Ctx(ctx) + _ = log + if pullErr := readBuffer.PullContext("S7PayloadUserDataItemClkFRequest"); pullErr != nil { + return nil, errors.Wrap(pullErr, "Error pulling for S7PayloadUserDataItemClkFRequest") + } + currentPos := positionAware.GetPos() + _ = currentPos + + if closeErr := readBuffer.CloseContext("S7PayloadUserDataItemClkFRequest"); closeErr != nil { + return nil, errors.Wrap(closeErr, "Error closing for S7PayloadUserDataItemClkFRequest") + } + + // Create a partially initialized instance + _child := &_S7PayloadUserDataItemClkFRequest{ + _S7PayloadUserDataItem: &_S7PayloadUserDataItem{}, + } + _child._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _child + return _child, nil +} + +func (m *_S7PayloadUserDataItemClkFRequest) Serialize() ([]byte, error) { + wb := utils.NewWriteBufferByteBased(utils.WithInitialSizeForByteBasedBuffer(int(m.GetLengthInBytes(context.Background())))) + if err := m.SerializeWithWriteBuffer(context.Background(), wb); err != nil { + return nil, err + } + return wb.GetBytes(), nil +} + +func (m *_S7PayloadUserDataItemClkFRequest) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error { + positionAware := writeBuffer + _ = positionAware + log := zerolog.Ctx(ctx) + _ = log + ser := func() error { + if pushErr := writeBuffer.PushContext("S7PayloadUserDataItemClkFRequest"); pushErr != nil { + return errors.Wrap(pushErr, "Error pushing for S7PayloadUserDataItemClkFRequest") + } + + if popErr := writeBuffer.PopContext("S7PayloadUserDataItemClkFRequest"); popErr != nil { + return errors.Wrap(popErr, "Error popping for S7PayloadUserDataItemClkFRequest") + } + return nil + } + return m.SerializeParent(ctx, writeBuffer, m, ser) +} + +func (m *_S7PayloadUserDataItemClkFRequest) isS7PayloadUserDataItemClkFRequest() bool { + return true +} + +func (m *_S7PayloadUserDataItemClkFRequest) String() string { + if m == nil { + return "" + } + writeBuffer := utils.NewWriteBufferBoxBasedWithOptions(true, true) + if err := writeBuffer.WriteSerializable(context.Background(), m); err != nil { + return err.Error() + } + return writeBuffer.GetBox().String() +} diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkFResponse.go b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkFResponse.go new file mode 100644 index 00000000000..b6f300b88cc --- /dev/null +++ b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkFResponse.go @@ -0,0 +1,283 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package model + +import ( + "context" + "fmt" + "github.com/apache/plc4x/plc4go/spi/utils" + "github.com/pkg/errors" + "github.com/rs/zerolog" +) + +// Code generated by code-generation. DO NOT EDIT. + +// S7PayloadUserDataItemClkFResponse is the corresponding interface of S7PayloadUserDataItemClkFResponse +type S7PayloadUserDataItemClkFResponse interface { + fmt.Stringer + utils.LengthAware + utils.Serializable + S7PayloadUserDataItem + // GetReserved returns Reserved (property field) + GetReserved() uint8 + // GetYear1 returns Year1 (property field) + GetYear1() uint8 + // GetTimeStamp returns TimeStamp (property field) + GetTimeStamp() DateAndTime +} + +// S7PayloadUserDataItemClkFResponseExactly can be used when we want exactly this type and not a type which fulfills S7PayloadUserDataItemClkFResponse. +// This is useful for switch cases. +type S7PayloadUserDataItemClkFResponseExactly interface { + S7PayloadUserDataItemClkFResponse + isS7PayloadUserDataItemClkFResponse() bool +} + +// _S7PayloadUserDataItemClkFResponse is the data-structure of this message +type _S7PayloadUserDataItemClkFResponse struct { + *_S7PayloadUserDataItem + Reserved uint8 + Year1 uint8 + TimeStamp DateAndTime +} + +/////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////// +/////////////////////// Accessors for discriminator values. +/////////////////////// + +func (m *_S7PayloadUserDataItemClkFResponse) GetCpuFunctionGroup() uint8 { + return 0x07 +} + +func (m *_S7PayloadUserDataItemClkFResponse) GetCpuFunctionType() uint8 { + return 0x08 +} + +func (m *_S7PayloadUserDataItemClkFResponse) GetCpuSubfunction() uint8 { + return 0x03 +} + +/////////////////////// +/////////////////////// +/////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////// + +func (m *_S7PayloadUserDataItemClkFResponse) InitializeParent(parent S7PayloadUserDataItem, returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) { + m.ReturnCode = returnCode + m.TransportSize = transportSize + m.DataLength = dataLength +} + +func (m *_S7PayloadUserDataItemClkFResponse) GetParent() S7PayloadUserDataItem { + return m._S7PayloadUserDataItem +} + +/////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////// +/////////////////////// Accessors for property fields. +/////////////////////// + +func (m *_S7PayloadUserDataItemClkFResponse) GetReserved() uint8 { + return m.Reserved +} + +func (m *_S7PayloadUserDataItemClkFResponse) GetYear1() uint8 { + return m.Year1 +} + +func (m *_S7PayloadUserDataItemClkFResponse) GetTimeStamp() DateAndTime { + return m.TimeStamp +} + +/////////////////////// +/////////////////////// +/////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////// + +// NewS7PayloadUserDataItemClkFResponse factory function for _S7PayloadUserDataItemClkFResponse +func NewS7PayloadUserDataItemClkFResponse(Reserved uint8, Year1 uint8, TimeStamp DateAndTime, returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) *_S7PayloadUserDataItemClkFResponse { + _result := &_S7PayloadUserDataItemClkFResponse{ + Reserved: Reserved, + Year1: Year1, + TimeStamp: TimeStamp, + _S7PayloadUserDataItem: NewS7PayloadUserDataItem(returnCode, transportSize, dataLength), + } + _result._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _result + return _result +} + +// Deprecated: use the interface for direct cast +func CastS7PayloadUserDataItemClkFResponse(structType any) S7PayloadUserDataItemClkFResponse { + if casted, ok := structType.(S7PayloadUserDataItemClkFResponse); ok { + return casted + } + if casted, ok := structType.(*S7PayloadUserDataItemClkFResponse); ok { + return *casted + } + return nil +} + +func (m *_S7PayloadUserDataItemClkFResponse) GetTypeName() string { + return "S7PayloadUserDataItemClkFResponse" +} + +func (m *_S7PayloadUserDataItemClkFResponse) GetLengthInBits(ctx context.Context) uint16 { + lengthInBits := uint16(m.GetParentLengthInBits(ctx)) + + // Simple field (Reserved) + lengthInBits += 8 + + // Simple field (Year1) + lengthInBits += 8 + + // Simple field (TimeStamp) + lengthInBits += m.TimeStamp.GetLengthInBits(ctx) + + return lengthInBits +} + +func (m *_S7PayloadUserDataItemClkFResponse) GetLengthInBytes(ctx context.Context) uint16 { + return m.GetLengthInBits(ctx) / 8 +} + +func S7PayloadUserDataItemClkFResponseParse(ctx context.Context, theBytes []byte, dataLength uint16, cpuFunctionGroup uint8, cpuFunctionType uint8, cpuSubfunction uint8) (S7PayloadUserDataItemClkFResponse, error) { + return S7PayloadUserDataItemClkFResponseParseWithBuffer(ctx, utils.NewReadBufferByteBased(theBytes), dataLength, cpuFunctionGroup, cpuFunctionType, cpuSubfunction) +} + +func S7PayloadUserDataItemClkFResponseParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, dataLength uint16, cpuFunctionGroup uint8, cpuFunctionType uint8, cpuSubfunction uint8) (S7PayloadUserDataItemClkFResponse, error) { + positionAware := readBuffer + _ = positionAware + log := zerolog.Ctx(ctx) + _ = log + if pullErr := readBuffer.PullContext("S7PayloadUserDataItemClkFResponse"); pullErr != nil { + return nil, errors.Wrap(pullErr, "Error pulling for S7PayloadUserDataItemClkFResponse") + } + currentPos := positionAware.GetPos() + _ = currentPos + + // Simple Field (Reserved) + _Reserved, _ReservedErr := readBuffer.ReadUint8("Reserved", 8) + if _ReservedErr != nil { + return nil, errors.Wrap(_ReservedErr, "Error parsing 'Reserved' field of S7PayloadUserDataItemClkFResponse") + } + Reserved := _Reserved + + // Simple Field (Year1) + _Year1, _Year1Err := readBuffer.ReadUint8("Year1", 8) + if _Year1Err != nil { + return nil, errors.Wrap(_Year1Err, "Error parsing 'Year1' field of S7PayloadUserDataItemClkFResponse") + } + Year1 := _Year1 + + // Simple Field (TimeStamp) + if pullErr := readBuffer.PullContext("TimeStamp"); pullErr != nil { + return nil, errors.Wrap(pullErr, "Error pulling for TimeStamp") + } + _TimeStamp, _TimeStampErr := DateAndTimeParseWithBuffer(ctx, readBuffer) + if _TimeStampErr != nil { + return nil, errors.Wrap(_TimeStampErr, "Error parsing 'TimeStamp' field of S7PayloadUserDataItemClkFResponse") + } + TimeStamp := _TimeStamp.(DateAndTime) + if closeErr := readBuffer.CloseContext("TimeStamp"); closeErr != nil { + return nil, errors.Wrap(closeErr, "Error closing for TimeStamp") + } + + if closeErr := readBuffer.CloseContext("S7PayloadUserDataItemClkFResponse"); closeErr != nil { + return nil, errors.Wrap(closeErr, "Error closing for S7PayloadUserDataItemClkFResponse") + } + + // Create a partially initialized instance + _child := &_S7PayloadUserDataItemClkFResponse{ + _S7PayloadUserDataItem: &_S7PayloadUserDataItem{}, + Reserved: Reserved, + Year1: Year1, + TimeStamp: TimeStamp, + } + _child._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _child + return _child, nil +} + +func (m *_S7PayloadUserDataItemClkFResponse) Serialize() ([]byte, error) { + wb := utils.NewWriteBufferByteBased(utils.WithInitialSizeForByteBasedBuffer(int(m.GetLengthInBytes(context.Background())))) + if err := m.SerializeWithWriteBuffer(context.Background(), wb); err != nil { + return nil, err + } + return wb.GetBytes(), nil +} + +func (m *_S7PayloadUserDataItemClkFResponse) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error { + positionAware := writeBuffer + _ = positionAware + log := zerolog.Ctx(ctx) + _ = log + ser := func() error { + if pushErr := writeBuffer.PushContext("S7PayloadUserDataItemClkFResponse"); pushErr != nil { + return errors.Wrap(pushErr, "Error pushing for S7PayloadUserDataItemClkFResponse") + } + + // Simple Field (Reserved) + Reserved := uint8(m.GetReserved()) + _ReservedErr := writeBuffer.WriteUint8("Reserved", 8, (Reserved)) + if _ReservedErr != nil { + return errors.Wrap(_ReservedErr, "Error serializing 'Reserved' field") + } + + // Simple Field (Year1) + Year1 := uint8(m.GetYear1()) + _Year1Err := writeBuffer.WriteUint8("Year1", 8, (Year1)) + if _Year1Err != nil { + return errors.Wrap(_Year1Err, "Error serializing 'Year1' field") + } + + // Simple Field (TimeStamp) + if pushErr := writeBuffer.PushContext("TimeStamp"); pushErr != nil { + return errors.Wrap(pushErr, "Error pushing for TimeStamp") + } + _TimeStampErr := writeBuffer.WriteSerializable(ctx, m.GetTimeStamp()) + if popErr := writeBuffer.PopContext("TimeStamp"); popErr != nil { + return errors.Wrap(popErr, "Error popping for TimeStamp") + } + if _TimeStampErr != nil { + return errors.Wrap(_TimeStampErr, "Error serializing 'TimeStamp' field") + } + + if popErr := writeBuffer.PopContext("S7PayloadUserDataItemClkFResponse"); popErr != nil { + return errors.Wrap(popErr, "Error popping for S7PayloadUserDataItemClkFResponse") + } + return nil + } + return m.SerializeParent(ctx, writeBuffer, m, ser) +} + +func (m *_S7PayloadUserDataItemClkFResponse) isS7PayloadUserDataItemClkFResponse() bool { + return true +} + +func (m *_S7PayloadUserDataItemClkFResponse) String() string { + if m == nil { + return "" + } + writeBuffer := utils.NewWriteBufferBoxBasedWithOptions(true, true) + if err := writeBuffer.WriteSerializable(context.Background(), m); err != nil { + return err.Error() + } + return writeBuffer.GetBox().String() +} diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkRequest.go b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkRequest.go new file mode 100644 index 00000000000..4f2edb91ca9 --- /dev/null +++ b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkRequest.go @@ -0,0 +1,184 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package model + +import ( + "context" + "fmt" + "github.com/apache/plc4x/plc4go/spi/utils" + "github.com/pkg/errors" + "github.com/rs/zerolog" +) + +// Code generated by code-generation. DO NOT EDIT. + +// S7PayloadUserDataItemClkRequest is the corresponding interface of S7PayloadUserDataItemClkRequest +type S7PayloadUserDataItemClkRequest interface { + fmt.Stringer + utils.LengthAware + utils.Serializable + S7PayloadUserDataItem +} + +// S7PayloadUserDataItemClkRequestExactly can be used when we want exactly this type and not a type which fulfills S7PayloadUserDataItemClkRequest. +// This is useful for switch cases. +type S7PayloadUserDataItemClkRequestExactly interface { + S7PayloadUserDataItemClkRequest + isS7PayloadUserDataItemClkRequest() bool +} + +// _S7PayloadUserDataItemClkRequest is the data-structure of this message +type _S7PayloadUserDataItemClkRequest struct { + *_S7PayloadUserDataItem +} + +/////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////// +/////////////////////// Accessors for discriminator values. +/////////////////////// + +func (m *_S7PayloadUserDataItemClkRequest) GetCpuFunctionGroup() uint8 { + return 0x07 +} + +func (m *_S7PayloadUserDataItemClkRequest) GetCpuFunctionType() uint8 { + return 0x04 +} + +func (m *_S7PayloadUserDataItemClkRequest) GetCpuSubfunction() uint8 { + return 0x01 +} + +/////////////////////// +/////////////////////// +/////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////// + +func (m *_S7PayloadUserDataItemClkRequest) InitializeParent(parent S7PayloadUserDataItem, returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) { + m.ReturnCode = returnCode + m.TransportSize = transportSize + m.DataLength = dataLength +} + +func (m *_S7PayloadUserDataItemClkRequest) GetParent() S7PayloadUserDataItem { + return m._S7PayloadUserDataItem +} + +// NewS7PayloadUserDataItemClkRequest factory function for _S7PayloadUserDataItemClkRequest +func NewS7PayloadUserDataItemClkRequest(returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) *_S7PayloadUserDataItemClkRequest { + _result := &_S7PayloadUserDataItemClkRequest{ + _S7PayloadUserDataItem: NewS7PayloadUserDataItem(returnCode, transportSize, dataLength), + } + _result._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _result + return _result +} + +// Deprecated: use the interface for direct cast +func CastS7PayloadUserDataItemClkRequest(structType any) S7PayloadUserDataItemClkRequest { + if casted, ok := structType.(S7PayloadUserDataItemClkRequest); ok { + return casted + } + if casted, ok := structType.(*S7PayloadUserDataItemClkRequest); ok { + return *casted + } + return nil +} + +func (m *_S7PayloadUserDataItemClkRequest) GetTypeName() string { + return "S7PayloadUserDataItemClkRequest" +} + +func (m *_S7PayloadUserDataItemClkRequest) GetLengthInBits(ctx context.Context) uint16 { + lengthInBits := uint16(m.GetParentLengthInBits(ctx)) + + return lengthInBits +} + +func (m *_S7PayloadUserDataItemClkRequest) GetLengthInBytes(ctx context.Context) uint16 { + return m.GetLengthInBits(ctx) / 8 +} + +func S7PayloadUserDataItemClkRequestParse(ctx context.Context, theBytes []byte, cpuFunctionGroup uint8, cpuFunctionType uint8, cpuSubfunction uint8) (S7PayloadUserDataItemClkRequest, error) { + return S7PayloadUserDataItemClkRequestParseWithBuffer(ctx, utils.NewReadBufferByteBased(theBytes), cpuFunctionGroup, cpuFunctionType, cpuSubfunction) +} + +func S7PayloadUserDataItemClkRequestParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, cpuFunctionGroup uint8, cpuFunctionType uint8, cpuSubfunction uint8) (S7PayloadUserDataItemClkRequest, error) { + positionAware := readBuffer + _ = positionAware + log := zerolog.Ctx(ctx) + _ = log + if pullErr := readBuffer.PullContext("S7PayloadUserDataItemClkRequest"); pullErr != nil { + return nil, errors.Wrap(pullErr, "Error pulling for S7PayloadUserDataItemClkRequest") + } + currentPos := positionAware.GetPos() + _ = currentPos + + if closeErr := readBuffer.CloseContext("S7PayloadUserDataItemClkRequest"); closeErr != nil { + return nil, errors.Wrap(closeErr, "Error closing for S7PayloadUserDataItemClkRequest") + } + + // Create a partially initialized instance + _child := &_S7PayloadUserDataItemClkRequest{ + _S7PayloadUserDataItem: &_S7PayloadUserDataItem{}, + } + _child._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _child + return _child, nil +} + +func (m *_S7PayloadUserDataItemClkRequest) Serialize() ([]byte, error) { + wb := utils.NewWriteBufferByteBased(utils.WithInitialSizeForByteBasedBuffer(int(m.GetLengthInBytes(context.Background())))) + if err := m.SerializeWithWriteBuffer(context.Background(), wb); err != nil { + return nil, err + } + return wb.GetBytes(), nil +} + +func (m *_S7PayloadUserDataItemClkRequest) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error { + positionAware := writeBuffer + _ = positionAware + log := zerolog.Ctx(ctx) + _ = log + ser := func() error { + if pushErr := writeBuffer.PushContext("S7PayloadUserDataItemClkRequest"); pushErr != nil { + return errors.Wrap(pushErr, "Error pushing for S7PayloadUserDataItemClkRequest") + } + + if popErr := writeBuffer.PopContext("S7PayloadUserDataItemClkRequest"); popErr != nil { + return errors.Wrap(popErr, "Error popping for S7PayloadUserDataItemClkRequest") + } + return nil + } + return m.SerializeParent(ctx, writeBuffer, m, ser) +} + +func (m *_S7PayloadUserDataItemClkRequest) isS7PayloadUserDataItemClkRequest() bool { + return true +} + +func (m *_S7PayloadUserDataItemClkRequest) String() string { + if m == nil { + return "" + } + writeBuffer := utils.NewWriteBufferBoxBasedWithOptions(true, true) + if err := writeBuffer.WriteSerializable(context.Background(), m); err != nil { + return err.Error() + } + return writeBuffer.GetBox().String() +} diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkResponse.go b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkResponse.go new file mode 100644 index 00000000000..0910085d8dc --- /dev/null +++ b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkResponse.go @@ -0,0 +1,283 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package model + +import ( + "context" + "fmt" + "github.com/apache/plc4x/plc4go/spi/utils" + "github.com/pkg/errors" + "github.com/rs/zerolog" +) + +// Code generated by code-generation. DO NOT EDIT. + +// S7PayloadUserDataItemClkResponse is the corresponding interface of S7PayloadUserDataItemClkResponse +type S7PayloadUserDataItemClkResponse interface { + fmt.Stringer + utils.LengthAware + utils.Serializable + S7PayloadUserDataItem + // GetReserved returns Reserved (property field) + GetReserved() uint8 + // GetYear1 returns Year1 (property field) + GetYear1() uint8 + // GetTimeStamp returns TimeStamp (property field) + GetTimeStamp() DateAndTime +} + +// S7PayloadUserDataItemClkResponseExactly can be used when we want exactly this type and not a type which fulfills S7PayloadUserDataItemClkResponse. +// This is useful for switch cases. +type S7PayloadUserDataItemClkResponseExactly interface { + S7PayloadUserDataItemClkResponse + isS7PayloadUserDataItemClkResponse() bool +} + +// _S7PayloadUserDataItemClkResponse is the data-structure of this message +type _S7PayloadUserDataItemClkResponse struct { + *_S7PayloadUserDataItem + Reserved uint8 + Year1 uint8 + TimeStamp DateAndTime +} + +/////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////// +/////////////////////// Accessors for discriminator values. +/////////////////////// + +func (m *_S7PayloadUserDataItemClkResponse) GetCpuFunctionGroup() uint8 { + return 0x07 +} + +func (m *_S7PayloadUserDataItemClkResponse) GetCpuFunctionType() uint8 { + return 0x08 +} + +func (m *_S7PayloadUserDataItemClkResponse) GetCpuSubfunction() uint8 { + return 0x01 +} + +/////////////////////// +/////////////////////// +/////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////// + +func (m *_S7PayloadUserDataItemClkResponse) InitializeParent(parent S7PayloadUserDataItem, returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) { + m.ReturnCode = returnCode + m.TransportSize = transportSize + m.DataLength = dataLength +} + +func (m *_S7PayloadUserDataItemClkResponse) GetParent() S7PayloadUserDataItem { + return m._S7PayloadUserDataItem +} + +/////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////// +/////////////////////// Accessors for property fields. +/////////////////////// + +func (m *_S7PayloadUserDataItemClkResponse) GetReserved() uint8 { + return m.Reserved +} + +func (m *_S7PayloadUserDataItemClkResponse) GetYear1() uint8 { + return m.Year1 +} + +func (m *_S7PayloadUserDataItemClkResponse) GetTimeStamp() DateAndTime { + return m.TimeStamp +} + +/////////////////////// +/////////////////////// +/////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////// + +// NewS7PayloadUserDataItemClkResponse factory function for _S7PayloadUserDataItemClkResponse +func NewS7PayloadUserDataItemClkResponse(Reserved uint8, Year1 uint8, TimeStamp DateAndTime, returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) *_S7PayloadUserDataItemClkResponse { + _result := &_S7PayloadUserDataItemClkResponse{ + Reserved: Reserved, + Year1: Year1, + TimeStamp: TimeStamp, + _S7PayloadUserDataItem: NewS7PayloadUserDataItem(returnCode, transportSize, dataLength), + } + _result._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _result + return _result +} + +// Deprecated: use the interface for direct cast +func CastS7PayloadUserDataItemClkResponse(structType any) S7PayloadUserDataItemClkResponse { + if casted, ok := structType.(S7PayloadUserDataItemClkResponse); ok { + return casted + } + if casted, ok := structType.(*S7PayloadUserDataItemClkResponse); ok { + return *casted + } + return nil +} + +func (m *_S7PayloadUserDataItemClkResponse) GetTypeName() string { + return "S7PayloadUserDataItemClkResponse" +} + +func (m *_S7PayloadUserDataItemClkResponse) GetLengthInBits(ctx context.Context) uint16 { + lengthInBits := uint16(m.GetParentLengthInBits(ctx)) + + // Simple field (Reserved) + lengthInBits += 8 + + // Simple field (Year1) + lengthInBits += 8 + + // Simple field (TimeStamp) + lengthInBits += m.TimeStamp.GetLengthInBits(ctx) + + return lengthInBits +} + +func (m *_S7PayloadUserDataItemClkResponse) GetLengthInBytes(ctx context.Context) uint16 { + return m.GetLengthInBits(ctx) / 8 +} + +func S7PayloadUserDataItemClkResponseParse(ctx context.Context, theBytes []byte, dataLength uint16, cpuFunctionGroup uint8, cpuFunctionType uint8, cpuSubfunction uint8) (S7PayloadUserDataItemClkResponse, error) { + return S7PayloadUserDataItemClkResponseParseWithBuffer(ctx, utils.NewReadBufferByteBased(theBytes), dataLength, cpuFunctionGroup, cpuFunctionType, cpuSubfunction) +} + +func S7PayloadUserDataItemClkResponseParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, dataLength uint16, cpuFunctionGroup uint8, cpuFunctionType uint8, cpuSubfunction uint8) (S7PayloadUserDataItemClkResponse, error) { + positionAware := readBuffer + _ = positionAware + log := zerolog.Ctx(ctx) + _ = log + if pullErr := readBuffer.PullContext("S7PayloadUserDataItemClkResponse"); pullErr != nil { + return nil, errors.Wrap(pullErr, "Error pulling for S7PayloadUserDataItemClkResponse") + } + currentPos := positionAware.GetPos() + _ = currentPos + + // Simple Field (Reserved) + _Reserved, _ReservedErr := readBuffer.ReadUint8("Reserved", 8) + if _ReservedErr != nil { + return nil, errors.Wrap(_ReservedErr, "Error parsing 'Reserved' field of S7PayloadUserDataItemClkResponse") + } + Reserved := _Reserved + + // Simple Field (Year1) + _Year1, _Year1Err := readBuffer.ReadUint8("Year1", 8) + if _Year1Err != nil { + return nil, errors.Wrap(_Year1Err, "Error parsing 'Year1' field of S7PayloadUserDataItemClkResponse") + } + Year1 := _Year1 + + // Simple Field (TimeStamp) + if pullErr := readBuffer.PullContext("TimeStamp"); pullErr != nil { + return nil, errors.Wrap(pullErr, "Error pulling for TimeStamp") + } + _TimeStamp, _TimeStampErr := DateAndTimeParseWithBuffer(ctx, readBuffer) + if _TimeStampErr != nil { + return nil, errors.Wrap(_TimeStampErr, "Error parsing 'TimeStamp' field of S7PayloadUserDataItemClkResponse") + } + TimeStamp := _TimeStamp.(DateAndTime) + if closeErr := readBuffer.CloseContext("TimeStamp"); closeErr != nil { + return nil, errors.Wrap(closeErr, "Error closing for TimeStamp") + } + + if closeErr := readBuffer.CloseContext("S7PayloadUserDataItemClkResponse"); closeErr != nil { + return nil, errors.Wrap(closeErr, "Error closing for S7PayloadUserDataItemClkResponse") + } + + // Create a partially initialized instance + _child := &_S7PayloadUserDataItemClkResponse{ + _S7PayloadUserDataItem: &_S7PayloadUserDataItem{}, + Reserved: Reserved, + Year1: Year1, + TimeStamp: TimeStamp, + } + _child._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _child + return _child, nil +} + +func (m *_S7PayloadUserDataItemClkResponse) Serialize() ([]byte, error) { + wb := utils.NewWriteBufferByteBased(utils.WithInitialSizeForByteBasedBuffer(int(m.GetLengthInBytes(context.Background())))) + if err := m.SerializeWithWriteBuffer(context.Background(), wb); err != nil { + return nil, err + } + return wb.GetBytes(), nil +} + +func (m *_S7PayloadUserDataItemClkResponse) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error { + positionAware := writeBuffer + _ = positionAware + log := zerolog.Ctx(ctx) + _ = log + ser := func() error { + if pushErr := writeBuffer.PushContext("S7PayloadUserDataItemClkResponse"); pushErr != nil { + return errors.Wrap(pushErr, "Error pushing for S7PayloadUserDataItemClkResponse") + } + + // Simple Field (Reserved) + Reserved := uint8(m.GetReserved()) + _ReservedErr := writeBuffer.WriteUint8("Reserved", 8, (Reserved)) + if _ReservedErr != nil { + return errors.Wrap(_ReservedErr, "Error serializing 'Reserved' field") + } + + // Simple Field (Year1) + Year1 := uint8(m.GetYear1()) + _Year1Err := writeBuffer.WriteUint8("Year1", 8, (Year1)) + if _Year1Err != nil { + return errors.Wrap(_Year1Err, "Error serializing 'Year1' field") + } + + // Simple Field (TimeStamp) + if pushErr := writeBuffer.PushContext("TimeStamp"); pushErr != nil { + return errors.Wrap(pushErr, "Error pushing for TimeStamp") + } + _TimeStampErr := writeBuffer.WriteSerializable(ctx, m.GetTimeStamp()) + if popErr := writeBuffer.PopContext("TimeStamp"); popErr != nil { + return errors.Wrap(popErr, "Error popping for TimeStamp") + } + if _TimeStampErr != nil { + return errors.Wrap(_TimeStampErr, "Error serializing 'TimeStamp' field") + } + + if popErr := writeBuffer.PopContext("S7PayloadUserDataItemClkResponse"); popErr != nil { + return errors.Wrap(popErr, "Error popping for S7PayloadUserDataItemClkResponse") + } + return nil + } + return m.SerializeParent(ctx, writeBuffer, m, ser) +} + +func (m *_S7PayloadUserDataItemClkResponse) isS7PayloadUserDataItemClkResponse() bool { + return true +} + +func (m *_S7PayloadUserDataItemClkResponse) String() string { + if m == nil { + return "" + } + writeBuffer := utils.NewWriteBufferBoxBasedWithOptions(true, true) + if err := writeBuffer.WriteSerializable(context.Background(), m); err != nil { + return err.Error() + } + return writeBuffer.GetBox().String() +} diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkSetRequest.go b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkSetRequest.go new file mode 100644 index 00000000000..b280a0f43cd --- /dev/null +++ b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkSetRequest.go @@ -0,0 +1,308 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package model + +import ( + "context" + "fmt" + "github.com/apache/plc4x/plc4go/spi/utils" + "github.com/pkg/errors" + "github.com/rs/zerolog" +) + +// Code generated by code-generation. DO NOT EDIT. + +// S7PayloadUserDataItemClkSetRequest is the corresponding interface of S7PayloadUserDataItemClkSetRequest +type S7PayloadUserDataItemClkSetRequest interface { + fmt.Stringer + utils.LengthAware + utils.Serializable + S7PayloadUserDataItem + // GetTimeStamp returns TimeStamp (property field) + GetTimeStamp() DateAndTime +} + +// S7PayloadUserDataItemClkSetRequestExactly can be used when we want exactly this type and not a type which fulfills S7PayloadUserDataItemClkSetRequest. +// This is useful for switch cases. +type S7PayloadUserDataItemClkSetRequestExactly interface { + S7PayloadUserDataItemClkSetRequest + isS7PayloadUserDataItemClkSetRequest() bool +} + +// _S7PayloadUserDataItemClkSetRequest is the data-structure of this message +type _S7PayloadUserDataItemClkSetRequest struct { + *_S7PayloadUserDataItem + TimeStamp DateAndTime + // Reserved Fields + reservedField0 *uint8 + reservedField1 *uint8 +} + +/////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////// +/////////////////////// Accessors for discriminator values. +/////////////////////// + +func (m *_S7PayloadUserDataItemClkSetRequest) GetCpuFunctionGroup() uint8 { + return 0x07 +} + +func (m *_S7PayloadUserDataItemClkSetRequest) GetCpuFunctionType() uint8 { + return 0x04 +} + +func (m *_S7PayloadUserDataItemClkSetRequest) GetCpuSubfunction() uint8 { + return 0x04 +} + +/////////////////////// +/////////////////////// +/////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////// + +func (m *_S7PayloadUserDataItemClkSetRequest) InitializeParent(parent S7PayloadUserDataItem, returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) { + m.ReturnCode = returnCode + m.TransportSize = transportSize + m.DataLength = dataLength +} + +func (m *_S7PayloadUserDataItemClkSetRequest) GetParent() S7PayloadUserDataItem { + return m._S7PayloadUserDataItem +} + +/////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////// +/////////////////////// Accessors for property fields. +/////////////////////// + +func (m *_S7PayloadUserDataItemClkSetRequest) GetTimeStamp() DateAndTime { + return m.TimeStamp +} + +/////////////////////// +/////////////////////// +/////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////// + +// NewS7PayloadUserDataItemClkSetRequest factory function for _S7PayloadUserDataItemClkSetRequest +func NewS7PayloadUserDataItemClkSetRequest(TimeStamp DateAndTime, returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) *_S7PayloadUserDataItemClkSetRequest { + _result := &_S7PayloadUserDataItemClkSetRequest{ + TimeStamp: TimeStamp, + _S7PayloadUserDataItem: NewS7PayloadUserDataItem(returnCode, transportSize, dataLength), + } + _result._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _result + return _result +} + +// Deprecated: use the interface for direct cast +func CastS7PayloadUserDataItemClkSetRequest(structType any) S7PayloadUserDataItemClkSetRequest { + if casted, ok := structType.(S7PayloadUserDataItemClkSetRequest); ok { + return casted + } + if casted, ok := structType.(*S7PayloadUserDataItemClkSetRequest); ok { + return *casted + } + return nil +} + +func (m *_S7PayloadUserDataItemClkSetRequest) GetTypeName() string { + return "S7PayloadUserDataItemClkSetRequest" +} + +func (m *_S7PayloadUserDataItemClkSetRequest) GetLengthInBits(ctx context.Context) uint16 { + lengthInBits := uint16(m.GetParentLengthInBits(ctx)) + + // Reserved Field (reserved) + lengthInBits += 8 + + // Reserved Field (reserved) + lengthInBits += 8 + + // Simple field (TimeStamp) + lengthInBits += m.TimeStamp.GetLengthInBits(ctx) + + return lengthInBits +} + +func (m *_S7PayloadUserDataItemClkSetRequest) GetLengthInBytes(ctx context.Context) uint16 { + return m.GetLengthInBits(ctx) / 8 +} + +func S7PayloadUserDataItemClkSetRequestParse(ctx context.Context, theBytes []byte, cpuFunctionGroup uint8, cpuFunctionType uint8, cpuSubfunction uint8) (S7PayloadUserDataItemClkSetRequest, error) { + return S7PayloadUserDataItemClkSetRequestParseWithBuffer(ctx, utils.NewReadBufferByteBased(theBytes), cpuFunctionGroup, cpuFunctionType, cpuSubfunction) +} + +func S7PayloadUserDataItemClkSetRequestParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, cpuFunctionGroup uint8, cpuFunctionType uint8, cpuSubfunction uint8) (S7PayloadUserDataItemClkSetRequest, error) { + positionAware := readBuffer + _ = positionAware + log := zerolog.Ctx(ctx) + _ = log + if pullErr := readBuffer.PullContext("S7PayloadUserDataItemClkSetRequest"); pullErr != nil { + return nil, errors.Wrap(pullErr, "Error pulling for S7PayloadUserDataItemClkSetRequest") + } + currentPos := positionAware.GetPos() + _ = currentPos + + var reservedField0 *uint8 + // Reserved Field (Compartmentalized so the "reserved" variable can't leak) + { + reserved, _err := readBuffer.ReadUint8("reserved", 8) + if _err != nil { + return nil, errors.Wrap(_err, "Error parsing 'reserved' field of S7PayloadUserDataItemClkSetRequest") + } + if reserved != uint8(0x00) { + log.Info().Fields(map[string]any{ + "expected value": uint8(0x00), + "got value": reserved, + }).Msg("Got unexpected response for reserved field.") + // We save the value, so it can be re-serialized + reservedField0 = &reserved + } + } + + var reservedField1 *uint8 + // Reserved Field (Compartmentalized so the "reserved" variable can't leak) + { + reserved, _err := readBuffer.ReadUint8("reserved", 8) + if _err != nil { + return nil, errors.Wrap(_err, "Error parsing 'reserved' field of S7PayloadUserDataItemClkSetRequest") + } + if reserved != uint8(0x00) { + log.Info().Fields(map[string]any{ + "expected value": uint8(0x00), + "got value": reserved, + }).Msg("Got unexpected response for reserved field.") + // We save the value, so it can be re-serialized + reservedField1 = &reserved + } + } + + // Simple Field (TimeStamp) + if pullErr := readBuffer.PullContext("TimeStamp"); pullErr != nil { + return nil, errors.Wrap(pullErr, "Error pulling for TimeStamp") + } + _TimeStamp, _TimeStampErr := DateAndTimeParseWithBuffer(ctx, readBuffer) + if _TimeStampErr != nil { + return nil, errors.Wrap(_TimeStampErr, "Error parsing 'TimeStamp' field of S7PayloadUserDataItemClkSetRequest") + } + TimeStamp := _TimeStamp.(DateAndTime) + if closeErr := readBuffer.CloseContext("TimeStamp"); closeErr != nil { + return nil, errors.Wrap(closeErr, "Error closing for TimeStamp") + } + + if closeErr := readBuffer.CloseContext("S7PayloadUserDataItemClkSetRequest"); closeErr != nil { + return nil, errors.Wrap(closeErr, "Error closing for S7PayloadUserDataItemClkSetRequest") + } + + // Create a partially initialized instance + _child := &_S7PayloadUserDataItemClkSetRequest{ + _S7PayloadUserDataItem: &_S7PayloadUserDataItem{}, + TimeStamp: TimeStamp, + reservedField0: reservedField0, + reservedField1: reservedField1, + } + _child._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _child + return _child, nil +} + +func (m *_S7PayloadUserDataItemClkSetRequest) Serialize() ([]byte, error) { + wb := utils.NewWriteBufferByteBased(utils.WithInitialSizeForByteBasedBuffer(int(m.GetLengthInBytes(context.Background())))) + if err := m.SerializeWithWriteBuffer(context.Background(), wb); err != nil { + return nil, err + } + return wb.GetBytes(), nil +} + +func (m *_S7PayloadUserDataItemClkSetRequest) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error { + positionAware := writeBuffer + _ = positionAware + log := zerolog.Ctx(ctx) + _ = log + ser := func() error { + if pushErr := writeBuffer.PushContext("S7PayloadUserDataItemClkSetRequest"); pushErr != nil { + return errors.Wrap(pushErr, "Error pushing for S7PayloadUserDataItemClkSetRequest") + } + + // Reserved Field (reserved) + { + var reserved uint8 = uint8(0x00) + if m.reservedField0 != nil { + log.Info().Fields(map[string]any{ + "expected value": uint8(0x00), + "got value": reserved, + }).Msg("Overriding reserved field with unexpected value.") + reserved = *m.reservedField0 + } + _err := writeBuffer.WriteUint8("reserved", 8, reserved) + if _err != nil { + return errors.Wrap(_err, "Error serializing 'reserved' field") + } + } + + // Reserved Field (reserved) + { + var reserved uint8 = uint8(0x00) + if m.reservedField1 != nil { + log.Info().Fields(map[string]any{ + "expected value": uint8(0x00), + "got value": reserved, + }).Msg("Overriding reserved field with unexpected value.") + reserved = *m.reservedField1 + } + _err := writeBuffer.WriteUint8("reserved", 8, reserved) + if _err != nil { + return errors.Wrap(_err, "Error serializing 'reserved' field") + } + } + + // Simple Field (TimeStamp) + if pushErr := writeBuffer.PushContext("TimeStamp"); pushErr != nil { + return errors.Wrap(pushErr, "Error pushing for TimeStamp") + } + _TimeStampErr := writeBuffer.WriteSerializable(ctx, m.GetTimeStamp()) + if popErr := writeBuffer.PopContext("TimeStamp"); popErr != nil { + return errors.Wrap(popErr, "Error popping for TimeStamp") + } + if _TimeStampErr != nil { + return errors.Wrap(_TimeStampErr, "Error serializing 'TimeStamp' field") + } + + if popErr := writeBuffer.PopContext("S7PayloadUserDataItemClkSetRequest"); popErr != nil { + return errors.Wrap(popErr, "Error popping for S7PayloadUserDataItemClkSetRequest") + } + return nil + } + return m.SerializeParent(ctx, writeBuffer, m, ser) +} + +func (m *_S7PayloadUserDataItemClkSetRequest) isS7PayloadUserDataItemClkSetRequest() bool { + return true +} + +func (m *_S7PayloadUserDataItemClkSetRequest) String() string { + if m == nil { + return "" + } + writeBuffer := utils.NewWriteBufferBoxBasedWithOptions(true, true) + if err := writeBuffer.WriteSerializable(context.Background(), m); err != nil { + return err.Error() + } + return writeBuffer.GetBox().String() +} diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkSetResponse.go b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkSetResponse.go new file mode 100644 index 00000000000..f5ddd674129 --- /dev/null +++ b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkSetResponse.go @@ -0,0 +1,184 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package model + +import ( + "context" + "fmt" + "github.com/apache/plc4x/plc4go/spi/utils" + "github.com/pkg/errors" + "github.com/rs/zerolog" +) + +// Code generated by code-generation. DO NOT EDIT. + +// S7PayloadUserDataItemClkSetResponse is the corresponding interface of S7PayloadUserDataItemClkSetResponse +type S7PayloadUserDataItemClkSetResponse interface { + fmt.Stringer + utils.LengthAware + utils.Serializable + S7PayloadUserDataItem +} + +// S7PayloadUserDataItemClkSetResponseExactly can be used when we want exactly this type and not a type which fulfills S7PayloadUserDataItemClkSetResponse. +// This is useful for switch cases. +type S7PayloadUserDataItemClkSetResponseExactly interface { + S7PayloadUserDataItemClkSetResponse + isS7PayloadUserDataItemClkSetResponse() bool +} + +// _S7PayloadUserDataItemClkSetResponse is the data-structure of this message +type _S7PayloadUserDataItemClkSetResponse struct { + *_S7PayloadUserDataItem +} + +/////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////// +/////////////////////// Accessors for discriminator values. +/////////////////////// + +func (m *_S7PayloadUserDataItemClkSetResponse) GetCpuFunctionGroup() uint8 { + return 0x07 +} + +func (m *_S7PayloadUserDataItemClkSetResponse) GetCpuFunctionType() uint8 { + return 0x08 +} + +func (m *_S7PayloadUserDataItemClkSetResponse) GetCpuSubfunction() uint8 { + return 0x04 +} + +/////////////////////// +/////////////////////// +/////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////// + +func (m *_S7PayloadUserDataItemClkSetResponse) InitializeParent(parent S7PayloadUserDataItem, returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) { + m.ReturnCode = returnCode + m.TransportSize = transportSize + m.DataLength = dataLength +} + +func (m *_S7PayloadUserDataItemClkSetResponse) GetParent() S7PayloadUserDataItem { + return m._S7PayloadUserDataItem +} + +// NewS7PayloadUserDataItemClkSetResponse factory function for _S7PayloadUserDataItemClkSetResponse +func NewS7PayloadUserDataItemClkSetResponse(returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) *_S7PayloadUserDataItemClkSetResponse { + _result := &_S7PayloadUserDataItemClkSetResponse{ + _S7PayloadUserDataItem: NewS7PayloadUserDataItem(returnCode, transportSize, dataLength), + } + _result._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _result + return _result +} + +// Deprecated: use the interface for direct cast +func CastS7PayloadUserDataItemClkSetResponse(structType any) S7PayloadUserDataItemClkSetResponse { + if casted, ok := structType.(S7PayloadUserDataItemClkSetResponse); ok { + return casted + } + if casted, ok := structType.(*S7PayloadUserDataItemClkSetResponse); ok { + return *casted + } + return nil +} + +func (m *_S7PayloadUserDataItemClkSetResponse) GetTypeName() string { + return "S7PayloadUserDataItemClkSetResponse" +} + +func (m *_S7PayloadUserDataItemClkSetResponse) GetLengthInBits(ctx context.Context) uint16 { + lengthInBits := uint16(m.GetParentLengthInBits(ctx)) + + return lengthInBits +} + +func (m *_S7PayloadUserDataItemClkSetResponse) GetLengthInBytes(ctx context.Context) uint16 { + return m.GetLengthInBits(ctx) / 8 +} + +func S7PayloadUserDataItemClkSetResponseParse(ctx context.Context, theBytes []byte, cpuFunctionGroup uint8, cpuFunctionType uint8, cpuSubfunction uint8) (S7PayloadUserDataItemClkSetResponse, error) { + return S7PayloadUserDataItemClkSetResponseParseWithBuffer(ctx, utils.NewReadBufferByteBased(theBytes), cpuFunctionGroup, cpuFunctionType, cpuSubfunction) +} + +func S7PayloadUserDataItemClkSetResponseParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, cpuFunctionGroup uint8, cpuFunctionType uint8, cpuSubfunction uint8) (S7PayloadUserDataItemClkSetResponse, error) { + positionAware := readBuffer + _ = positionAware + log := zerolog.Ctx(ctx) + _ = log + if pullErr := readBuffer.PullContext("S7PayloadUserDataItemClkSetResponse"); pullErr != nil { + return nil, errors.Wrap(pullErr, "Error pulling for S7PayloadUserDataItemClkSetResponse") + } + currentPos := positionAware.GetPos() + _ = currentPos + + if closeErr := readBuffer.CloseContext("S7PayloadUserDataItemClkSetResponse"); closeErr != nil { + return nil, errors.Wrap(closeErr, "Error closing for S7PayloadUserDataItemClkSetResponse") + } + + // Create a partially initialized instance + _child := &_S7PayloadUserDataItemClkSetResponse{ + _S7PayloadUserDataItem: &_S7PayloadUserDataItem{}, + } + _child._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _child + return _child, nil +} + +func (m *_S7PayloadUserDataItemClkSetResponse) Serialize() ([]byte, error) { + wb := utils.NewWriteBufferByteBased(utils.WithInitialSizeForByteBasedBuffer(int(m.GetLengthInBytes(context.Background())))) + if err := m.SerializeWithWriteBuffer(context.Background(), wb); err != nil { + return nil, err + } + return wb.GetBytes(), nil +} + +func (m *_S7PayloadUserDataItemClkSetResponse) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error { + positionAware := writeBuffer + _ = positionAware + log := zerolog.Ctx(ctx) + _ = log + ser := func() error { + if pushErr := writeBuffer.PushContext("S7PayloadUserDataItemClkSetResponse"); pushErr != nil { + return errors.Wrap(pushErr, "Error pushing for S7PayloadUserDataItemClkSetResponse") + } + + if popErr := writeBuffer.PopContext("S7PayloadUserDataItemClkSetResponse"); popErr != nil { + return errors.Wrap(popErr, "Error popping for S7PayloadUserDataItemClkSetResponse") + } + return nil + } + return m.SerializeParent(ctx, writeBuffer, m, ser) +} + +func (m *_S7PayloadUserDataItemClkSetResponse) isS7PayloadUserDataItemClkSetResponse() bool { + return true +} + +func (m *_S7PayloadUserDataItemClkSetResponse) String() string { + if m == nil { + return "" + } + writeBuffer := utils.NewWriteBufferBoxBasedWithOptions(true, true) + if err := writeBuffer.WriteSerializable(context.Background(), m); err != nil { + return err.Error() + } + return writeBuffer.GetBox().String() +}