plc4go/protocols/ads/readwrite/model/AdsMethodParam.go

/*
 * 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"
	stdErrors "errors"
	"fmt"

	"github.com/rs/zerolog"

	. "github.com/apache/plc4x/plc4go/spi/codegen/fields"
	. "github.com/apache/plc4x/plc4go/spi/codegen/io"
	"github.com/apache/plc4x/plc4go/spi/errors"
	"github.com/apache/plc4x/plc4go/spi/utils"
)

// Code generated by code-generation. DO NOT EDIT.

// Constant values.
const AdsMethodParam_NAMETERMINATOR uint8 = 0x00
const AdsMethodParam_TYPENAMETERMINATOR uint8 = 0x00
const AdsMethodParam_COMMENTTERMINATOR uint8 = 0x00

// AdsMethodParam is the corresponding interface of AdsMethodParam
// A single parameter descriptor. Matches your “tail”: length + 5 headers + GUID +
// optional ids/flags + lengths + strings + terminators.
type AdsMethodParam interface {
	fmt.Stringer
	utils.LengthAware
	utils.Serializable
	utils.Copyable
	// GetHeader1 returns Header1 (property field)
	GetHeader1() uint32
	// GetHeader2 returns Header2 (property field)
	GetHeader2() uint32
	// GetHeader3 returns Header3 (property field)
	GetHeader3() uint32
	// GetHeader4 returns Header4 (property field)
	GetHeader4() uint32
	// GetHeader5 returns Header5 (property field)
	GetHeader5() uint32
	// GetGuid returns Guid (property field)
	GetGuid() []byte
	// GetName returns Name (property field)
	GetName() string
	// GetTypeName returns TypeName (property field)
	GetTypeName() string
	// GetComment returns Comment (property field)
	GetComment() string
	// IsAdsMethodParam is a marker method to prevent unintentional type checks (interfaces of same signature)
	IsAdsMethodParam()
	// CreateBuilder creates a AdsMethodParamBuilder
	CreateAdsMethodParamBuilder() AdsMethodParamBuilder
}

// _AdsMethodParam is the data-structure of this message
type _AdsMethodParam struct {
	Header1  uint32
	Header2  uint32
	Header3  uint32
	Header4  uint32
	Header5  uint32
	Guid     []byte
	Name     string
	TypeName string
	Comment  string
	// Reserved Fields
	reservedField0 *uint16
}

var _ AdsMethodParam = (*_AdsMethodParam)(nil)

// NewAdsMethodParam factory function for _AdsMethodParam
func NewAdsMethodParam(header1 uint32, header2 uint32, header3 uint32, header4 uint32, header5 uint32, guid []byte, name string, typeName string, comment string) *_AdsMethodParam {
	return &_AdsMethodParam{Header1: header1, Header2: header2, Header3: header3, Header4: header4, Header5: header5, Guid: guid, Name: name, TypeName: typeName, Comment: comment}
}

///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
/////////////////////// Builder
///////////////////////

// AdsMethodParamBuilder is a builder for AdsMethodParam
type AdsMethodParamBuilder interface {
	utils.Copyable
	// WithMandatoryFields adds all mandatory fields (convenience for using multiple builder calls)
	WithMandatoryFields(header1 uint32, header2 uint32, header3 uint32, header4 uint32, header5 uint32, guid []byte, name string, typeName string, comment string) AdsMethodParamBuilder
	// WithHeader1 adds Header1 (property field)
	WithHeader1(uint32) AdsMethodParamBuilder
	// WithHeader2 adds Header2 (property field)
	WithHeader2(uint32) AdsMethodParamBuilder
	// WithHeader3 adds Header3 (property field)
	WithHeader3(uint32) AdsMethodParamBuilder
	// WithHeader4 adds Header4 (property field)
	WithHeader4(uint32) AdsMethodParamBuilder
	// WithHeader5 adds Header5 (property field)
	WithHeader5(uint32) AdsMethodParamBuilder
	// WithGuid adds Guid (property field)
	WithGuid(...byte) AdsMethodParamBuilder
	// WithName adds Name (property field)
	WithName(string) AdsMethodParamBuilder
	// WithTypeName adds TypeName (property field)
	WithTypeName(string) AdsMethodParamBuilder
	// WithComment adds Comment (property field)
	WithComment(string) AdsMethodParamBuilder
	// Build builds the AdsMethodParam or returns an error if something is wrong
	Build() (AdsMethodParam, error)
	// MustBuild does the same as Build but panics on error
	MustBuild() AdsMethodParam
}

// NewAdsMethodParamBuilder() creates a AdsMethodParamBuilder
func NewAdsMethodParamBuilder() AdsMethodParamBuilder {
	return &_AdsMethodParamBuilder{_AdsMethodParam: new(_AdsMethodParam)}
}

type _AdsMethodParamBuilder struct {
	*_AdsMethodParam

	collectedErr []error
}

var _ (AdsMethodParamBuilder) = (*_AdsMethodParamBuilder)(nil)

func (b *_AdsMethodParamBuilder) WithMandatoryFields(header1 uint32, header2 uint32, header3 uint32, header4 uint32, header5 uint32, guid []byte, name string, typeName string, comment string) AdsMethodParamBuilder {
	return b.WithHeader1(header1).WithHeader2(header2).WithHeader3(header3).WithHeader4(header4).WithHeader5(header5).WithGuid(guid...).WithName(name).WithTypeName(typeName).WithComment(comment)
}

func (b *_AdsMethodParamBuilder) WithHeader1(header1 uint32) AdsMethodParamBuilder {
	b.Header1 = header1
	return b
}

func (b *_AdsMethodParamBuilder) WithHeader2(header2 uint32) AdsMethodParamBuilder {
	b.Header2 = header2
	return b
}

func (b *_AdsMethodParamBuilder) WithHeader3(header3 uint32) AdsMethodParamBuilder {
	b.Header3 = header3
	return b
}

func (b *_AdsMethodParamBuilder) WithHeader4(header4 uint32) AdsMethodParamBuilder {
	b.Header4 = header4
	return b
}

func (b *_AdsMethodParamBuilder) WithHeader5(header5 uint32) AdsMethodParamBuilder {
	b.Header5 = header5
	return b
}

func (b *_AdsMethodParamBuilder) WithGuid(guid ...byte) AdsMethodParamBuilder {
	b.Guid = guid
	return b
}

func (b *_AdsMethodParamBuilder) WithName(name string) AdsMethodParamBuilder {
	b.Name = name
	return b
}

func (b *_AdsMethodParamBuilder) WithTypeName(typeName string) AdsMethodParamBuilder {
	b.TypeName = typeName
	return b
}

func (b *_AdsMethodParamBuilder) WithComment(comment string) AdsMethodParamBuilder {
	b.Comment = comment
	return b
}

func (b *_AdsMethodParamBuilder) Build() (AdsMethodParam, error) {
	if err := stdErrors.Join(b.collectedErr...); err != nil {
		return nil, errors.Wrap(err, "error occurred during build")
	}
	return b._AdsMethodParam.deepCopy(), nil
}

func (b *_AdsMethodParamBuilder) MustBuild() AdsMethodParam {
	build, err := b.Build()
	if err != nil {
		panic(err)
	}
	return build
}

func (b *_AdsMethodParamBuilder) DeepCopy() any {
	_copy := b.CreateAdsMethodParamBuilder().(*_AdsMethodParamBuilder)
	if b.collectedErr != nil {
		copy(_copy.collectedErr, b.collectedErr)
	}
	return _copy
}

// CreateAdsMethodParamBuilder creates a AdsMethodParamBuilder
func (b *_AdsMethodParam) CreateAdsMethodParamBuilder() AdsMethodParamBuilder {
	if b == nil {
		return NewAdsMethodParamBuilder()
	}
	return &_AdsMethodParamBuilder{_AdsMethodParam: b.deepCopy()}
}

///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
/////////////////////// Accessors for property fields.
///////////////////////

func (m *_AdsMethodParam) GetHeader1() uint32 {
	return m.Header1
}

func (m *_AdsMethodParam) GetHeader2() uint32 {
	return m.Header2
}

func (m *_AdsMethodParam) GetHeader3() uint32 {
	return m.Header3
}

func (m *_AdsMethodParam) GetHeader4() uint32 {
	return m.Header4
}

func (m *_AdsMethodParam) GetHeader5() uint32 {
	return m.Header5
}

func (m *_AdsMethodParam) GetGuid() []byte {
	return m.Guid
}

func (m *_AdsMethodParam) GetName() string {
	return m.Name
}

func (m *_AdsMethodParam) GetTypeName() string {
	return m.TypeName
}

func (m *_AdsMethodParam) GetComment() string {
	return m.Comment
}

///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
/////////////////////// Accessors for const fields.
///////////////////////

func (m *_AdsMethodParam) GetNameTerminator() uint8 {
	return AdsMethodParam_NAMETERMINATOR
}

func (m *_AdsMethodParam) GetTypeNameTerminator() uint8 {
	return AdsMethodParam_TYPENAMETERMINATOR
}

func (m *_AdsMethodParam) GetCommentTerminator() uint8 {
	return AdsMethodParam_COMMENTTERMINATOR
}

///////////////////////
///////////////////////
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////

// Deprecated: use the interface for direct cast
func CastAdsMethodParam(structType any) AdsMethodParam {
	if casted, ok := structType.(AdsMethodParam); ok {
		return casted
	}
	if casted, ok := structType.(*AdsMethodParam); ok {
		return *casted
	}
	return nil
}

func (m *_AdsMethodParam) GetPlx4xTypeName() string {
	return "AdsMethodParam"
}

func (m *_AdsMethodParam) GetLengthInBits(ctx context.Context) uint16 {
	lengthInBits := uint16(0)

	// Implicit Field (paramLength)
	lengthInBits += 32

	// Simple field (header1)
	lengthInBits += 32

	// Simple field (header2)
	lengthInBits += 32

	// Simple field (header3)
	lengthInBits += 32

	// Simple field (header4)
	lengthInBits += 32

	// Simple field (header5)
	lengthInBits += 32

	// Array field
	if len(m.Guid) > 0 {
		lengthInBits += 8 * uint16(len(m.Guid))
	}

	// Reserved Field (reserved)
	lengthInBits += 16

	// Implicit Field (nameLength)
	lengthInBits += 16

	// Implicit Field (typeNameLength)
	lengthInBits += 16

	// Implicit Field (commentLength)
	lengthInBits += 16

	// Simple field (name)
	lengthInBits += uint16(int32(uint16(len(m.GetName()))) * int32(int32(8)))

	// Const Field (nameTerminator)
	lengthInBits += 8

	// Simple field (typeName)
	lengthInBits += uint16(int32(uint16(len(m.GetTypeName()))) * int32(int32(8)))

	// Const Field (typeNameTerminator)
	lengthInBits += 8

	// Simple field (comment)
	lengthInBits += uint16(int32(uint16(len(m.GetComment()))) * int32(int32(8)))

	// Const Field (commentTerminator)
	lengthInBits += 8

	return lengthInBits
}

func (m *_AdsMethodParam) GetLengthInBytes(ctx context.Context) uint16 {
	return m.GetLengthInBits(ctx) / 8
}

func AdsMethodParamParse(ctx context.Context, theBytes []byte) (AdsMethodParam, error) {
	return AdsMethodParamParseWithBuffer(ctx, utils.NewReadBufferByteBased(theBytes))
}

func AdsMethodParamParseWithBufferProducer() func(ctx context.Context, readBuffer utils.ReadBuffer) (AdsMethodParam, error) {
	return func(ctx context.Context, readBuffer utils.ReadBuffer) (AdsMethodParam, error) {
		return AdsMethodParamParseWithBuffer(ctx, readBuffer)
	}
}

func AdsMethodParamParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer) (AdsMethodParam, error) {
	v, err := (new(_AdsMethodParam)).parse(ctx, readBuffer)
	if err != nil {
		return nil, err
	}
	return v, nil
}

func (m *_AdsMethodParam) parse(ctx context.Context, readBuffer utils.ReadBuffer) (__adsMethodParam AdsMethodParam, err error) {
	positionAware := readBuffer
	_ = positionAware
	if pullErr := readBuffer.PullContext("AdsMethodParam"); pullErr != nil {
		return nil, errors.Wrap(pullErr, "Error pulling for AdsMethodParam")
	}
	currentPos := positionAware.GetPos()
	_ = currentPos

	paramLength, err := ReadImplicitField[uint32](ctx, "paramLength", ReadUnsignedInt(readBuffer, uint8(32)))
	if err != nil {
		return nil, errors.Wrap(err, fmt.Sprintf("Error parsing 'paramLength' field"))
	}
	_ = paramLength

	header1, err := ReadSimpleField(ctx, "header1", ReadUnsignedInt(readBuffer, uint8(32)))
	if err != nil {
		return nil, errors.Wrap(err, fmt.Sprintf("Error parsing 'header1' field"))
	}
	m.Header1 = header1

	header2, err := ReadSimpleField(ctx, "header2", ReadUnsignedInt(readBuffer, uint8(32)))
	if err != nil {
		return nil, errors.Wrap(err, fmt.Sprintf("Error parsing 'header2' field"))
	}
	m.Header2 = header2

	header3, err := ReadSimpleField(ctx, "header3", ReadUnsignedInt(readBuffer, uint8(32)))
	if err != nil {
		return nil, errors.Wrap(err, fmt.Sprintf("Error parsing 'header3' field"))
	}
	m.Header3 = header3

	header4, err := ReadSimpleField(ctx, "header4", ReadUnsignedInt(readBuffer, uint8(32)))
	if err != nil {
		return nil, errors.Wrap(err, fmt.Sprintf("Error parsing 'header4' field"))
	}
	m.Header4 = header4

	header5, err := ReadSimpleField(ctx, "header5", ReadUnsignedInt(readBuffer, uint8(32)))
	if err != nil {
		return nil, errors.Wrap(err, fmt.Sprintf("Error parsing 'header5' field"))
	}
	m.Header5 = header5

	guid, err := readBuffer.ReadByteArray("guid", int(int32(16)))
	if err != nil {
		return nil, errors.Wrap(err, fmt.Sprintf("Error parsing 'guid' field"))
	}
	m.Guid = guid

	reservedField0, err := ReadReservedField(ctx, "reserved", ReadUnsignedShort(readBuffer, uint8(16)), uint16(0x0000))
	if err != nil {
		return nil, errors.Wrap(err, fmt.Sprintf("Error parsing reserved field"))
	}
	m.reservedField0 = reservedField0

	nameLength, err := ReadImplicitField[uint16](ctx, "nameLength", ReadUnsignedShort(readBuffer, uint8(16)))
	if err != nil {
		return nil, errors.Wrap(err, fmt.Sprintf("Error parsing 'nameLength' field"))
	}
	_ = nameLength

	typeNameLength, err := ReadImplicitField[uint16](ctx, "typeNameLength", ReadUnsignedShort(readBuffer, uint8(16)))
	if err != nil {
		return nil, errors.Wrap(err, fmt.Sprintf("Error parsing 'typeNameLength' field"))
	}
	_ = typeNameLength

	commentLength, err := ReadImplicitField[uint16](ctx, "commentLength", ReadUnsignedShort(readBuffer, uint8(16)))
	if err != nil {
		return nil, errors.Wrap(err, fmt.Sprintf("Error parsing 'commentLength' field"))
	}
	_ = commentLength

	name, err := ReadSimpleField(ctx, "name", ReadString(readBuffer, uint32(int32(nameLength)*int32(int32(8)))))
	if err != nil {
		return nil, errors.Wrap(err, fmt.Sprintf("Error parsing 'name' field"))
	}
	m.Name = name

	nameTerminator, err := ReadConstField[uint8](ctx, "nameTerminator", ReadUnsignedByte(readBuffer, uint8(8)), AdsMethodParam_NAMETERMINATOR)
	if err != nil {
		return nil, errors.Wrap(err, fmt.Sprintf("Error parsing 'nameTerminator' field"))
	}
	_ = nameTerminator

	typeName, err := ReadSimpleField(ctx, "typeName", ReadString(readBuffer, uint32(int32(typeNameLength)*int32(int32(8)))))
	if err != nil {
		return nil, errors.Wrap(err, fmt.Sprintf("Error parsing 'typeName' field"))
	}
	m.TypeName = typeName

	typeNameTerminator, err := ReadConstField[uint8](ctx, "typeNameTerminator", ReadUnsignedByte(readBuffer, uint8(8)), AdsMethodParam_TYPENAMETERMINATOR)
	if err != nil {
		return nil, errors.Wrap(err, fmt.Sprintf("Error parsing 'typeNameTerminator' field"))
	}
	_ = typeNameTerminator

	comment, err := ReadSimpleField(ctx, "comment", ReadString(readBuffer, uint32(int32(commentLength)*int32(int32(8)))))
	if err != nil {
		return nil, errors.Wrap(err, fmt.Sprintf("Error parsing 'comment' field"))
	}
	m.Comment = comment

	commentTerminator, err := ReadConstField[uint8](ctx, "commentTerminator", ReadUnsignedByte(readBuffer, uint8(8)), AdsMethodParam_COMMENTTERMINATOR)
	if err != nil {
		return nil, errors.Wrap(err, fmt.Sprintf("Error parsing 'commentTerminator' field"))
	}
	_ = commentTerminator

	if closeErr := readBuffer.CloseContext("AdsMethodParam"); closeErr != nil {
		return nil, errors.Wrap(closeErr, "Error closing for AdsMethodParam")
	}

	return m, nil
}

func (m *_AdsMethodParam) 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 *_AdsMethodParam) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error {
	positionAware := writeBuffer
	_ = positionAware
	log := zerolog.Ctx(ctx)
	_ = log
	if pushErr := writeBuffer.PushContext("AdsMethodParam"); pushErr != nil {
		return errors.Wrap(pushErr, "Error pushing for AdsMethodParam")
	}
	paramLength := uint32(uint32(m.GetLengthInBytes(ctx)))
	if err := WriteImplicitField(ctx, "paramLength", paramLength, WriteUnsignedInt(writeBuffer, 32)); err != nil {
		return errors.Wrap(err, "Error serializing 'paramLength' field")
	}

	if err := WriteSimpleField[uint32](ctx, "header1", m.GetHeader1(), WriteUnsignedInt(writeBuffer, 32)); err != nil {
		return errors.Wrap(err, "Error serializing 'header1' field")
	}

	if err := WriteSimpleField[uint32](ctx, "header2", m.GetHeader2(), WriteUnsignedInt(writeBuffer, 32)); err != nil {
		return errors.Wrap(err, "Error serializing 'header2' field")
	}

	if err := WriteSimpleField[uint32](ctx, "header3", m.GetHeader3(), WriteUnsignedInt(writeBuffer, 32)); err != nil {
		return errors.Wrap(err, "Error serializing 'header3' field")
	}

	if err := WriteSimpleField[uint32](ctx, "header4", m.GetHeader4(), WriteUnsignedInt(writeBuffer, 32)); err != nil {
		return errors.Wrap(err, "Error serializing 'header4' field")
	}

	if err := WriteSimpleField[uint32](ctx, "header5", m.GetHeader5(), WriteUnsignedInt(writeBuffer, 32)); err != nil {
		return errors.Wrap(err, "Error serializing 'header5' field")
	}

	if err := WriteByteArrayField(ctx, "guid", m.GetGuid(), WriteByteArray(writeBuffer, 8)); err != nil {
		return errors.Wrap(err, "Error serializing 'guid' field")
	}

	if err := WriteReservedField[uint16](ctx, "reserved", uint16(0x0000), WriteUnsignedShort(writeBuffer, 16)); err != nil {
		return errors.Wrap(err, "Error serializing 'reserved' field number 1")
	}
	nameLength := uint16(uint16(len(m.GetName())))
	if err := WriteImplicitField(ctx, "nameLength", nameLength, WriteUnsignedShort(writeBuffer, 16)); err != nil {
		return errors.Wrap(err, "Error serializing 'nameLength' field")
	}
	typeNameLength := uint16(uint16(len(m.GetTypeName())))
	if err := WriteImplicitField(ctx, "typeNameLength", typeNameLength, WriteUnsignedShort(writeBuffer, 16)); err != nil {
		return errors.Wrap(err, "Error serializing 'typeNameLength' field")
	}
	commentLength := uint16(uint16(len(m.GetComment())))
	if err := WriteImplicitField(ctx, "commentLength", commentLength, WriteUnsignedShort(writeBuffer, 16)); err != nil {
		return errors.Wrap(err, "Error serializing 'commentLength' field")
	}

	if err := WriteSimpleField[string](ctx, "name", m.GetName(), WriteString(writeBuffer, int32(int32(uint16(len(m.GetName())))*int32(int32(8))))); err != nil {
		return errors.Wrap(err, "Error serializing 'name' field")
	}

	if err := WriteConstField(ctx, "nameTerminator", AdsMethodParam_NAMETERMINATOR, WriteUnsignedByte(writeBuffer, 8)); err != nil {
		return errors.Wrap(err, "Error serializing 'nameTerminator' field")
	}

	if err := WriteSimpleField[string](ctx, "typeName", m.GetTypeName(), WriteString(writeBuffer, int32(int32(uint16(len(m.GetTypeName())))*int32(int32(8))))); err != nil {
		return errors.Wrap(err, "Error serializing 'typeName' field")
	}

	if err := WriteConstField(ctx, "typeNameTerminator", AdsMethodParam_TYPENAMETERMINATOR, WriteUnsignedByte(writeBuffer, 8)); err != nil {
		return errors.Wrap(err, "Error serializing 'typeNameTerminator' field")
	}

	if err := WriteSimpleField[string](ctx, "comment", m.GetComment(), WriteString(writeBuffer, int32(int32(uint16(len(m.GetComment())))*int32(int32(8))))); err != nil {
		return errors.Wrap(err, "Error serializing 'comment' field")
	}

	if err := WriteConstField(ctx, "commentTerminator", AdsMethodParam_COMMENTTERMINATOR, WriteUnsignedByte(writeBuffer, 8)); err != nil {
		return errors.Wrap(err, "Error serializing 'commentTerminator' field")
	}

	if popErr := writeBuffer.PopContext("AdsMethodParam"); popErr != nil {
		return errors.Wrap(popErr, "Error popping for AdsMethodParam")
	}
	return nil
}

func (m *_AdsMethodParam) IsAdsMethodParam() {}

func (m *_AdsMethodParam) DeepCopy() any {
	return m.deepCopy()
}

func (m *_AdsMethodParam) deepCopy() *_AdsMethodParam {
	if m == nil {
		return nil
	}
	_AdsMethodParamCopy := &_AdsMethodParam{
		m.Header1,
		m.Header2,
		m.Header3,
		m.Header4,
		m.Header5,
		utils.DeepCopySlice[byte, byte](m.Guid),
		m.Name,
		m.TypeName,
		m.Comment,
		m.reservedField0,
	}
	return _AdsMethodParamCopy
}

func (m *_AdsMethodParam) String() string {
	if m == nil {
		return "<nil>"
	}
	wb := utils.NewWriteBufferBoxBased(
		utils.WithWriteBufferBoxBasedMergeSingleBoxes(),
		utils.WithWriteBufferBoxBasedOmitEmptyBoxes(),
		utils.WithWriteBufferBoxBasedPrintPosLengthFooter(),
	)
	if err := wb.WriteSerializable(context.Background(), m); err != nil {
		return err.Error()
	}
	return wb.GetBox().String()
}