func _RowValue_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*RowValue)
// value
switch x := m.Value.(type) {
case *RowValue_Str:
_ = b.EncodeVarint(1<<3 | proto.WireBytes)
_ = b.EncodeStringBytes(x.Str)
case *RowValue_Int:
_ = b.EncodeVarint(2<<3 | proto.WireVarint)
_ = b.EncodeVarint(uint64(x.Int))
case *RowValue_Real:
_ = b.EncodeVarint(3<<3 | proto.WireFixed32)
_ = b.EncodeFixed32(uint64(math.Float32bits(x.Real)))
case *RowValue_Date:
_ = b.EncodeVarint(4<<3 | proto.WireVarint)
_ = b.EncodeVarint(uint64(x.Date))
case *RowValue_DateOfTime:
_ = b.EncodeVarint(5<<3 | proto.WireVarint)
_ = b.EncodeVarint(uint64(x.DateOfTime))
case *RowValue_TimeOfDay:
_ = b.EncodeVarint(6<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.TimeOfDay); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("RowValue.Value has unexpected type %T", x)
}
return nil
}
func _HttpRule_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*HttpRule)
// pattern
switch x := m.Pattern.(type) {
case *HttpRule_Get:
_ = b.EncodeVarint(2<<3 | proto.WireBytes)
_ = b.EncodeStringBytes(x.Get)
case *HttpRule_Put:
_ = b.EncodeVarint(3<<3 | proto.WireBytes)
_ = b.EncodeStringBytes(x.Put)
case *HttpRule_Post:
_ = b.EncodeVarint(4<<3 | proto.WireBytes)
_ = b.EncodeStringBytes(x.Post)
case *HttpRule_Delete:
_ = b.EncodeVarint(5<<3 | proto.WireBytes)
_ = b.EncodeStringBytes(x.Delete)
case *HttpRule_Patch:
_ = b.EncodeVarint(6<<3 | proto.WireBytes)
_ = b.EncodeStringBytes(x.Patch)
case *HttpRule_Custom:
_ = b.EncodeVarint(8<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Custom); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("HttpRule.Pattern has unexpected type %T", x)
}
return nil
}
func _Value_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Value)
// value_type
switch x := m.ValueType.(type) {
case *Value_NullValue:
_ = b.EncodeVarint(11<<3 | proto.WireVarint)
_ = b.EncodeVarint(uint64(x.NullValue))
case *Value_BooleanValue:
t := uint64(0)
if x.BooleanValue {
t = 1
}
_ = b.EncodeVarint(1<<3 | proto.WireVarint)
_ = b.EncodeVarint(t)
case *Value_IntegerValue:
_ = b.EncodeVarint(2<<3 | proto.WireVarint)
_ = b.EncodeVarint(uint64(x.IntegerValue))
case *Value_DoubleValue:
_ = b.EncodeVarint(3<<3 | proto.WireFixed64)
_ = b.EncodeFixed64(math.Float64bits(x.DoubleValue))
case *Value_TimestampValue:
_ = b.EncodeVarint(10<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.TimestampValue); err != nil {
return err
}
case *Value_KeyValue:
_ = b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.KeyValue); err != nil {
return err
}
case *Value_StringValue:
_ = b.EncodeVarint(17<<3 | proto.WireBytes)
_ = b.EncodeStringBytes(x.StringValue)
case *Value_BlobValue:
_ = b.EncodeVarint(18<<3 | proto.WireBytes)
_ = b.EncodeRawBytes(x.BlobValue)
case *Value_GeoPointValue:
_ = b.EncodeVarint(8<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.GeoPointValue); err != nil {
return err
}
case *Value_EntityValue:
_ = b.EncodeVarint(6<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.EntityValue); err != nil {
return err
}
case *Value_ArrayValue:
_ = b.EncodeVarint(9<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ArrayValue); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Value.ValueType has unexpected type %T", x)
}
return nil
}
func _Mutation_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Mutation)
// operation
switch x := m.Operation.(type) {
case *Mutation_Insert:
_ = b.EncodeVarint(4<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Insert); err != nil {
return err
}
case *Mutation_Update:
_ = b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Update); err != nil {
return err
}
case *Mutation_Upsert:
_ = b.EncodeVarint(6<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Upsert); err != nil {
return err
}
case *Mutation_Delete:
_ = b.EncodeVarint(7<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Delete); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Mutation.Operation has unexpected type %T", x)
}
return nil
}
func _Communique_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Communique)
// union
switch x := m.Union.(type) {
case *Communique_Number:
_ = b.EncodeVarint(5<<3 | proto.WireVarint)
_ = b.EncodeVarint(uint64(x.Number))
case *Communique_Name:
_ = b.EncodeVarint(6<<3 | proto.WireBytes)
_ = b.EncodeStringBytes(x.Name)
case *Communique_Data:
_ = b.EncodeVarint(7<<3 | proto.WireBytes)
_ = b.EncodeRawBytes(x.Data)
case *Communique_TempC:
_ = b.EncodeVarint(8<<3 | proto.WireFixed64)
_ = b.EncodeFixed64(math.Float64bits(x.TempC))
case *Communique_Height:
_ = b.EncodeVarint(9<<3 | proto.WireFixed32)
_ = b.EncodeFixed32(uint64(math.Float32bits(x.Height)))
case *Communique_Today:
_ = b.EncodeVarint(10<<3 | proto.WireVarint)
_ = b.EncodeVarint(uint64(x.Today))
case *Communique_Maybe:
t := uint64(0)
if x.Maybe {
t = 1
}
_ = b.EncodeVarint(11<<3 | proto.WireVarint)
_ = b.EncodeVarint(t)
case *Communique_Delta_:
_ = b.EncodeVarint(12<<3 | proto.WireVarint)
_ = b.EncodeZigzag32(uint64(x.Delta))
case *Communique_Msg:
_ = b.EncodeVarint(13<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Msg); err != nil {
return err
}
case *Communique_Somegroup:
_ = b.EncodeVarint(14<<3 | proto.WireStartGroup)
if err := b.Marshal(x.Somegroup); err != nil {
return err
}
_ = b.EncodeVarint(14<<3 | proto.WireEndGroup)
case nil:
default:
return fmt.Errorf("Communique.Union has unexpected type %T", x)
}
return 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 _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 _Datum_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Datum)
// payload
switch x := m.Payload.(type) {
case *Datum_BoolVal:
t := uint64(0)
if x.BoolVal {
t = 1
}
_ = b.EncodeVarint(1<<3 | proto.WireVarint)
_ = b.EncodeVarint(t)
case *Datum_IntVal:
_ = b.EncodeVarint(2<<3 | proto.WireVarint)
_ = b.EncodeVarint(uint64(x.IntVal))
case *Datum_FloatVal:
_ = b.EncodeVarint(3<<3 | proto.WireFixed64)
_ = b.EncodeFixed64(math.Float64bits(x.FloatVal))
case *Datum_BytesVal:
_ = b.EncodeVarint(4<<3 | proto.WireBytes)
_ = b.EncodeRawBytes(x.BytesVal)
case *Datum_StringVal:
_ = b.EncodeVarint(5<<3 | proto.WireBytes)
_ = b.EncodeStringBytes(x.StringVal)
case *Datum_DateVal:
_ = b.EncodeVarint(6<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.DateVal); err != nil {
return err
}
case *Datum_TimeVal:
_ = b.EncodeVarint(7<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.TimeVal); err != nil {
return err
}
case *Datum_IntervalVal:
_ = b.EncodeVarint(8<<3 | proto.WireVarint)
_ = b.EncodeVarint(uint64(x.IntervalVal))
case nil:
default:
return fmt.Errorf("Datum.Payload 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
}
func _RunQueryRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*RunQueryRequest)
// query_type
switch x := m.QueryType.(type) {
case *RunQueryRequest_Query:
_ = b.EncodeVarint(3<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Query); err != nil {
return err
}
case *RunQueryRequest_GqlQuery:
_ = b.EncodeVarint(7<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.GqlQuery); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("RunQueryRequest.QueryType 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 _Descriptor_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Descriptor)
// union
switch x := m.Union.(type) {
case *Descriptor_Table:
_ = b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Table); err != nil {
return err
}
case *Descriptor_Database:
_ = b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Database); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Descriptor.Union has unexpected type %T", x)
}
return nil
}
func _Distribution_BucketOptions_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Distribution_BucketOptions)
// options
switch x := m.Options.(type) {
case *Distribution_BucketOptions_LinearBuckets:
_ = b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.LinearBuckets); err != nil {
return err
}
case *Distribution_BucketOptions_ExponentialBuckets:
_ = b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ExponentialBuckets); err != nil {
return err
}
case *Distribution_BucketOptions_ExplicitBuckets:
_ = b.EncodeVarint(3<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ExplicitBuckets); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Distribution_BucketOptions.Options has unexpected type %T", x)
}
return nil
}
func _LogEntry_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*LogEntry)
// payload
switch x := m.Payload.(type) {
case *LogEntry_ProtoPayload:
_ = b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ProtoPayload); err != nil {
return err
}
case *LogEntry_TextPayload:
_ = b.EncodeVarint(3<<3 | proto.WireBytes)
_ = b.EncodeStringBytes(x.TextPayload)
case *LogEntry_JsonPayload:
_ = b.EncodeVarint(6<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.JsonPayload); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("LogEntry.Payload has unexpected type %T", x)
}
return nil
}
func _Response_Result_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Response_Result)
// union
switch x := m.Union.(type) {
case *Response_Result_DDL_:
_ = b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.DDL); err != nil {
return err
}
case *Response_Result_RowsAffected:
_ = b.EncodeVarint(3<<3 | proto.WireVarint)
_ = b.EncodeVarint(uint64(x.RowsAffected))
case *Response_Result_Rows_:
_ = b.EncodeVarint(4<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Rows); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Response_Result.Union has unexpected type %T", x)
}
return nil
}
func _Value_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Value)
// kind
switch x := m.Kind.(type) {
case *Value_NullValue:
_ = b.EncodeVarint(1<<3 | proto.WireVarint)
_ = b.EncodeVarint(uint64(x.NullValue))
case *Value_NumberValue:
_ = b.EncodeVarint(2<<3 | proto.WireFixed64)
_ = b.EncodeFixed64(math.Float64bits(x.NumberValue))
case *Value_StringValue:
_ = b.EncodeVarint(3<<3 | proto.WireBytes)
_ = b.EncodeStringBytes(x.StringValue)
case *Value_BoolValue:
t := uint64(0)
if x.BoolValue {
t = 1
}
_ = b.EncodeVarint(4<<3 | proto.WireVarint)
_ = b.EncodeVarint(t)
case *Value_StructValue:
_ = b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.StructValue); err != nil {
return err
}
case *Value_ListValue:
_ = b.EncodeVarint(6<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ListValue); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Value.Kind has unexpected type %T", x)
}
return nil
}
func _Mutation_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Mutation)
// operation
switch x := m.Operation.(type) {
case *Mutation_Insert:
_ = b.EncodeVarint(4<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Insert); err != nil {
return err
}
case *Mutation_Update:
_ = b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Update); err != nil {
return err
}
case *Mutation_Upsert:
_ = b.EncodeVarint(6<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Upsert); err != nil {
return err
}
case *Mutation_Delete:
_ = b.EncodeVarint(7<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Delete); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Mutation.Operation has unexpected type %T", x)
}
// conflict_detection_strategy
switch x := m.ConflictDetectionStrategy.(type) {
case *Mutation_BaseVersion:
_ = b.EncodeVarint(8<<3 | proto.WireVarint)
_ = b.EncodeVarint(uint64(x.BaseVersion))
case nil:
default:
return fmt.Errorf("Mutation.ConflictDetectionStrategy has unexpected type %T", x)
}
return nil
}
func _Response_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Response)
// message
switch x := m.Message.(type) {
case *Response_Info:
_ = b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Info); err != nil {
return err
}
case *Response_Init:
_ = b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Init); err != nil {
return err
}
case *Response_Keepalive:
_ = b.EncodeVarint(3<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Keepalive); err != nil {
return err
}
case *Response_Snapshot:
_ = b.EncodeVarint(4<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Snapshot); err != nil {
return err
}
case *Response_Restore:
_ = b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Restore); err != nil {
return err
}
case *Response_Error:
_ = b.EncodeVarint(6<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Error); err != nil {
return err
}
case *Response_Begin:
_ = b.EncodeVarint(16<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Begin); err != nil {
return err
}
case *Response_Point:
_ = b.EncodeVarint(17<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Point); err != nil {
return err
}
case *Response_End:
_ = b.EncodeVarint(18<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.End); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Response.Message has unexpected type %T", x)
}
return nil
}