// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package impl

import (
	

	
	
	
	
)

func sizeMessageSet( *MessageInfo,  pointer,  marshalOptions) ( int) {
	if !flags.ProtoLegacy {
		return 0
	}

	 := *.Apply(.extensionOffset).Extensions()
	for ,  := range  {
		 := getExtensionFieldInfo(.Type())
		if .funcs.size == nil {
			continue
		}
		,  := protowire.DecodeTag(.wiretag)
		 += messageset.SizeField()
		if fullyLazyExtensions() {
			// Don't expand the extension, instead use the buffer to calculate size
			if  := .lazyBuffer();  != nil {
				// We got hold of the buffer, so it's still lazy.
				// Don't count the tag size in the extension buffer, it's already added.
				 += protowire.SizeTag(messageset.FieldMessage) + len() - .tagsize
				continue
			}
		}
		 += .funcs.size(.Value(), protowire.SizeTag(messageset.FieldMessage), )
	}

	if  := .getUnknownBytes();  != nil {
		 += messageset.SizeUnknown(*)
	}

	return 
}

func marshalMessageSet( *MessageInfo,  []byte,  pointer,  marshalOptions) ([]byte, error) {
	if !flags.ProtoLegacy {
		return , errors.New("no support for message_set_wire_format")
	}

	 := *.Apply(.extensionOffset).Extensions()
	switch len() {
	case 0:
	case 1:
		// Fast-path for one extension: Don't bother sorting the keys.
		for ,  := range  {
			var  error
			,  = marshalMessageSetField(, , , )
			if  != nil {
				return , 
			}
		}
	default:
		// Sort the keys to provide a deterministic encoding.
		// Not sure this is required, but the old code does it.
		 := make([]int, 0, len())
		for  := range  {
			 = append(, int())
		}
		sort.Ints()
		for ,  := range  {
			var  error
			,  = marshalMessageSetField(, , [int32()], )
			if  != nil {
				return , 
			}
		}
	}

	if  := .getUnknownBytes();  != nil {
		var  error
		,  = messageset.AppendUnknown(, *)
		if  != nil {
			return , 
		}
	}

	return , nil
}

func marshalMessageSetField( *MessageInfo,  []byte,  ExtensionField,  marshalOptions) ([]byte, error) {
	 := getExtensionFieldInfo(.Type())
	,  := protowire.DecodeTag(.wiretag)
	 = messageset.AppendFieldStart(, )

	if fullyLazyExtensions() {
		// Don't expand the extension if it's still in wire format, instead use the buffer content.
		if  := .lazyBuffer();  != nil {
			// The tag inside the lazy buffer is a different tag (the extension
			// number), but what we need here is the tag for FieldMessage:
			 = protowire.AppendVarint(, protowire.EncodeTag(messageset.FieldMessage, protowire.BytesType))
			 = append(, [.tagsize:]...)
			 = messageset.AppendFieldEnd()
			return , nil
		}
	}

	,  := .funcs.marshal(, .Value(), protowire.EncodeTag(messageset.FieldMessage, protowire.BytesType), )
	if  != nil {
		return , 
	}
	 = messageset.AppendFieldEnd()
	return , nil
}

func unmarshalMessageSet( *MessageInfo,  []byte,  pointer,  unmarshalOptions) ( unmarshalOutput,  error) {
	if !flags.ProtoLegacy {
		return , errors.New("no support for message_set_wire_format")
	}

	 := .Apply(.extensionOffset).Extensions()
	if * == nil {
		* = make(map[int32]ExtensionField)
	}
	 := *
	 := true
	 = messageset.Unmarshal(, true, func( protowire.Number,  []byte) error {
		,  := .unmarshalExtension(, , protowire.BytesType, , )
		if  == errUnknown {
			 := .mutableUnknownBytes()
			* = protowire.AppendTag(*, , protowire.BytesType)
			* = append(*, ...)
			return nil
		}
		if !.initialized {
			 = false
		}
		return 
	})
	.n = len()
	.initialized = 
	return , 
}