func _ReadRowsRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*ReadRowsRequest) switch tag { case 2: // target.row_key if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeRawBytes(true) m.Target = &ReadRowsRequest_RowKey{x} return true, err case 3: // target.row_range if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(google_bigtable_v11.RowRange) err := b.DecodeMessage(msg) m.Target = &ReadRowsRequest_RowRange{msg} return true, err case 8: // target.row_set if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(google_bigtable_v11.RowSet) err := b.DecodeMessage(msg) m.Target = &ReadRowsRequest_RowSet{msg} return true, err default: return false, nil } }
func _BatchMessage_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*BatchMessage) switch tag { case 1: // payload.request if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Request) err := b.DecodeMessage(msg) m.Payload = &BatchMessage_Request{msg} return true, err case 4: // payload.pbft_message if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeRawBytes(true) m.Payload = &BatchMessage_PbftMessage{x} return true, err case 5: // payload.complaint if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Request) err := b.DecodeMessage(msg) m.Payload = &BatchMessage_Complaint{msg} 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 _CommitRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*CommitRequest) switch tag { case 1: // transaction_selector.transaction if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeRawBytes(true) m.TransactionSelector = &CommitRequest_Transaction{x} 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 unmarshalTrieNodeValueFromBuffer(buffer *proto.Buffer) []byte { valueMarker, err := buffer.DecodeVarint() if err != nil { panic(fmt.Errorf("This error is not excpected: %s", err)) } if valueMarker == 0 { return nil } value, err := buffer.DecodeRawBytes(false) if err != nil { panic(fmt.Errorf("This error is not excpected: %s", err)) } return value }
func _StreamMessage_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*StreamMessage) switch tag { case 1: // message_oneof.rpc if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(RPC) err := b.DecodeMessage(msg) m.MessageOneof = &StreamMessage_Rpc{msg} return true, err case 2: // message_oneof.message if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(JSON) err := b.DecodeMessage(msg) m.MessageOneof = &StreamMessage_Message{msg} return true, err case 3: // message_oneof.byte_message if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeRawBytes(true) m.MessageOneof = &StreamMessage_ByteMessage{x} return true, err case 4: // message_oneof.error if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(JSON) err := b.DecodeMessage(msg) m.MessageOneof = &StreamMessage_Error{msg} return true, err case 5: // message_oneof.byte_error if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeRawBytes(true) m.MessageOneof = &StreamMessage_ByteError{x} 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 (chaincodeStateDelta *ChaincodeStateDelta) unmarshalValueWithMarker(buffer *proto.Buffer) ([]byte, error) { valueMarker, err := buffer.DecodeVarint() if err != nil { return nil, fmt.Errorf("Error unmarshaling state delta : %s", err) } if valueMarker == 0 { return nil, nil } value, err := buffer.DecodeRawBytes(false) if err != nil { return nil, fmt.Errorf("Error unmarhsaling state delta : %s", err) } // protobuff makes an empty []byte into a nil. So, assigning an empty byte array explicitly if value == nil { value = []byte{} } return value, nil }
func _DropRowRangeRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*DropRowRangeRequest) switch tag { case 2: // target.row_key_prefix if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeRawBytes(true) m.Target = &DropRowRangeRequest_RowKeyPrefix{x} return true, err case 3: // target.delete_all_data_from_table if wire != proto.WireVarint { return true, proto.ErrInternalBadWireType } x, err := b.DecodeVarint() m.Target = &DropRowRangeRequest_DeleteAllDataFromTable{x != 0} 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 _ReadOptions_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*ReadOptions) switch tag { case 1: // consistency_type.read_consistency if wire != proto.WireVarint { return true, proto.ErrInternalBadWireType } x, err := b.DecodeVarint() m.ConsistencyType = &ReadOptions_ReadConsistency_{ReadOptions_ReadConsistency(x)} return true, err case 2: // consistency_type.transaction if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeRawBytes(true) m.ConsistencyType = &ReadOptions_Transaction{x} return true, err default: return false, nil } }
func _GqlQueryParameter_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*GqlQueryParameter) switch tag { case 2: // parameter_type.value if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Value) err := b.DecodeMessage(msg) m.ParameterType = &GqlQueryParameter_Value{msg} return true, err case 3: // parameter_type.cursor if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeRawBytes(true) m.ParameterType = &GqlQueryParameter_Cursor{x} return true, err default: return false, nil } }
func _RPC_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*RPC) switch tag { case 1: // args_oneof.args if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(JSONArray) err := b.DecodeMessage(msg) m.ArgsOneof = &RPC_Args{msg} return true, err case 2: // args_oneof.byte_args if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeRawBytes(true) m.ArgsOneof = &RPC_ByteArgs{x} return true, err default: return false, nil } }
func _PrintContent_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*PrintContent) switch tag { case 1: // print_content_type.printInfo if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(PrintInfo) err := b.DecodeMessage(msg) m.PrintContentType = &PrintContent_PrintInfo{msg} return true, err case 2: // print_content_type.content if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeRawBytes(true) m.PrintContentType = &PrintContent_Content{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 _RPCReply_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*RPCReply) switch tag { case 1: // result_oneof.result if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(JSON) err := b.DecodeMessage(msg) m.ResultOneof = &RPCReply_Result{msg} return true, err case 2: // result_oneof.byte_result if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeRawBytes(true) m.ResultOneof = &RPCReply_ByteResult{x} return true, err case 3: // result_oneof.error if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(JSON) err := b.DecodeMessage(msg) m.ResultOneof = &RPCReply_Error{msg} return true, err case 4: // result_oneof.byte_error if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeRawBytes(true) m.ResultOneof = &RPCReply_ByteError{x} return true, err default: return false, nil } }
func _SieveMessage_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*SieveMessage) switch tag { case 1: // payload.request if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeRawBytes(true) m.Payload = &SieveMessage_Request{x} return true, err case 2: // payload.execute if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Execute) err := b.DecodeMessage(msg) m.Payload = &SieveMessage_Execute{msg} return true, err case 3: // payload.verify if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Verify) err := b.DecodeMessage(msg) m.Payload = &SieveMessage_Verify{msg} return true, err case 4: // payload.pbft_message if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeRawBytes(true) m.Payload = &SieveMessage_PbftMessage{x} 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 } }
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 } }