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 } }