Scott Baker | 1fe7273 | 2019-10-21 10:58:51 -0700 | [diff] [blame] | 1 | // Go support for Protocol Buffers - Google's data interchange format |
| 2 | // |
| 3 | // Copyright 2010 The Go Authors. All rights reserved. |
| 4 | // https://github.com/golang/protobuf |
| 5 | // |
| 6 | // Redistribution and use in source and binary forms, with or without |
| 7 | // modification, are permitted provided that the following conditions are |
| 8 | // met: |
| 9 | // |
| 10 | // * Redistributions of source code must retain the above copyright |
| 11 | // notice, this list of conditions and the following disclaimer. |
| 12 | // * Redistributions in binary form must reproduce the above |
| 13 | // copyright notice, this list of conditions and the following disclaimer |
| 14 | // in the documentation and/or other materials provided with the |
| 15 | // distribution. |
| 16 | // * Neither the name of Google Inc. nor the names of its |
| 17 | // contributors may be used to endorse or promote products derived from |
| 18 | // this software without specific prior written permission. |
| 19 | // |
| 20 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 21 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 22 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 23 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 24 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 25 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 26 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 27 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 28 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 29 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 30 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 31 | |
| 32 | package proto |
| 33 | |
| 34 | /* |
| 35 | * Routines for encoding data into the wire format for protocol buffers. |
| 36 | */ |
| 37 | |
| 38 | import ( |
| 39 | "errors" |
| 40 | "reflect" |
| 41 | ) |
| 42 | |
| 43 | var ( |
| 44 | // errRepeatedHasNil is the error returned if Marshal is called with |
| 45 | // a struct with a repeated field containing a nil element. |
| 46 | errRepeatedHasNil = errors.New("proto: repeated field has nil element") |
| 47 | |
| 48 | // errOneofHasNil is the error returned if Marshal is called with |
| 49 | // a struct with a oneof field containing a nil element. |
| 50 | errOneofHasNil = errors.New("proto: oneof field has nil value") |
| 51 | |
| 52 | // ErrNil is the error returned if Marshal is called with nil. |
| 53 | ErrNil = errors.New("proto: Marshal called with nil") |
| 54 | |
| 55 | // ErrTooLarge is the error returned if Marshal is called with a |
| 56 | // message that encodes to >2GB. |
| 57 | ErrTooLarge = errors.New("proto: message encodes to over 2 GB") |
| 58 | ) |
| 59 | |
| 60 | // The fundamental encoders that put bytes on the wire. |
| 61 | // Those that take integer types all accept uint64 and are |
| 62 | // therefore of type valueEncoder. |
| 63 | |
| 64 | const maxVarintBytes = 10 // maximum length of a varint |
| 65 | |
| 66 | // EncodeVarint returns the varint encoding of x. |
| 67 | // This is the format for the |
| 68 | // int32, int64, uint32, uint64, bool, and enum |
| 69 | // protocol buffer types. |
| 70 | // Not used by the package itself, but helpful to clients |
| 71 | // wishing to use the same encoding. |
| 72 | func EncodeVarint(x uint64) []byte { |
| 73 | var buf [maxVarintBytes]byte |
| 74 | var n int |
| 75 | for n = 0; x > 127; n++ { |
| 76 | buf[n] = 0x80 | uint8(x&0x7F) |
| 77 | x >>= 7 |
| 78 | } |
| 79 | buf[n] = uint8(x) |
| 80 | n++ |
| 81 | return buf[0:n] |
| 82 | } |
| 83 | |
| 84 | // EncodeVarint writes a varint-encoded integer to the Buffer. |
| 85 | // This is the format for the |
| 86 | // int32, int64, uint32, uint64, bool, and enum |
| 87 | // protocol buffer types. |
| 88 | func (p *Buffer) EncodeVarint(x uint64) error { |
| 89 | for x >= 1<<7 { |
| 90 | p.buf = append(p.buf, uint8(x&0x7f|0x80)) |
| 91 | x >>= 7 |
| 92 | } |
| 93 | p.buf = append(p.buf, uint8(x)) |
| 94 | return nil |
| 95 | } |
| 96 | |
| 97 | // SizeVarint returns the varint encoding size of an integer. |
| 98 | func SizeVarint(x uint64) int { |
| 99 | switch { |
| 100 | case x < 1<<7: |
| 101 | return 1 |
| 102 | case x < 1<<14: |
| 103 | return 2 |
| 104 | case x < 1<<21: |
| 105 | return 3 |
| 106 | case x < 1<<28: |
| 107 | return 4 |
| 108 | case x < 1<<35: |
| 109 | return 5 |
| 110 | case x < 1<<42: |
| 111 | return 6 |
| 112 | case x < 1<<49: |
| 113 | return 7 |
| 114 | case x < 1<<56: |
| 115 | return 8 |
| 116 | case x < 1<<63: |
| 117 | return 9 |
| 118 | } |
| 119 | return 10 |
| 120 | } |
| 121 | |
| 122 | // EncodeFixed64 writes a 64-bit integer to the Buffer. |
| 123 | // This is the format for the |
| 124 | // fixed64, sfixed64, and double protocol buffer types. |
| 125 | func (p *Buffer) EncodeFixed64(x uint64) error { |
| 126 | p.buf = append(p.buf, |
| 127 | uint8(x), |
| 128 | uint8(x>>8), |
| 129 | uint8(x>>16), |
| 130 | uint8(x>>24), |
| 131 | uint8(x>>32), |
| 132 | uint8(x>>40), |
| 133 | uint8(x>>48), |
| 134 | uint8(x>>56)) |
| 135 | return nil |
| 136 | } |
| 137 | |
| 138 | // EncodeFixed32 writes a 32-bit integer to the Buffer. |
| 139 | // This is the format for the |
| 140 | // fixed32, sfixed32, and float protocol buffer types. |
| 141 | func (p *Buffer) EncodeFixed32(x uint64) error { |
| 142 | p.buf = append(p.buf, |
| 143 | uint8(x), |
| 144 | uint8(x>>8), |
| 145 | uint8(x>>16), |
| 146 | uint8(x>>24)) |
| 147 | return nil |
| 148 | } |
| 149 | |
| 150 | // EncodeZigzag64 writes a zigzag-encoded 64-bit integer |
| 151 | // to the Buffer. |
| 152 | // This is the format used for the sint64 protocol buffer type. |
| 153 | func (p *Buffer) EncodeZigzag64(x uint64) error { |
| 154 | // use signed number to get arithmetic right shift. |
| 155 | return p.EncodeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63)))) |
| 156 | } |
| 157 | |
| 158 | // EncodeZigzag32 writes a zigzag-encoded 32-bit integer |
| 159 | // to the Buffer. |
| 160 | // This is the format used for the sint32 protocol buffer type. |
| 161 | func (p *Buffer) EncodeZigzag32(x uint64) error { |
| 162 | // use signed number to get arithmetic right shift. |
| 163 | return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31)))) |
| 164 | } |
| 165 | |
| 166 | // EncodeRawBytes writes a count-delimited byte buffer to the Buffer. |
| 167 | // This is the format used for the bytes protocol buffer |
| 168 | // type and for embedded messages. |
| 169 | func (p *Buffer) EncodeRawBytes(b []byte) error { |
| 170 | p.EncodeVarint(uint64(len(b))) |
| 171 | p.buf = append(p.buf, b...) |
| 172 | return nil |
| 173 | } |
| 174 | |
| 175 | // EncodeStringBytes writes an encoded string to the Buffer. |
| 176 | // This is the format used for the proto2 string type. |
| 177 | func (p *Buffer) EncodeStringBytes(s string) error { |
| 178 | p.EncodeVarint(uint64(len(s))) |
| 179 | p.buf = append(p.buf, s...) |
| 180 | return nil |
| 181 | } |
| 182 | |
| 183 | // Marshaler is the interface representing objects that can marshal themselves. |
| 184 | type Marshaler interface { |
| 185 | Marshal() ([]byte, error) |
| 186 | } |
| 187 | |
| 188 | // EncodeMessage writes the protocol buffer to the Buffer, |
| 189 | // prefixed by a varint-encoded length. |
| 190 | func (p *Buffer) EncodeMessage(pb Message) error { |
| 191 | siz := Size(pb) |
| 192 | p.EncodeVarint(uint64(siz)) |
| 193 | return p.Marshal(pb) |
| 194 | } |
| 195 | |
| 196 | // All protocol buffer fields are nillable, but be careful. |
| 197 | func isNil(v reflect.Value) bool { |
| 198 | switch v.Kind() { |
| 199 | case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: |
| 200 | return v.IsNil() |
| 201 | } |
| 202 | return false |
| 203 | } |