func _OneofStdTypes_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*OneofStdTypes) switch tag { case 1: // OneOfStdTimes.timestamp if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeRawBytes(true) if err != nil { return true, err } c := new(time.Time) if err2 := github_com_gogo_protobuf_types.StdTimeUnmarshal(c, x); err2 != nil { return true, err } m.OneOfStdTimes = &OneofStdTypes_Timestamp{c} return true, err case 2: // OneOfStdTimes.duration if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeRawBytes(true) if err != nil { return true, err } c := new(time.Duration) if err2 := github_com_gogo_protobuf_types.StdDurationUnmarshal(c, x); err2 != nil { return true, err } m.OneOfStdTimes = &OneofStdTypes_Duration{c} return true, err default: return false, nil } }
func _CommitRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*CommitRequest) // transaction_selector switch x := m.TransactionSelector.(type) { case *CommitRequest_Transaction: _ = b.EncodeVarint(1<<3 | proto.WireBytes) _ = b.EncodeRawBytes(x.Transaction) case nil: default: return fmt.Errorf("CommitRequest.TransactionSelector has unexpected type %T", x) } 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 case 4: // union.home_address if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeStringBytes() m.Union = &MsgWithOneof_HomeAddress{x} 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 } }
func _OneofStdTypes_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*OneofStdTypes) // OneOfStdTimes switch x := m.OneOfStdTimes.(type) { case *OneofStdTypes_Timestamp: _ = b.EncodeVarint(1<<3 | proto.WireBytes) dAtA, err := github_com_gogo_protobuf_types.StdTimeMarshal(*x.Timestamp) if err != nil { return err } if err := b.EncodeRawBytes(dAtA); err != nil { return err } case *OneofStdTypes_Duration: _ = b.EncodeVarint(2<<3 | proto.WireBytes) dAtA, err := github_com_gogo_protobuf_types.StdDurationMarshal(*x.Duration) if err != nil { return err } if err := b.EncodeRawBytes(dAtA); err != nil { return err } case nil: default: return fmt.Errorf("OneofStdTypes.OneOfStdTimes has unexpected type %T", x) } return 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 _WatchRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*WatchRequest) // request_union switch x := m.RequestUnion.(type) { case *WatchRequest_CreateRequest: _ = b.EncodeVarint(1<<3 | proto.WireBytes) if err := b.EncodeMessage(x.CreateRequest); err != nil { return err } case nil: default: return fmt.Errorf("WatchRequest.RequestUnion has unexpected type %T", x) } return nil }
func _Mutation_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*Mutation) switch tag { case 4: // operation.insert if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Entity) err := b.DecodeMessage(msg) m.Operation = &Mutation_Insert{msg} return true, err case 5: // operation.update if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Entity) err := b.DecodeMessage(msg) m.Operation = &Mutation_Update{msg} return true, err case 6: // operation.upsert if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Entity) err := b.DecodeMessage(msg) m.Operation = &Mutation_Upsert{msg} return true, err case 7: // operation.delete if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Key) err := b.DecodeMessage(msg) m.Operation = &Mutation_Delete{msg} return true, err case 8: // conflict_detection_strategy.base_version if wire != proto.WireVarint { return true, proto.ErrInternalBadWireType } x, err := b.DecodeVarint() m.ConflictDetectionStrategy = &Mutation_BaseVersion{int64(x)} 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 _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 _Bar_OneofUnmarshaler(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error) { m := msg.(*Bar) switch tag { case 11: // pick.a if wire != proto1.WireVarint { return true, proto1.ErrInternalBadWireType } x, err := b.DecodeVarint() m.Pick = &Bar_A{x != 0} return true, err case 12: // pick.b if wire != proto1.WireVarint { return true, proto1.ErrInternalBadWireType } x, err := b.DecodeVarint() m.Pick = &Bar_B{x != 0} 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 _Tree_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*Tree) switch tag { case 1: // stuff.ValueString if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeStringBytes() m.Stuff = &Tree_ValueString{x} return true, err case 4: // stuff.ValueNum if wire != proto.WireVarint { return true, proto.ErrInternalBadWireType } x, err := b.DecodeVarint() m.Stuff = &Tree_ValueNum{x} return true, err default: return false, nil } }
func _Session_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*Session) switch tag { case 5: // timezone.location if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeStringBytes() m.Timezone = &Session_Location{x} return true, err case 6: // timezone.offset if wire != proto.WireVarint { return true, proto.ErrInternalBadWireType } x, err := b.DecodeVarint() m.Timezone = &Session_Offset{int64(x)} 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 _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 _Response_Result_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*Response_Result) switch tag { case 2: // union.ddl if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Response_Result_DDL) err := b.DecodeMessage(msg) m.Union = &Response_Result_DDL_{msg} return true, err case 3: // union.rows_affected if wire != proto.WireVarint { return true, proto.ErrInternalBadWireType } x, err := b.DecodeVarint() m.Union = &Response_Result_RowsAffected{uint32(x)} return true, err case 4: // union.rows if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Response_Result_Rows) err := b.DecodeMessage(msg) m.Union = &Response_Result_Rows_{msg} 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 _Descriptor_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*Descriptor) switch tag { case 1: // union.table if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(TableDescriptor) err := b.DecodeMessage(msg) m.Union = &Descriptor_Table{msg} return true, err case 2: // union.database if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(DatabaseDescriptor) err := b.DecodeMessage(msg) m.Union = &Descriptor_Database{msg} return true, err default: return false, nil } }
func _Filter_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*Filter) switch tag { case 1: // filter_type.composite_filter if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(CompositeFilter) err := b.DecodeMessage(msg) m.FilterType = &Filter_CompositeFilter{msg} return true, err case 2: // filter_type.property_filter if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(PropertyFilter) err := b.DecodeMessage(msg) m.FilterType = &Filter_PropertyFilter{msg} return true, err default: return false, nil } }
func _Session_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*Session) // timezone switch x := m.Timezone.(type) { case *Session_Location: _ = b.EncodeVarint(5<<3 | proto.WireBytes) _ = b.EncodeStringBytes(x.Location) case *Session_Offset: _ = b.EncodeVarint(6<<3 | proto.WireVarint) _ = b.EncodeVarint(uint64(x.Offset)) case nil: default: return fmt.Errorf("Session.Timezone has unexpected type %T", x) } return nil }
func _MsgWithOneof_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*MsgWithOneof) // union switch x := m.Union.(type) { case *MsgWithOneof_Title: _ = b.EncodeVarint(1<<3 | proto.WireBytes) _ = b.EncodeStringBytes(x.Title) case *MsgWithOneof_Salary: _ = b.EncodeVarint(2<<3 | proto.WireVarint) _ = b.EncodeVarint(uint64(x.Salary)) case nil: default: return fmt.Errorf("MsgWithOneof.Union has unexpected type %T", x) } return nil }
func _RunQueryRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*RunQueryRequest) switch tag { case 3: // query_type.query if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Query) err := b.DecodeMessage(msg) m.QueryType = &RunQueryRequest_Query{msg} return true, err case 7: // query_type.gql_query if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(GqlQuery) err := b.DecodeMessage(msg) m.QueryType = &RunQueryRequest_GqlQuery{msg} return true, err default: return false, nil } }
func _ReadOptions_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*ReadOptions) // consistency_type switch x := m.ConsistencyType.(type) { case *ReadOptions_ReadConsistency_: _ = b.EncodeVarint(1<<3 | proto.WireVarint) _ = b.EncodeVarint(uint64(x.ReadConsistency)) case *ReadOptions_Transaction: _ = b.EncodeVarint(2<<3 | proto.WireBytes) _ = b.EncodeRawBytes(x.Transaction) case nil: default: return fmt.Errorf("ReadOptions.ConsistencyType has unexpected type %T", x) } return nil }
func _Tree_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*Tree) // stuff switch x := m.Stuff.(type) { case *Tree_ValueString: _ = b.EncodeVarint(1<<3 | proto.WireBytes) _ = b.EncodeStringBytes(x.ValueString) case *Tree_ValueNum: _ = b.EncodeVarint(4<<3 | proto.WireVarint) _ = b.EncodeVarint(uint64(x.ValueNum)) case nil: default: return fmt.Errorf("Tree.Stuff has unexpected type %T", x) } return nil }
func _Key_PathElement_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*Key_PathElement) // id_type switch x := m.IdType.(type) { case *Key_PathElement_Id: _ = b.EncodeVarint(2<<3 | proto.WireVarint) _ = b.EncodeVarint(uint64(x.Id)) case *Key_PathElement_Name: _ = b.EncodeVarint(3<<3 | proto.WireBytes) _ = b.EncodeStringBytes(x.Name) case nil: default: return fmt.Errorf("Key_PathElement.IdType has unexpected type %T", x) } return nil }
func _Operation_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*Operation) switch tag { case 4: // result.error if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(google_rpc.Status) err := b.DecodeMessage(msg) m.Result = &Operation_Error{msg} return true, err case 5: // result.response if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(google_protobuf1.Any) err := b.DecodeMessage(msg) m.Result = &Operation_Response{msg} return true, err default: return false, nil } }
func _GqlQueryParameter_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*GqlQueryParameter) // parameter_type switch x := m.ParameterType.(type) { case *GqlQueryParameter_Value: _ = b.EncodeVarint(2<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Value); err != nil { return err } case *GqlQueryParameter_Cursor: _ = b.EncodeVarint(3<<3 | proto.WireBytes) _ = b.EncodeRawBytes(x.Cursor) case nil: default: return fmt.Errorf("GqlQueryParameter.ParameterType has unexpected type %T", x) } return nil }
func _Filter_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*Filter) // filter_type switch x := m.FilterType.(type) { case *Filter_CompositeFilter: _ = b.EncodeVarint(1<<3 | proto.WireBytes) if err := b.EncodeMessage(x.CompositeFilter); err != nil { return err } case *Filter_PropertyFilter: _ = b.EncodeVarint(2<<3 | proto.WireBytes) if err := b.EncodeMessage(x.PropertyFilter); err != nil { return err } case nil: default: return fmt.Errorf("Filter.FilterType has unexpected type %T", x) } return nil }
func _Operation_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*Operation) // result switch x := m.Result.(type) { case *Operation_Error: _ = b.EncodeVarint(4<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Error); err != nil { return err } case *Operation_Response: _ = b.EncodeVarint(5<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Response); err != nil { return err } case nil: default: return fmt.Errorf("Operation.Result has unexpected type %T", x) } return nil }