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 _ModifyColumnFamiliesRequest_Modification_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*ModifyColumnFamiliesRequest_Modification)
switch tag {
case 2: // mod.create
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(ColumnFamily)
err := b.DecodeMessage(msg)
m.Mod = &ModifyColumnFamiliesRequest_Modification_Create{msg}
return true, err
case 3: // mod.update
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(ColumnFamily)
err := b.DecodeMessage(msg)
m.Mod = &ModifyColumnFamiliesRequest_Modification_Update{msg}
return true, err
case 4: // mod.drop
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Mod = &ModifyColumnFamiliesRequest_Modification_Drop{x != 0}
return true, err
default:
return false, nil
}
}
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 _ReadRowsResponse_Chunk_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*ReadRowsResponse_Chunk)
switch tag {
case 1: // chunk.row_contents
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(google_bigtable_v11.Family)
err := b.DecodeMessage(msg)
m.Chunk = &ReadRowsResponse_Chunk_RowContents{msg}
return true, err
case 2: // chunk.reset_row
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Chunk = &ReadRowsResponse_Chunk_ResetRow{x != 0}
return true, err
case 3: // chunk.commit_row
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Chunk = &ReadRowsResponse_Chunk_CommitRow{x != 0}
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 _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 _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
}
}
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
}
}
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 _ZoneServerMsg_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*ZoneServerMsg)
switch tag {
case 1: // Msg.ForWardZoneStartupMsg
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(ForWardZoneStartupMsg)
err := b.DecodeMessage(msg)
m.Msg = &ZoneServerMsg_ForWardZoneStartupMsg{msg}
return true, err
default:
return false, nil
}
}
func _WatchRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*WatchRequest)
switch tag {
case 1: // request_union.create_request
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(WatchCreateRequest)
err := b.DecodeMessage(msg)
m.RequestUnion = &WatchRequest_CreateRequest{msg}
return true, err
default:
return false, nil
}
}
func _Message_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Message)
switch tag {
case 1: // protocol.lorawan
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(lorawan.Message)
err := b.DecodeMessage(msg)
m.Protocol = &Message_Lorawan{msg}
return true, err
default:
return false, nil
}
}
func _ArchiveServerConfig_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*ArchiveServerConfig)
switch tag {
case 3: // credentials.ssl_credentials
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(ArchiveServerConfig_SslCredentials)
err := b.DecodeMessage(msg)
m.Credentials = &ArchiveServerConfig_SslCredentials_{msg}
return true, err
default:
return false, nil
}
}
func _Interest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Interest)
switch tag {
case 2: // RegInfo.chaincodeRegInfo
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(ChaincodeReg)
err := b.DecodeMessage(msg)
m.RegInfo = &Interest_ChaincodeRegInfo{msg}
return true, err
default:
return false, nil
}
}
func _Policy_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Policy)
switch tag {
case 1: // Type.SignaturePolicy
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(SignaturePolicyEnvelope)
err := b.DecodeMessage(msg)
m.Type = &Policy_SignaturePolicy{msg}
return true, err
default:
return false, nil
}
}
func _PipelineSource_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*PipelineSource)
switch tag {
case 4: // typed_pipeline_source.github_pipeline_source
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(GithubPipelineSource)
err := b.DecodeMessage(msg)
m.TypedPipelineSource = &PipelineSource_GithubPipelineSource{msg}
return true, err
default:
return false, nil
}
}
func _Command_OneofUnmarshaler(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error) {
m := msg.(*Command)
switch tag {
case 2: // command.say
if wire != proto1.WireBytes {
return true, proto1.ErrInternalBadWireType
}
msg := new(CommandSay)
err := b.DecodeMessage(msg)
m.Command = &Command_Say{msg}
return true, err
case 3: // command.nick
if wire != proto1.WireBytes {
return true, proto1.ErrInternalBadWireType
}
msg := new(CommandChangeNick)
err := b.DecodeMessage(msg)
m.Command = &Command_Nick{msg}
return true, err
case 4: // command.join
if wire != proto1.WireBytes {
return true, proto1.ErrInternalBadWireType
}
msg := new(CommandJoinChannel)
err := b.DecodeMessage(msg)
m.Command = &Command_Join{msg}
return true, err
case 5: // command.leave
if wire != proto1.WireBytes {
return true, proto1.ErrInternalBadWireType
}
msg := new(CommandLeaveChannel)
err := b.DecodeMessage(msg)
m.Command = &Command_Leave{msg}
return true, err
case 6: // command.exit
if wire != proto1.WireBytes {
return true, proto1.ErrInternalBadWireType
}
msg := new(CommandExit)
err := b.DecodeMessage(msg)
m.Command = &Command_Exit{msg}
return true, err
default:
return false, nil
}
}
func _LoadParams_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*LoadParams)
switch tag {
case 1: // load.closed_loop
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(ClosedLoopParams)
err := b.DecodeMessage(msg)
m.Load = &LoadParams_ClosedLoop{msg}
return true, err
case 2: // load.poisson
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(PoissonParams)
err := b.DecodeMessage(msg)
m.Load = &LoadParams_Poisson{msg}
return true, err
case 3: // load.uniform
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(UniformParams)
err := b.DecodeMessage(msg)
m.Load = &LoadParams_Uniform{msg}
return true, err
case 4: // load.determ
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(DeterministicParams)
err := b.DecodeMessage(msg)
m.Load = &LoadParams_Determ{msg}
return true, err
case 5: // load.pareto
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(ParetoParams)
err := b.DecodeMessage(msg)
m.Load = &LoadParams_Pareto{msg}
return true, err
default:
return false, nil
}
}
func _Event_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Event)
switch tag {
case 1: // Event.register
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Register)
err := b.DecodeMessage(msg)
m.Event = &Event_Register{msg}
return true, err
case 2: // Event.block
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Block)
err := b.DecodeMessage(msg)
m.Event = &Event_Block{msg}
return true, err
case 3: // Event.chaincodeEvent
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(ChaincodeEvent)
err := b.DecodeMessage(msg)
m.Event = &Event_ChaincodeEvent{msg}
return true, err
case 4: // Event.rejection
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Rejection)
err := b.DecodeMessage(msg)
m.Event = &Event_Rejection{msg}
return true, err
case 5: // Event.unregister
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Unregister)
err := b.DecodeMessage(msg)
m.Event = &Event_Unregister{msg}
return true, err
default:
return false, 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 _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 _Wrapper_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Wrapper)
switch tag {
case 1: // content.message
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Message)
err := b.DecodeMessage(msg)
m.Content = &Wrapper_Message{msg}
return true, err
case 2: // content.request
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Request)
err := b.DecodeMessage(msg)
m.Content = &Wrapper_Request{msg}
return true, err
case 3: // content.response
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Response)
err := b.DecodeMessage(msg)
m.Content = &Wrapper_Response{msg}
return true, err
default:
return false, nil
}
}
func _KafkaMessage_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*KafkaMessage)
switch tag {
case 1: // Type.regular
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(KafkaMessageRegular)
err := b.DecodeMessage(msg)
m.Type = &KafkaMessage_Regular{msg}
return true, err
case 2: // Type.time_to_cut
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(KafkaMessageTimeToCut)
err := b.DecodeMessage(msg)
m.Type = &KafkaMessage_TimeToCut{msg}
return true, err
case 3: // Type.connect
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(KafkaMessageConnect)
err := b.DecodeMessage(msg)
m.Type = &KafkaMessage_Connect{msg}
return true, err
default:
return false, nil
}
}
func _PayloadConfig_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*PayloadConfig)
switch tag {
case 1: // payload.bytebuf_params
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(ByteBufferParams)
err := b.DecodeMessage(msg)
m.Payload = &PayloadConfig_BytebufParams{msg}
return true, err
case 2: // payload.simple_params
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(SimpleProtoParams)
err := b.DecodeMessage(msg)
m.Payload = &PayloadConfig_SimpleParams{msg}
return true, err
case 3: // payload.complex_params
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(ComplexProtoParams)
err := b.DecodeMessage(msg)
m.Payload = &PayloadConfig_ComplexParams{msg}
return true, err
default:
return false, nil
}
}
func _Distribution_BucketOptions_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Distribution_BucketOptions)
switch tag {
case 1: // options.linear_buckets
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Distribution_BucketOptions_Linear)
err := b.DecodeMessage(msg)
m.Options = &Distribution_BucketOptions_LinearBuckets{msg}
return true, err
case 2: // options.exponential_buckets
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Distribution_BucketOptions_Exponential)
err := b.DecodeMessage(msg)
m.Options = &Distribution_BucketOptions_ExponentialBuckets{msg}
return true, err
case 3: // options.explicit_buckets
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Distribution_BucketOptions_Explicit)
err := b.DecodeMessage(msg)
m.Options = &Distribution_BucketOptions_ExplicitBuckets{msg}
return true, err
default:
return false, nil
}
}
func _OpenchainEvent_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*OpenchainEvent)
switch tag {
case 1: // Event.register
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Register)
err := b.DecodeMessage(msg)
m.Event = &OpenchainEvent_Register{msg}
return true, err
case 2: // Event.block
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Block)
err := b.DecodeMessage(msg)
m.Event = &OpenchainEvent_Block{msg}
return true, err
case 3: // Event.generic
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Generic)
err := b.DecodeMessage(msg)
m.Event = &OpenchainEvent_Generic{msg}
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 _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 _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 _FrontendConfig_Backend_OneofUnmarshaler(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error) {
m := msg.(*FrontendConfig_Backend)
switch tag {
case 3: // security.tls
if wire != proto1.WireBytes {
return true, proto1.ErrInternalBadWireType
}
msg := new(TLSConfig)
err := b.DecodeMessage(msg)
m.Security = &FrontendConfig_Backend_Tls{msg}
return true, err
case 4: // security.insecure
if wire != proto1.WireVarint {
return true, proto1.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Security = &FrontendConfig_Backend_Insecure{x != 0}
return true, err
default:
return false, nil
}
}
