// Go support for Protocol Buffers - Google's data interchange format

//

// Copyright 2010 The Go Authors.  All rights reserved.

// https://github.com/golang/protobuf

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//     * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package proto

/*

 * Support for message sets.

 */

import (

	"errors"

)

// errNoMessageTypeID occurs when a protocol buffer does not have a message type ID.

// A message type ID is required for storing a protocol buffer in a message set.

var errNoMessageTypeID = errors.New("proto does not have a message type ID")

// The first two types (_MessageSet_Item and messageSet)

// model what the protocol compiler produces for the following protocol message:

//   message MessageSet {

//     repeated group Item = 1 {

//       required int32 type_id = 2;

//       required string message = 3;

//     };

//   }

// That is the MessageSet wire format. We can't use a proto to generate these

// because that would introduce a circular dependency between it and this package.

type _MessageSet_Item struct {

	TypeId  *int32 `protobuf:"varint,2,req,name=type_id"`

	Message []byte `protobuf:"bytes,3,req,name=message"`

}

type messageSet struct {

	Item             []*_MessageSet_Item `protobuf:"group,1,rep"`

	XXX_unrecognized []byte

	// TODO: caching?

}

// Make sure messageSet is a Message.

var _ Message = (*messageSet)(nil)

// messageTypeIder is an interface satisfied by a protocol buffer type

// that may be stored in a MessageSet.

type messageTypeIder interface {

	MessageTypeId() int32

}

func (ms *messageSet) find(pb Message) *_MessageSet_Item {

	mti, ok := pb.(messageTypeIder)

	if !ok {

		return nil

	}

	id := mti.MessageTypeId()

	for _, item := range ms.Item {

		if *item.TypeId == id {

			return item

		}

	}

	return nil

}

func (ms *messageSet) Has(pb Message) bool {

	return ms.find(pb) != nil

}

func (ms *messageSet) Unmarshal(pb Message) error {

	if item := ms.find(pb); item != nil {

		return Unmarshal(item.Message, pb)

	}

	if _, ok := pb.(messageTypeIder); !ok {

		return errNoMessageTypeID

	}

	return nil // TODO: return error instead?

}

func (ms *messageSet) Marshal(pb Message) error {

	msg, err := Marshal(pb)

	if err != nil {

		return err

	}

	if item := ms.find(pb); item != nil {

		// reuse existing item

		item.Message = msg

		return nil

	}

	mti, ok := pb.(messageTypeIder)

	if !ok {

		return errNoMessageTypeID

	}

	mtid := mti.MessageTypeId()

	ms.Item = append(ms.Item, &_MessageSet_Item{

		TypeId:  &mtid,

		Message: msg,

	})

	return nil

}

func (ms *messageSet) Reset()         { *ms = messageSet{} }

func (ms *messageSet) String() string { return CompactTextString(ms) }

func (*messageSet) ProtoMessage()     {}

// Support for the message_set_wire_format message option.

func skipVarint(buf []byte) []byte {

	i := 0

	for ; buf[i]&0x80 != 0; i++ {

	}

	return buf[i+1:]

}

// It is called by Unmarshal methods on protocol buffer messages with the message_set_wire_format option.

	var m map[int32]Extension

	switch exts := exts.(type) {

	case *XXX_InternalExtensions:

		m = exts.extensionsWrite()

	case map[int32]Extension:

		m = exts

	default:

		return errors.New("proto: not an extension map")

	}

	ms := new(messageSet)

	if err := Unmarshal(buf, ms); err != nil {

		return err

	}

	for _, item := range ms.Item {

		id := *item.TypeId

		msg := item.Message

		// Restore wire type and field number varint, plus length varint.

		// Be careful to preserve duplicate items.

		b := EncodeVarint(uint64(id)<<3 | WireBytes)

		if ext, ok := m[id]; ok {

			// Existing data; rip off the tag and length varint

			// so we join the new data correctly.

			// We can assume that ext.enc is set because we are unmarshaling.

			o := ext.enc[len(b):]   // skip wire type and field number

			_, n := DecodeVarint(o) // calculate length of length varint

			o = o[n:]               // skip length varint

			msg = append(o, msg...) // join old data and new data

		}

		b = append(b, EncodeVarint(uint64(len(msg)))...)

		b = append(b, msg...)

		m[id] = Extension{enc: b}

	}

	return nil

}