// 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

/*

 * Routines for decoding protocol buffer data to construct in-memory representations.

 */

import (

	"errors"

	"fmt"

	"io"

)

// errOverflow is returned when an integer is too large to be represented.

var errOverflow = errors.New("proto: integer overflow")

// ErrInternalBadWireType is returned by generated code when an incorrect

// wire type is encountered. It does not get returned to user code.

var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")

// DecodeVarint reads a varint-encoded integer from the slice.

// It returns the integer and the number of bytes consumed, or

// zero if there is not enough.

// This is the format for the

// int32, int64, uint32, uint64, bool, and enum

// protocol buffer types.

func DecodeVarint(buf []byte) (x uint64, n int) {

	for shift := uint(0); shift < 64; shift += 7 {

		if n >= len(buf) {

			return 0, 0

		}

		b := uint64(buf[n])

		n++

		x |= (b & 0x7F) << shift

		if (b & 0x80) == 0 {

			return x, n

		}

	}

	// The number is too large to represent in a 64-bit value.

	return 0, 0

}

func (p *Buffer) decodeVarintSlow() (x uint64, err error) {

	i := p.index

	l := len(p.buf)

	for shift := uint(0); shift < 64; shift += 7 {

		if i >= l {

			err = io.ErrUnexpectedEOF

			return

		}

		b := p.buf[i]

		i++

		x |= (uint64(b) & 0x7F) << shift

		if b < 0x80 {

			p.index = i

			return

		}

	}

	// The number is too large to represent in a 64-bit value.

	err = errOverflow

	return

}

// DecodeVarint reads a varint-encoded integer from the Buffer.

// This is the format for the

// int32, int64, uint32, uint64, bool, and enum

// protocol buffer types.

func (p *Buffer) DecodeVarint() (x uint64, err error) {

	i := p.index

	buf := p.buf

	if i >= len(buf) {

		return 0, io.ErrUnexpectedEOF

	} else if buf[i] < 0x80 {

		p.index++

		return uint64(buf[i]), nil

	} else if len(buf)-i < 10 {

		return p.decodeVarintSlow()

	}

	var b uint64

	// we already checked the first byte

	x = uint64(buf[i]) - 0x80

	i++

	b = uint64(buf[i])

	i++

	x += b << 7

	if b&0x80 == 0 {

		goto done

	}

	x -= 0x80 << 7

	b = uint64(buf[i])

	i++

	x += b << 14

	if b&0x80 == 0 {

		goto done

	}

	x -= 0x80 << 14

	b = uint64(buf[i])

	i++

	x += b << 21

	if b&0x80 == 0 {

		goto done

	}

	x -= 0x80 << 21

	b = uint64(buf[i])

	i++

	x += b << 28

	if b&0x80 == 0 {

		goto done

	}

	x -= 0x80 << 28

	b = uint64(buf[i])

	i++

	x += b << 35

	if b&0x80 == 0 {

		goto done

	}

	x -= 0x80 << 35

	b = uint64(buf[i])

	i++

	x += b << 42

	if b&0x80 == 0 {

		goto done

	}

	x -= 0x80 << 42

	b = uint64(buf[i])

	i++

	x += b << 49

	if b&0x80 == 0 {

		goto done

	}

	x -= 0x80 << 49

	b = uint64(buf[i])

	i++

	x += b << 56

	if b&0x80 == 0 {

		goto done

	}

	x -= 0x80 << 56

	b = uint64(buf[i])

	i++

	x += b << 63

	if b&0x80 == 0 {

		goto done

	}

	return 0, errOverflow

done:

	p.index = i

	return x, nil

}

// DecodeFixed64 reads a 64-bit integer from the Buffer.

// This is the format for the

// fixed64, sfixed64, and double protocol buffer types.

func (p *Buffer) DecodeFixed64() (x uint64, err error) {

	// x, err already 0

	i := p.index + 8

	if i < 0 || i > len(p.buf) {

		err = io.ErrUnexpectedEOF

		return

	}

	p.index = i

	x = uint64(p.buf[i-8])

	x |= uint64(p.buf[i-7]) << 8

	x |= uint64(p.buf[i-6]) << 16

	x |= uint64(p.buf[i-5]) << 24

	x |= uint64(p.buf[i-4]) << 32

	x |= uint64(p.buf[i-3]) << 40

	x |= uint64(p.buf[i-2]) << 48

	x |= uint64(p.buf[i-1]) << 56

	return

}

// DecodeFixed32 reads a 32-bit integer from the Buffer.

// This is the format for the

// fixed32, sfixed32, and float protocol buffer types.

func (p *Buffer) DecodeFixed32() (x uint64, err error) {

	// x, err already 0

	i := p.index + 4

	if i < 0 || i > len(p.buf) {

		err = io.ErrUnexpectedEOF

		return

	}

	p.index = i

	x = uint64(p.buf[i-4])

	x |= uint64(p.buf[i-3]) << 8

	x |= uint64(p.buf[i-2]) << 16

	x |= uint64(p.buf[i-1]) << 24

	return

}

// DecodeZigzag64 reads a zigzag-encoded 64-bit integer

// from the Buffer.

// This is the format used for the sint64 protocol buffer type.

func (p *Buffer) DecodeZigzag64() (x uint64, err error) {

	x, err = p.DecodeVarint()

	if err != nil {

		return

	}

	x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63)

	return

}

// DecodeZigzag32 reads a zigzag-encoded 32-bit integer

// from  the Buffer.

// This is the format used for the sint32 protocol buffer type.

func (p *Buffer) DecodeZigzag32() (x uint64, err error) {

	x, err = p.DecodeVarint()

	if err != nil {

		return

	}

	x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31))

	return

}

// DecodeRawBytes reads a count-delimited byte buffer from the Buffer.

// This is the format used for the bytes protocol buffer

// type and for embedded messages.

func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) {

	n, err := p.DecodeVarint()

	if err != nil {

		return nil, err

	}

	nb := int(n)

	if nb < 0 {

		return nil, fmt.Errorf("proto: bad byte length %d", nb)

	}

	end := p.index + nb

	if end < p.index || end > len(p.buf) {

		return nil, io.ErrUnexpectedEOF

	}

	if !alloc {

		// todo: check if can get more uses of alloc=false

		buf = p.buf[p.index:end]

		p.index += nb

		return

	}

	buf = make([]byte, nb)

	copy(buf, p.buf[p.index:])

	p.index += nb

	return

}

// DecodeStringBytes reads an encoded string from the Buffer.

// This is the format used for the proto2 string type.

func (p *Buffer) DecodeStringBytes() (s string, err error) {

	buf, err := p.DecodeRawBytes(false)

	if err != nil {

		return

	}

	return string(buf), nil

}

// Unmarshaler is the interface representing objects that can

// unmarshal themselves.  The argument points to data that may be

// overwritten, so implementations should not keep references to the

// buffer.

// Unmarshal implementations should not clear the receiver.

// Any unmarshaled data should be merged into the receiver.

// Callers of Unmarshal that do not want to retain existing data

// should Reset the receiver before calling Unmarshal.

type Unmarshaler interface {

	Unmarshal([]byte) error

}

// newUnmarshaler is the interface representing objects that can

// unmarshal themselves. The semantics are identical to Unmarshaler.

//

// This exists to support protoc-gen-go generated messages.

// The proto package will stop type-asserting to this interface in the future.

//

// DO NOT DEPEND ON THIS.

type newUnmarshaler interface {

	XXX_Unmarshal([]byte) error

}

// Unmarshal parses the protocol buffer representation in buf and places the

// decoded result in pb.  If the struct underlying pb does not match

// the data in buf, the results can be unpredictable.

//

// Unmarshal resets pb before starting to unmarshal, so any

// existing data in pb is always removed. Use UnmarshalMerge

// to preserve and append to existing data.

func Unmarshal(buf []byte, pb Message) error {

	pb.Reset()

	if u, ok := pb.(newUnmarshaler); ok {

		return u.XXX_Unmarshal(buf)

	}

	if u, ok := pb.(Unmarshaler); ok {

		return u.Unmarshal(buf)

	}

	return NewBuffer(buf).Unmarshal(pb)

}

// UnmarshalMerge parses the protocol buffer representation in buf and

// writes the decoded result to pb.  If the struct underlying pb does not match

// the data in buf, the results can be unpredictable.

//

// UnmarshalMerge merges into existing data in pb.

// Most code should use Unmarshal instead.

func UnmarshalMerge(buf []byte, pb Message) error {

	if u, ok := pb.(newUnmarshaler); ok {

		return u.XXX_Unmarshal(buf)

	}

	if u, ok := pb.(Unmarshaler); ok {

		// NOTE: The history of proto have unfortunately been inconsistent

		// whether Unmarshaler should or should not implicitly clear itself.

		// Some implementations do, most do not.

		// Thus, calling this here may or may not do what people want.

		//

		// See https://github.com/golang/protobuf/issues/424

		return u.Unmarshal(buf)

	}

	return NewBuffer(buf).Unmarshal(pb)

}

// DecodeMessage reads a count-delimited message from the Buffer.

func (p *Buffer) DecodeMessage(pb Message) error {

	enc, err := p.DecodeRawBytes(false)

	if err != nil {

		return err

	}

	return NewBuffer(enc).Unmarshal(pb)

}

// DecodeGroup reads a tag-delimited group from the Buffer.

// StartGroup tag is already consumed. This function consumes

// EndGroup tag.

func (p *Buffer) DecodeGroup(pb Message) error {

	b := p.buf[p.index:]

	x, y := findEndGroup(b)

	if x < 0 {

		return io.ErrUnexpectedEOF

	}

	err := Unmarshal(b[:x], pb)

	p.index += y

	return err

}

// Unmarshal parses the protocol buffer representation in the

// Buffer and places the decoded result in pb.  If the struct

// underlying pb does not match the data in the buffer, the results can be

// unpredictable.

//

// Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal.

func (p *Buffer) Unmarshal(pb Message) error {

	// If the object can unmarshal itself, let it.

	if u, ok := pb.(newUnmarshaler); ok {

		err := u.XXX_Unmarshal(p.buf[p.index:])

		p.index = len(p.buf)

		return err

	}

	if u, ok := pb.(Unmarshaler); ok {

		// NOTE: The history of proto have unfortunately been inconsistent

		// whether Unmarshaler should or should not implicitly clear itself.

		// Some implementations do, most do not.

		// Thus, calling this here may or may not do what people want.

		//

		// See https://github.com/golang/protobuf/issues/424

		err := u.Unmarshal(p.buf[p.index:])

		p.index = len(p.buf)

		return err

	}

	// Slow workaround for messages that aren't Unmarshalers.

	// This includes some hand-coded .pb.go files and

	// bootstrap protos.

	// TODO: fix all of those and then add Unmarshal to

	// the Message interface. Then:

	// The cast above and code below can be deleted.

	// The old unmarshaler can be deleted.

	// Clients can call Unmarshal directly (can already do that, actually).