mirror of
https://gitlab.bertha.cloud/partitio/Nextcloud-Partitio/gonextcloud
synced 2024-11-25 10:56:25 +00:00
351 lines
9.2 KiB
Go
351 lines
9.2 KiB
Go
// 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
|
|
}
|