| // Protocol Buffers for Go with Gadgets |
| // |
| // Copyright (c) 2013, The GoGo Authors. All rights reserved. |
| // http://github.com/gogo/protobuf |
| // |
| // Go support for Protocol Buffers - Google's data interchange format |
| // |
| // Copyright 2010 The Go Authors. All rights reserved. |
| // http://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 |
| |
| import ( |
| "reflect" |
| ) |
| |
| func NewRequiredNotSetError(field string) *RequiredNotSetError { |
| return &RequiredNotSetError{field} |
| } |
| |
| type Sizer interface { |
| Size() int |
| } |
| |
| func (o *Buffer) enc_ext_slice_byte(p *Properties, base structPointer) error { |
| s := *structPointer_Bytes(base, p.field) |
| if s == nil { |
| return ErrNil |
| } |
| o.buf = append(o.buf, s...) |
| return nil |
| } |
| |
| func size_ext_slice_byte(p *Properties, base structPointer) (n int) { |
| s := *structPointer_Bytes(base, p.field) |
| if s == nil { |
| return 0 |
| } |
| n += len(s) |
| return |
| } |
| |
| // Encode a reference to bool pointer. |
| func (o *Buffer) enc_ref_bool(p *Properties, base structPointer) error { |
| v := *structPointer_BoolVal(base, p.field) |
| x := 0 |
| if v { |
| x = 1 |
| } |
| o.buf = append(o.buf, p.tagcode...) |
| p.valEnc(o, uint64(x)) |
| return nil |
| } |
| |
| func size_ref_bool(p *Properties, base structPointer) int { |
| return len(p.tagcode) + 1 // each bool takes exactly one byte |
| } |
| |
| // Encode a reference to int32 pointer. |
| func (o *Buffer) enc_ref_int32(p *Properties, base structPointer) error { |
| v := structPointer_Word32Val(base, p.field) |
| x := int32(word32Val_Get(v)) |
| o.buf = append(o.buf, p.tagcode...) |
| p.valEnc(o, uint64(x)) |
| return nil |
| } |
| |
| func size_ref_int32(p *Properties, base structPointer) (n int) { |
| v := structPointer_Word32Val(base, p.field) |
| x := int32(word32Val_Get(v)) |
| n += len(p.tagcode) |
| n += p.valSize(uint64(x)) |
| return |
| } |
| |
| func (o *Buffer) enc_ref_uint32(p *Properties, base structPointer) error { |
| v := structPointer_Word32Val(base, p.field) |
| x := word32Val_Get(v) |
| o.buf = append(o.buf, p.tagcode...) |
| p.valEnc(o, uint64(x)) |
| return nil |
| } |
| |
| func size_ref_uint32(p *Properties, base structPointer) (n int) { |
| v := structPointer_Word32Val(base, p.field) |
| x := word32Val_Get(v) |
| n += len(p.tagcode) |
| n += p.valSize(uint64(x)) |
| return |
| } |
| |
| // Encode a reference to an int64 pointer. |
| func (o *Buffer) enc_ref_int64(p *Properties, base structPointer) error { |
| v := structPointer_Word64Val(base, p.field) |
| x := word64Val_Get(v) |
| o.buf = append(o.buf, p.tagcode...) |
| p.valEnc(o, x) |
| return nil |
| } |
| |
| func size_ref_int64(p *Properties, base structPointer) (n int) { |
| v := structPointer_Word64Val(base, p.field) |
| x := word64Val_Get(v) |
| n += len(p.tagcode) |
| n += p.valSize(x) |
| return |
| } |
| |
| // Encode a reference to a string pointer. |
| func (o *Buffer) enc_ref_string(p *Properties, base structPointer) error { |
| v := *structPointer_StringVal(base, p.field) |
| o.buf = append(o.buf, p.tagcode...) |
| o.EncodeStringBytes(v) |
| return nil |
| } |
| |
| func size_ref_string(p *Properties, base structPointer) (n int) { |
| v := *structPointer_StringVal(base, p.field) |
| n += len(p.tagcode) |
| n += sizeStringBytes(v) |
| return |
| } |
| |
| // Encode a reference to a message struct. |
| func (o *Buffer) enc_ref_struct_message(p *Properties, base structPointer) error { |
| var state errorState |
| structp := structPointer_GetRefStructPointer(base, p.field) |
| if structPointer_IsNil(structp) { |
| return ErrNil |
| } |
| |
| // Can the object marshal itself? |
| if p.isMarshaler { |
| m := structPointer_Interface(structp, p.stype).(Marshaler) |
| data, err := m.Marshal() |
| if err != nil && !state.shouldContinue(err, nil) { |
| return err |
| } |
| o.buf = append(o.buf, p.tagcode...) |
| o.EncodeRawBytes(data) |
| return nil |
| } |
| |
| o.buf = append(o.buf, p.tagcode...) |
| return o.enc_len_struct(p.sprop, structp, &state) |
| } |
| |
| //TODO this is only copied, please fix this |
| func size_ref_struct_message(p *Properties, base structPointer) int { |
| structp := structPointer_GetRefStructPointer(base, p.field) |
| if structPointer_IsNil(structp) { |
| return 0 |
| } |
| |
| // Can the object marshal itself? |
| if p.isMarshaler { |
| m := structPointer_Interface(structp, p.stype).(Marshaler) |
| data, _ := m.Marshal() |
| n0 := len(p.tagcode) |
| n1 := sizeRawBytes(data) |
| return n0 + n1 |
| } |
| |
| n0 := len(p.tagcode) |
| n1 := size_struct(p.sprop, structp) |
| n2 := sizeVarint(uint64(n1)) // size of encoded length |
| return n0 + n1 + n2 |
| } |
| |
| // Encode a slice of references to message struct pointers ([]struct). |
| func (o *Buffer) enc_slice_ref_struct_message(p *Properties, base structPointer) error { |
| var state errorState |
| ss := structPointer_StructRefSlice(base, p.field, p.stype.Size()) |
| l := ss.Len() |
| for i := 0; i < l; i++ { |
| structp := ss.Index(i) |
| if structPointer_IsNil(structp) { |
| return errRepeatedHasNil |
| } |
| |
| // Can the object marshal itself? |
| if p.isMarshaler { |
| m := structPointer_Interface(structp, p.stype).(Marshaler) |
| data, err := m.Marshal() |
| if err != nil && !state.shouldContinue(err, nil) { |
| return err |
| } |
| o.buf = append(o.buf, p.tagcode...) |
| o.EncodeRawBytes(data) |
| continue |
| } |
| |
| o.buf = append(o.buf, p.tagcode...) |
| err := o.enc_len_struct(p.sprop, structp, &state) |
| if err != nil && !state.shouldContinue(err, nil) { |
| if err == ErrNil { |
| return errRepeatedHasNil |
| } |
| return err |
| } |
| |
| } |
| return state.err |
| } |
| |
| //TODO this is only copied, please fix this |
| func size_slice_ref_struct_message(p *Properties, base structPointer) (n int) { |
| ss := structPointer_StructRefSlice(base, p.field, p.stype.Size()) |
| l := ss.Len() |
| n += l * len(p.tagcode) |
| for i := 0; i < l; i++ { |
| structp := ss.Index(i) |
| if structPointer_IsNil(structp) { |
| return // return the size up to this point |
| } |
| |
| // Can the object marshal itself? |
| if p.isMarshaler { |
| m := structPointer_Interface(structp, p.stype).(Marshaler) |
| data, _ := m.Marshal() |
| n += len(p.tagcode) |
| n += sizeRawBytes(data) |
| continue |
| } |
| |
| n0 := size_struct(p.sprop, structp) |
| n1 := sizeVarint(uint64(n0)) // size of encoded length |
| n += n0 + n1 |
| } |
| return |
| } |
| |
| func (o *Buffer) enc_custom_bytes(p *Properties, base structPointer) error { |
| i := structPointer_InterfaceRef(base, p.field, p.ctype) |
| if i == nil { |
| return ErrNil |
| } |
| custom := i.(Marshaler) |
| data, err := custom.Marshal() |
| if err != nil { |
| return err |
| } |
| if data == nil { |
| return ErrNil |
| } |
| o.buf = append(o.buf, p.tagcode...) |
| o.EncodeRawBytes(data) |
| return nil |
| } |
| |
| func size_custom_bytes(p *Properties, base structPointer) (n int) { |
| n += len(p.tagcode) |
| i := structPointer_InterfaceRef(base, p.field, p.ctype) |
| if i == nil { |
| return 0 |
| } |
| custom := i.(Marshaler) |
| data, _ := custom.Marshal() |
| n += sizeRawBytes(data) |
| return |
| } |
| |
| func (o *Buffer) enc_custom_ref_bytes(p *Properties, base structPointer) error { |
| custom := structPointer_InterfaceAt(base, p.field, p.ctype).(Marshaler) |
| data, err := custom.Marshal() |
| if err != nil { |
| return err |
| } |
| if data == nil { |
| return ErrNil |
| } |
| o.buf = append(o.buf, p.tagcode...) |
| o.EncodeRawBytes(data) |
| return nil |
| } |
| |
| func size_custom_ref_bytes(p *Properties, base structPointer) (n int) { |
| n += len(p.tagcode) |
| i := structPointer_InterfaceAt(base, p.field, p.ctype) |
| if i == nil { |
| return 0 |
| } |
| custom := i.(Marshaler) |
| data, _ := custom.Marshal() |
| n += sizeRawBytes(data) |
| return |
| } |
| |
| func (o *Buffer) enc_custom_slice_bytes(p *Properties, base structPointer) error { |
| inter := structPointer_InterfaceRef(base, p.field, p.ctype) |
| if inter == nil { |
| return ErrNil |
| } |
| slice := reflect.ValueOf(inter) |
| l := slice.Len() |
| for i := 0; i < l; i++ { |
| v := slice.Index(i) |
| custom := v.Interface().(Marshaler) |
| data, err := custom.Marshal() |
| if err != nil { |
| return err |
| } |
| o.buf = append(o.buf, p.tagcode...) |
| o.EncodeRawBytes(data) |
| } |
| return nil |
| } |
| |
| func size_custom_slice_bytes(p *Properties, base structPointer) (n int) { |
| inter := structPointer_InterfaceRef(base, p.field, p.ctype) |
| if inter == nil { |
| return 0 |
| } |
| slice := reflect.ValueOf(inter) |
| l := slice.Len() |
| n += l * len(p.tagcode) |
| for i := 0; i < l; i++ { |
| v := slice.Index(i) |
| custom := v.Interface().(Marshaler) |
| data, _ := custom.Marshal() |
| n += sizeRawBytes(data) |
| } |
| return |
| } |