1 // Protocol Buffers for Go with Gadgets
3 // Copyright (c) 2018, The GoGo Authors. All rights reserved.
4 // http://github.com/gogo/protobuf
6 // Redistribution and use in source and binary forms, with or without
7 // modification, are permitted provided that the following conditions are
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
17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 // makeMessageRefMarshaler differs a bit from makeMessageMarshaler
37 // It marshal a message T instead of a *T
38 func makeMessageRefMarshaler(u *marshalInfo) (sizer, marshaler) {
39 return func(ptr pointer, tagsize int) int {
41 return siz + SizeVarint(uint64(siz)) + tagsize
43 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
44 b = appendVarint(b, wiretag)
45 siz := u.cachedsize(ptr)
46 b = appendVarint(b, uint64(siz))
47 return u.marshal(b, ptr, deterministic)
51 // makeMessageRefSliceMarshaler differs quite a lot from makeMessageSliceMarshaler
52 // It marshals a slice of messages []T instead of []*T
53 func makeMessageRefSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
54 return func(ptr pointer, tagsize int) int {
55 s := ptr.getSlice(u.typ)
57 for i := 0; i < s.Len(); i++ {
60 v := toAddrPointer(&e, false)
62 n += siz + SizeVarint(uint64(siz)) + tagsize
66 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
67 s := ptr.getSlice(u.typ)
69 for i := 0; i < s.Len(); i++ {
72 v := toAddrPointer(&e, false)
73 b = appendVarint(b, wiretag)
75 b = appendVarint(b, uint64(siz))
76 b, err = u.marshal(b, v, deterministic)
79 if _, ok := err.(*RequiredNotSetError); ok {
80 // Required field in submessage is not set.
81 // We record the error but keep going, to give a complete marshaling.
88 err = errRepeatedHasNil
98 func makeCustomPtrMarshaler(u *marshalInfo) (sizer, marshaler) {
99 return func(ptr pointer, tagsize int) int {
103 m := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(custom)
105 return tagsize + SizeVarint(uint64(siz)) + siz
106 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
110 m := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(custom)
112 buf, err := m.Marshal()
116 b = appendVarint(b, wiretag)
117 b = appendVarint(b, uint64(siz))
118 b = append(b, buf...)
123 func makeCustomMarshaler(u *marshalInfo) (sizer, marshaler) {
124 return func(ptr pointer, tagsize int) int {
125 m := ptr.asPointerTo(u.typ).Interface().(custom)
127 return tagsize + SizeVarint(uint64(siz)) + siz
128 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
129 m := ptr.asPointerTo(u.typ).Interface().(custom)
131 buf, err := m.Marshal()
135 b = appendVarint(b, wiretag)
136 b = appendVarint(b, uint64(siz))
137 b = append(b, buf...)
142 func makeTimeMarshaler(u *marshalInfo) (sizer, marshaler) {
143 return func(ptr pointer, tagsize int) int {
144 t := ptr.asPointerTo(u.typ).Interface().(*time.Time)
145 ts, err := timestampProto(*t)
150 return tagsize + SizeVarint(uint64(siz)) + siz
151 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
152 t := ptr.asPointerTo(u.typ).Interface().(*time.Time)
153 ts, err := timestampProto(*t)
157 buf, err := Marshal(ts)
161 b = appendVarint(b, wiretag)
162 b = appendVarint(b, uint64(len(buf)))
163 b = append(b, buf...)
168 func makeTimePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
169 return func(ptr pointer, tagsize int) int {
173 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*time.Time)
174 ts, err := timestampProto(*t)
179 return tagsize + SizeVarint(uint64(siz)) + siz
180 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
184 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*time.Time)
185 ts, err := timestampProto(*t)
189 buf, err := Marshal(ts)
193 b = appendVarint(b, wiretag)
194 b = appendVarint(b, uint64(len(buf)))
195 b = append(b, buf...)
200 func makeTimeSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
201 return func(ptr pointer, tagsize int) int {
202 s := ptr.getSlice(u.typ)
204 for i := 0; i < s.Len(); i++ {
206 t := elem.Interface().(time.Time)
207 ts, err := timestampProto(t)
212 n += siz + SizeVarint(uint64(siz)) + tagsize
216 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
217 s := ptr.getSlice(u.typ)
218 for i := 0; i < s.Len(); i++ {
220 t := elem.Interface().(time.Time)
221 ts, err := timestampProto(t)
226 buf, err := Marshal(ts)
230 b = appendVarint(b, wiretag)
231 b = appendVarint(b, uint64(siz))
232 b = append(b, buf...)
239 func makeTimePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
240 return func(ptr pointer, tagsize int) int {
241 s := ptr.getSlice(reflect.PtrTo(u.typ))
243 for i := 0; i < s.Len(); i++ {
245 t := elem.Interface().(*time.Time)
246 ts, err := timestampProto(*t)
251 n += siz + SizeVarint(uint64(siz)) + tagsize
255 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
256 s := ptr.getSlice(reflect.PtrTo(u.typ))
257 for i := 0; i < s.Len(); i++ {
259 t := elem.Interface().(*time.Time)
260 ts, err := timestampProto(*t)
265 buf, err := Marshal(ts)
269 b = appendVarint(b, wiretag)
270 b = appendVarint(b, uint64(siz))
271 b = append(b, buf...)
278 func makeDurationMarshaler(u *marshalInfo) (sizer, marshaler) {
279 return func(ptr pointer, tagsize int) int {
280 d := ptr.asPointerTo(u.typ).Interface().(*time.Duration)
281 dur := durationProto(*d)
283 return tagsize + SizeVarint(uint64(siz)) + siz
284 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
285 d := ptr.asPointerTo(u.typ).Interface().(*time.Duration)
286 dur := durationProto(*d)
287 buf, err := Marshal(dur)
291 b = appendVarint(b, wiretag)
292 b = appendVarint(b, uint64(len(buf)))
293 b = append(b, buf...)
298 func makeDurationPtrMarshaler(u *marshalInfo) (sizer, marshaler) {
299 return func(ptr pointer, tagsize int) int {
303 d := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*time.Duration)
304 dur := durationProto(*d)
306 return tagsize + SizeVarint(uint64(siz)) + siz
307 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
311 d := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*time.Duration)
312 dur := durationProto(*d)
313 buf, err := Marshal(dur)
317 b = appendVarint(b, wiretag)
318 b = appendVarint(b, uint64(len(buf)))
319 b = append(b, buf...)
324 func makeDurationSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
325 return func(ptr pointer, tagsize int) int {
326 s := ptr.getSlice(u.typ)
328 for i := 0; i < s.Len(); i++ {
330 d := elem.Interface().(time.Duration)
331 dur := durationProto(d)
333 n += siz + SizeVarint(uint64(siz)) + tagsize
337 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
338 s := ptr.getSlice(u.typ)
339 for i := 0; i < s.Len(); i++ {
341 d := elem.Interface().(time.Duration)
342 dur := durationProto(d)
344 buf, err := Marshal(dur)
348 b = appendVarint(b, wiretag)
349 b = appendVarint(b, uint64(siz))
350 b = append(b, buf...)
357 func makeDurationPtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
358 return func(ptr pointer, tagsize int) int {
359 s := ptr.getSlice(reflect.PtrTo(u.typ))
361 for i := 0; i < s.Len(); i++ {
363 d := elem.Interface().(*time.Duration)
364 dur := durationProto(*d)
366 n += siz + SizeVarint(uint64(siz)) + tagsize
370 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
371 s := ptr.getSlice(reflect.PtrTo(u.typ))
372 for i := 0; i < s.Len(); i++ {
374 d := elem.Interface().(*time.Duration)
375 dur := durationProto(*d)
377 buf, err := Marshal(dur)
381 b = appendVarint(b, wiretag)
382 b = appendVarint(b, uint64(siz))
383 b = append(b, buf...)