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
}