func _LogEntry_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*LogEntry)
switch tag {
case 2: // payload.proto_payload
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(google_protobuf1.Any)
err := b.DecodeMessage(msg)
m.Payload = &LogEntry_ProtoPayload{msg}
return true, err
case 3: // payload.text_payload
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Payload = &LogEntry_TextPayload{x}
return true, err
case 6: // payload.json_payload
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(google_protobuf2.Struct)
err := b.DecodeMessage(msg)
m.Payload = &LogEntry_JsonPayload{msg}
return true, err
default:
return false, nil
}
}
func _TestQuery_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*TestQuery)
switch tag {
case 1: // query.id
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Query = &TestQuery_Id{x}
return true, err
case 2: // query.wildcard
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(TestQuery_Wildcard)
err := b.DecodeMessage(msg)
m.Query = &TestQuery_Wildcard_{msg}
return true, err
case 3: // query.regex
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(TestQuery_Regex)
err := b.DecodeMessage(msg)
m.Query = &TestQuery_Regex_{msg}
return true, err
default:
return false, nil
}
}
func _GaugeResponse_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*GaugeResponse)
switch tag {
case 2: // value.long_value
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Value = &GaugeResponse_LongValue{int64(x)}
return true, err
case 3: // value.double_value
if wire != proto.WireFixed64 {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeFixed64()
m.Value = &GaugeResponse_DoubleValue{math.Float64frombits(x)}
return true, err
case 4: // value.string_value
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Value = &GaugeResponse_StringValue{x}
return true, err
default:
return false, nil
}
}
// Unmarshal deserializes a `NsReadWriteSet`
func (nsRW *NsReadWriteSet) Unmarshal(buf *proto.Buffer) error {
var err error
if nsRW.NameSpace, err = buf.DecodeStringBytes(); err != nil {
return err
}
var numReads uint64
if numReads, err = buf.DecodeVarint(); err != nil {
return err
}
for i := 0; i < int(numReads); i++ {
r := &KVRead{}
if err = r.Unmarshal(buf); err != nil {
return err
}
nsRW.Reads = append(nsRW.Reads, r)
}
var numWrites uint64
if numWrites, err = buf.DecodeVarint(); err != nil {
return err
}
for i := 0; i < int(numWrites); i++ {
w := &KVWrite{}
if err = w.Unmarshal(buf); err != nil {
return err
}
nsRW.Writes = append(nsRW.Writes, w)
}
return nil
}
func _MsgWithOneof_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*MsgWithOneof)
switch tag {
case 1: // union.title
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Union = &MsgWithOneof_Title{x}
return true, err
case 2: // union.salary
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Union = &MsgWithOneof_Salary{int64(x)}
return true, err
case 3: // union.Country
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Union = &MsgWithOneof_Country{x}
return true, err
default:
return false, nil
}
}
func _Argument_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Argument)
switch tag {
case 1: // value.number
if wire != proto.WireFixed64 {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeFixed64()
m.Value = &Argument_Number{math.Float64frombits(x)}
return true, err
case 2: // value.str
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Value = &Argument_Str{x}
return true, err
case 3: // value.boolean
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Value = &Argument_Boolean{x != 0}
return true, err
default:
return false, nil
}
}
func _Metric_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Metric)
switch tag {
case 9: // data.string_data
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Data = &Metric_StringData{x}
return true, err
case 10: // data.float32_data
if wire != proto.WireFixed32 {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeFixed32()
m.Data = &Metric_Float32Data{math.Float32frombits(uint32(x))}
return true, err
case 11: // data.float64_data
if wire != proto.WireFixed64 {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeFixed64()
m.Data = &Metric_Float64Data{math.Float64frombits(x)}
return true, err
case 12: // data.int32_data
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Data = &Metric_Int32Data{int32(x)}
return true, err
case 13: // data.int64_data
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Data = &Metric_Int64Data{int64(x)}
return true, err
case 14: // data.bytes_data
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeRawBytes(true)
m.Data = &Metric_BytesData{x}
return true, err
case 15: // data.bool_data
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Data = &Metric_BoolData{x != 0}
return true, err
default:
return false, nil
}
}
func _Column_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Column)
switch tag {
case 1: // value.string
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Value = &Column_String_{x}
return true, err
case 2: // value.int32
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Value = &Column_Int32{int32(x)}
return true, err
case 3: // value.int64
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Value = &Column_Int64{int64(x)}
return true, err
case 4: // value.uint32
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Value = &Column_Uint32{uint32(x)}
return true, err
case 5: // value.uint64
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Value = &Column_Uint64{x}
return true, err
case 6: // value.bytes
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeRawBytes(true)
m.Value = &Column_Bytes{x}
return true, err
case 7: // value.bool
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Value = &Column_Bool{x != 0}
return true, err
default:
return false, nil
}
}
func _Field_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Field)
switch tag {
case 2: // value.number
if wire != proto.WireFixed64 {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeFixed64()
m.Value = &Field_Number{math.Float64frombits(x)}
return true, err
case 3: // value.str
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Value = &Field_Str{x}
return true, err
case 4: // value.boolean
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Value = &Field_Boolean{x != 0}
return true, err
case 5: // value.object
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Object)
err := b.DecodeMessage(msg)
m.Value = &Field_Object{msg}
return true, err
case 6: // value.array
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Array)
err := b.DecodeMessage(msg)
m.Value = &Field_Array{msg}
return true, err
case 7: // value.link
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Link)
err := b.DecodeMessage(msg)
m.Value = &Field_Link{msg}
return true, err
default:
return false, nil
}
}
func _Value_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Value)
switch tag {
case 1: // kind.null_value
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Kind = &Value_NullValue{NullValue(x)}
return true, err
case 2: // kind.number_value
if wire != proto.WireFixed64 {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeFixed64()
m.Kind = &Value_NumberValue{math.Float64frombits(x)}
return true, err
case 3: // kind.string_value
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Kind = &Value_StringValue{x}
return true, err
case 4: // kind.bool_value
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Kind = &Value_BoolValue{x != 0}
return true, err
case 5: // kind.struct_value
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Struct)
err := b.DecodeMessage(msg)
m.Kind = &Value_StructValue{msg}
return true, err
case 6: // kind.list_value
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(ListValue)
err := b.DecodeMessage(msg)
m.Kind = &Value_ListValue{msg}
return true, err
default:
return false, nil
}
}
// Unmarshal deserializes a `KVRead`
func (r *KVRead) Unmarshal(buf *proto.Buffer) error {
var err error
var versionBytes []byte
if r.Key, err = buf.DecodeStringBytes(); err != nil {
return err
}
if versionBytes, err = buf.DecodeRawBytes(false); err != nil {
return err
}
if len(versionBytes) > 0 {
r.Version, _ = version.NewHeightFromBytes(versionBytes)
}
return nil
}
func _RowValue_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*RowValue)
switch tag {
case 1: // value.str
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Value = &RowValue_Str{x}
return true, err
case 2: // value.int
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Value = &RowValue_Int{int32(x)}
return true, err
case 3: // value.real
if wire != proto.WireFixed32 {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeFixed32()
m.Value = &RowValue_Real{math.Float32frombits(uint32(x))}
return true, err
case 4: // value.date
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Value = &RowValue_Date{int64(x)}
return true, err
case 5: // value.date_of_time
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Value = &RowValue_DateOfTime{int64(x)}
return true, err
case 6: // value.time_of_day
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(TimeOfDay)
err := b.DecodeMessage(msg)
m.Value = &RowValue_TimeOfDay{msg}
return true, err
default:
return false, nil
}
}
func _HttpRule_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*HttpRule)
switch tag {
case 2: // pattern.get
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Pattern = &HttpRule_Get{x}
return true, err
case 3: // pattern.put
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Pattern = &HttpRule_Put{x}
return true, err
case 4: // pattern.post
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Pattern = &HttpRule_Post{x}
return true, err
case 5: // pattern.delete
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Pattern = &HttpRule_Delete{x}
return true, err
case 6: // pattern.patch
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Pattern = &HttpRule_Patch{x}
return true, err
case 8: // pattern.custom
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(CustomHttpPattern)
err := b.DecodeMessage(msg)
m.Pattern = &HttpRule_Custom{msg}
return true, err
default:
return false, nil
}
}
// Unmarshal deserializes a `KVWrite`
func (w *KVWrite) Unmarshal(buf *proto.Buffer) error {
var err error
if w.Key, err = buf.DecodeStringBytes(); err != nil {
return err
}
var deleteMarker uint64
if deleteMarker, err = buf.DecodeVarint(); err != nil {
return err
}
if deleteMarker == 1 {
w.IsDelete = true
return nil
}
if w.Value, err = buf.DecodeRawBytes(false); err != nil {
return err
}
return nil
}
func _JSON_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*JSON)
switch tag {
case 1: // json_value_oneof.json_string
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.JsonValueOneof = &JSON_JsonString{x}
return true, err
case 2: // json_value_oneof.json_number
if wire != proto.WireFixed64 {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeFixed64()
m.JsonValueOneof = &JSON_JsonNumber{math.Float64frombits(x)}
return true, err
case 3: // json_value_oneof.json_bool
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.JsonValueOneof = &JSON_JsonBool{x != 0}
return true, err
case 4: // json_value_oneof.json_object
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(JSONObject)
err := b.DecodeMessage(msg)
m.JsonValueOneof = &JSON_JsonObject{msg}
return true, err
case 5: // json_value_oneof.json_array
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(JSONArray)
err := b.DecodeMessage(msg)
m.JsonValueOneof = &JSON_JsonArray{msg}
return true, err
default:
return false, nil
}
}
func _OptionValue_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*OptionValue)
switch tag {
case 2: // value.boolValue
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Value = &OptionValue_BoolValue{x != 0}
return true, err
case 3: // value.intValue
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Value = &OptionValue_IntValue{int64(x)}
return true, err
case 4: // value.doubleValue
if wire != proto.WireFixed64 {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeFixed64()
m.Value = &OptionValue_DoubleValue{math.Float64frombits(x)}
return true, err
case 5: // value.stringValue
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Value = &OptionValue_StringValue{x}
return true, err
case 6: // value.durationValue
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Value = &OptionValue_DurationValue{int64(x)}
return true, err
default:
return false, nil
}
}
func _Test_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Test)
switch tag {
case 6: // union.number
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Union = &Test_Number{int32(x)}
return true, err
case 7: // union.name
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Union = &Test_Name{x}
return true, err
default:
return false, nil
}
}
func _Key_PathElement_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Key_PathElement)
switch tag {
case 2: // id_type.id
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.IdType = &Key_PathElement_Id{int64(x)}
return true, err
case 3: // id_type.name
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.IdType = &Key_PathElement_Name{x}
return true, err
default:
return false, nil
}
}
func _Flag_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Flag)
switch tag {
case 1: // flag.reserved
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Flag = &Flag_Reserved_{Flag_Reserved(x)}
return true, err
case 2: // flag.custom
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Flag = &Flag_Custom{x}
return true, err
default:
return false, nil
}
}
func _IPOrDomain_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*IPOrDomain)
switch tag {
case 1: // address.ip
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeRawBytes(true)
m.Address = &IPOrDomain_Ip{x}
return true, err
case 2: // address.domain
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Address = &IPOrDomain_Domain{x}
return true, err
default:
return false, nil
}
}
func _FileServer_Entry_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*FileServer_Entry)
switch tag {
case 1: // FileOrDir.File
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.FileOrDir = &FileServer_Entry_File{x}
return true, err
case 2: // FileOrDir.Directory
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.FileOrDir = &FileServer_Entry_Directory{x}
return true, err
default:
return false, nil
}
}
func _ABitOfEverything_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*ABitOfEverything)
switch tag {
case 20: // oneof_value.oneof_empty
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(google_protobuf1.Empty)
err := b.DecodeMessage(msg)
m.OneofValue = &ABitOfEverything_OneofEmpty{msg}
return true, err
case 21: // oneof_value.oneof_string
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.OneofValue = &ABitOfEverything_OneofString{x}
return true, err
default:
return false, nil
}
}
func _JobInfo_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*JobInfo)
switch tag {
case 2: // spec.transform
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(pachyderm_pps.Transform)
err := b.DecodeMessage(msg)
m.Spec = &JobInfo_Transform{msg}
return true, err
case 3: // spec.pipeline_name
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Spec = &JobInfo_PipelineName{x}
return true, err
default:
return false, nil
}
}
func (chaincodeStateDelta *chaincodeStateDelta) unmarshal(buffer *proto.Buffer) error {
size, err := buffer.DecodeVarint()
if err != nil {
panic(fmt.Errorf("This error should not occur: %s", err))
}
chaincodeStateDelta.updatedKVs = make(map[string]*UpdatedValue, size)
for i := uint64(0); i < size; i++ {
key, err := buffer.DecodeStringBytes()
if err != nil {
panic(fmt.Errorf("This error should not occur: %s", err))
}
value, err := buffer.DecodeRawBytes(false)
if err != nil {
panic(fmt.Errorf("This error should not occur: %s", err))
}
// protobuff does not differentiate between an empty []byte or a nil
// For now we assume user does not have a motivation to store []byte array
// as a value for a key and we treat an empty []byte represent that the value was nil
// during marshalling (i.e., the entry represent a delete of a key)
// If we need to differentiate, we need to write a flag during marshalling
//(which would require one bool per keyvalue entry)
if len(value) == 0 {
value = nil
}
previousValue, err := buffer.DecodeRawBytes(false)
if err != nil {
panic(fmt.Errorf("This error should not occur: %s", err))
}
if len(previousValue) == 0 {
previousValue = nil
}
chaincodeStateDelta.updatedKVs[key] = &UpdatedValue{value, previousValue}
}
return nil
}
func (chaincodeStateDelta *ChaincodeStateDelta) unmarshal(buffer *proto.Buffer) error {
size, err := buffer.DecodeVarint()
if err != nil {
return fmt.Errorf("Error unmarshaling state delta: %s", err)
}
chaincodeStateDelta.UpdatedKVs = make(map[string]*UpdatedValue, size)
for i := uint64(0); i < size; i++ {
key, err := buffer.DecodeStringBytes()
if err != nil {
return fmt.Errorf("Error unmarshaling state delta : %s", err)
}
value, err := chaincodeStateDelta.unmarshalValueWithMarker(buffer)
if err != nil {
return fmt.Errorf("Error unmarshaling state delta : %s", err)
}
previousValue, err := chaincodeStateDelta.unmarshalValueWithMarker(buffer)
if err != nil {
return fmt.Errorf("Error unmarshaling state delta : %s", err)
}
chaincodeStateDelta.UpdatedKVs[key] = &UpdatedValue{value, previousValue}
}
return nil
}
func _ServerReflectionRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*ServerReflectionRequest)
switch tag {
case 3: // message_request.file_by_filename
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.MessageRequest = &ServerReflectionRequest_FileByFilename{x}
return true, err
case 4: // message_request.file_containing_symbol
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.MessageRequest = &ServerReflectionRequest_FileContainingSymbol{x}
return true, err
case 5: // message_request.file_containing_extension
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(ExtensionRequest)
err := b.DecodeMessage(msg)
m.MessageRequest = &ServerReflectionRequest_FileContainingExtension{msg}
return true, err
case 6: // message_request.all_extension_numbers_of_type
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.MessageRequest = &ServerReflectionRequest_AllExtensionNumbersOfType{x}
return true, err
case 7: // message_request.list_services
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.MessageRequest = &ServerReflectionRequest_ListServices{x}
return true, err
default:
return false, nil
}
}
func _Value_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Value)
switch tag {
case 11: // value_type.null_value
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.ValueType = &Value_NullValue{google_protobuf.NullValue(x)}
return true, err
case 1: // value_type.boolean_value
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.ValueType = &Value_BooleanValue{x != 0}
return true, err
case 2: // value_type.integer_value
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.ValueType = &Value_IntegerValue{int64(x)}
return true, err
case 3: // value_type.double_value
if wire != proto.WireFixed64 {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeFixed64()
m.ValueType = &Value_DoubleValue{math.Float64frombits(x)}
return true, err
case 10: // value_type.timestamp_value
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(google_protobuf1.Timestamp)
err := b.DecodeMessage(msg)
m.ValueType = &Value_TimestampValue{msg}
return true, err
case 5: // value_type.key_value
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Key)
err := b.DecodeMessage(msg)
m.ValueType = &Value_KeyValue{msg}
return true, err
case 17: // value_type.string_value
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.ValueType = &Value_StringValue{x}
return true, err
case 18: // value_type.blob_value
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeRawBytes(true)
m.ValueType = &Value_BlobValue{x}
return true, err
case 8: // value_type.geo_point_value
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(google_type.LatLng)
err := b.DecodeMessage(msg)
m.ValueType = &Value_GeoPointValue{msg}
return true, err
case 6: // value_type.entity_value
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Entity)
err := b.DecodeMessage(msg)
m.ValueType = &Value_EntityValue{msg}
return true, err
case 9: // value_type.array_value
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(ArrayValue)
err := b.DecodeMessage(msg)
m.ValueType = &Value_ArrayValue{msg}
return true, err
default:
return false, nil
}
}
func _Communique_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Communique)
switch tag {
case 5: // union.number
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Union = &Communique_Number{int32(x)}
return true, err
case 6: // union.name
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Union = &Communique_Name{x}
return true, err
case 7: // union.data
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeRawBytes(true)
m.Union = &Communique_Data{x}
return true, err
case 8: // union.temp_c
if wire != proto.WireFixed64 {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeFixed64()
m.Union = &Communique_TempC{math.Float64frombits(x)}
return true, err
case 9: // union.height
if wire != proto.WireFixed32 {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeFixed32()
m.Union = &Communique_Height{math.Float32frombits(uint32(x))}
return true, err
case 10: // union.today
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Union = &Communique_Today{Days(x)}
return true, err
case 11: // union.maybe
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Union = &Communique_Maybe{x != 0}
return true, err
case 12: // union.delta
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeZigzag32()
m.Union = &Communique_Delta_{int32(x)}
return true, err
case 13: // union.msg
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Reply)
err := b.DecodeMessage(msg)
m.Union = &Communique_Msg{msg}
return true, err
case 14: // union.somegroup
if wire != proto.WireStartGroup {
return true, proto.ErrInternalBadWireType
}
msg := new(Communique_SomeGroup)
err := b.DecodeGroup(msg)
m.Union = &Communique_Somegroup{msg}
return true, err
default:
return false, nil
}
}
