func _StreamMessage_OneofSizer(msg proto.Message) (n int) { m := msg.(*StreamMessage) // message_oneof switch x := m.MessageOneof.(type) { case *StreamMessage_Rpc: s := proto.Size(x.Rpc) n += proto.SizeVarint(1<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *StreamMessage_Message: s := proto.Size(x.Message) n += proto.SizeVarint(2<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *StreamMessage_ByteMessage: n += proto.SizeVarint(3<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.ByteMessage))) n += len(x.ByteMessage) case *StreamMessage_Error: s := proto.Size(x.Error) n += proto.SizeVarint(4<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *StreamMessage_ByteError: n += proto.SizeVarint(5<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.ByteError))) n += len(x.ByteError) case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _RPCReply_OneofSizer(msg proto.Message) (n int) { m := msg.(*RPCReply) // result_oneof switch x := m.ResultOneof.(type) { case *RPCReply_Result: s := proto.Size(x.Result) n += proto.SizeVarint(1<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *RPCReply_ByteResult: n += proto.SizeVarint(2<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.ByteResult))) n += len(x.ByteResult) case *RPCReply_Error: s := proto.Size(x.Error) n += proto.SizeVarint(3<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *RPCReply_ByteError: n += proto.SizeVarint(4<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.ByteError))) n += len(x.ByteError) case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _Distribution_BucketOptions_OneofSizer(msg proto.Message) (n int) { m := msg.(*Distribution_BucketOptions) // options switch x := m.Options.(type) { case *Distribution_BucketOptions_LinearBuckets: s := proto.Size(x.LinearBuckets) n += proto.SizeVarint(1<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Distribution_BucketOptions_ExponentialBuckets: s := proto.Size(x.ExponentialBuckets) n += proto.SizeVarint(2<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Distribution_BucketOptions_ExplicitBuckets: s := proto.Size(x.ExplicitBuckets) n += proto.SizeVarint(3<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _LoadParams_OneofSizer(msg proto.Message) (n int) { m := msg.(*LoadParams) // load switch x := m.Load.(type) { case *LoadParams_ClosedLoop: s := proto.Size(x.ClosedLoop) n += proto.SizeVarint(1<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *LoadParams_Poisson: s := proto.Size(x.Poisson) n += proto.SizeVarint(2<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *LoadParams_Uniform: s := proto.Size(x.Uniform) n += proto.SizeVarint(3<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *LoadParams_Determ: s := proto.Size(x.Determ) n += proto.SizeVarint(4<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *LoadParams_Pareto: s := proto.Size(x.Pareto) n += proto.SizeVarint(5<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _ServerReflectionResponse_OneofSizer(msg proto.Message) (n int) { m := msg.(*ServerReflectionResponse) // message_response switch x := m.MessageResponse.(type) { case *ServerReflectionResponse_FileDescriptorResponse: s := proto.Size(x.FileDescriptorResponse) n += proto.SizeVarint(4<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *ServerReflectionResponse_AllExtensionNumbersResponse: s := proto.Size(x.AllExtensionNumbersResponse) n += proto.SizeVarint(5<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *ServerReflectionResponse_ListServicesResponse: s := proto.Size(x.ListServicesResponse) n += proto.SizeVarint(6<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *ServerReflectionResponse_ErrorResponse: s := proto.Size(x.ErrorResponse) n += proto.SizeVarint(7<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _KafkaMessage_OneofSizer(msg proto.Message) (n int) { m := msg.(*KafkaMessage) // Type switch x := m.Type.(type) { case *KafkaMessage_Regular: s := proto.Size(x.Regular) n += proto.SizeVarint(1<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *KafkaMessage_TimeToCut: s := proto.Size(x.TimeToCut) n += proto.SizeVarint(2<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *KafkaMessage_Connect: s := proto.Size(x.Connect) n += proto.SizeVarint(3<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _PayloadConfig_OneofSizer(msg proto.Message) (n int) { m := msg.(*PayloadConfig) // payload switch x := m.Payload.(type) { case *PayloadConfig_BytebufParams: s := proto.Size(x.BytebufParams) n += proto.SizeVarint(1<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *PayloadConfig_SimpleParams: s := proto.Size(x.SimpleParams) n += proto.SizeVarint(2<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *PayloadConfig_ComplexParams: s := proto.Size(x.ComplexParams) n += proto.SizeVarint(3<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _Mutation_OneofSizer(msg proto.Message) (n int) { m := msg.(*Mutation) // operation switch x := m.Operation.(type) { case *Mutation_Insert: s := proto.Size(x.Insert) n += proto.SizeVarint(4<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Mutation_Update: s := proto.Size(x.Update) n += proto.SizeVarint(5<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Mutation_Upsert: s := proto.Size(x.Upsert) n += proto.SizeVarint(6<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Mutation_Delete: s := proto.Size(x.Delete) n += proto.SizeVarint(7<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _Field_OneofSizer(msg proto.Message) (n int) { m := msg.(*Field) // value switch x := m.Value.(type) { case *Field_Number: n += proto.SizeVarint(2<<3 | proto.WireFixed64) n += 8 case *Field_Str: n += proto.SizeVarint(3<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.Str))) n += len(x.Str) case *Field_Boolean: n += proto.SizeVarint(4<<3 | proto.WireVarint) n += 1 case *Field_Object: s := proto.Size(x.Object) n += proto.SizeVarint(5<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Field_Array: s := proto.Size(x.Array) n += proto.SizeVarint(6<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Field_Link: s := proto.Size(x.Link) n += proto.SizeVarint(7<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _Event_OneofSizer(msg proto.Message) (n int) { m := msg.(*Event) // Event switch x := m.Event.(type) { case *Event_Register: s := proto.Size(x.Register) n += proto.SizeVarint(1<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Event_Block: s := proto.Size(x.Block) n += proto.SizeVarint(2<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Event_ChaincodeEvent: s := proto.Size(x.ChaincodeEvent) n += proto.SizeVarint(3<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Event_Rejection: s := proto.Size(x.Rejection) n += proto.SizeVarint(4<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Event_Unregister: s := proto.Size(x.Unregister) n += proto.SizeVarint(5<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _Cred_OneofSizer(msg proto.Message) (n int) { m := msg.(*Cred) // statement switch x := m.Statement.(type) { case *Cred_HumanReadable: s := proto.Size(x.HumanReadable) n += proto.SizeVarint(7<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Cred_CredSeen: s := proto.Size(x.CredSeen) n += proto.SizeVarint(8<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Cred_ApplicationSpecific: s := proto.Size(x.ApplicationSpecific) n += proto.SizeVarint(9<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Cred_IdentityDeclaration: s := proto.Size(x.IdentityDeclaration) n += proto.SizeVarint(10<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _JSON_OneofSizer(msg proto.Message) (n int) { m := msg.(*JSON) // json_value_oneof switch x := m.JsonValueOneof.(type) { case *JSON_JsonString: n += proto.SizeVarint(1<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.JsonString))) n += len(x.JsonString) case *JSON_JsonNumber: n += proto.SizeVarint(2<<3 | proto.WireFixed64) n += 8 case *JSON_JsonBool: n += proto.SizeVarint(3<<3 | proto.WireVarint) n += 1 case *JSON_JsonObject: s := proto.Size(x.JsonObject) n += proto.SizeVarint(4<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *JSON_JsonArray: s := proto.Size(x.JsonArray) n += proto.SizeVarint(5<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _Wrapper_OneofSizer(msg proto.Message) (n int) { m := msg.(*Wrapper) // content switch x := m.Content.(type) { case *Wrapper_Message: s := proto.Size(x.Message) n += proto.SizeVarint(1<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Wrapper_Request: s := proto.Size(x.Request) n += proto.SizeVarint(2<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Wrapper_Response: s := proto.Size(x.Response) n += proto.SizeVarint(3<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _GcRule_OneofSizer(msg proto.Message) (n int) { m := msg.(*GcRule) // rule switch x := m.Rule.(type) { case *GcRule_MaxNumVersions: n += proto.SizeVarint(1<<3 | proto.WireVarint) n += proto.SizeVarint(uint64(x.MaxNumVersions)) case *GcRule_MaxAge: s := proto.Size(x.MaxAge) n += proto.SizeVarint(2<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *GcRule_Intersection_: s := proto.Size(x.Intersection) n += proto.SizeVarint(3<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *GcRule_Union_: s := proto.Size(x.Union) n += proto.SizeVarint(4<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _BatchMessage_OneofSizer(msg proto.Message) (n int) { m := msg.(*BatchMessage) // payload switch x := m.Payload.(type) { case *BatchMessage_Request: s := proto.Size(x.Request) n += proto.SizeVarint(1<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *BatchMessage_RequestBatch: s := proto.Size(x.RequestBatch) n += proto.SizeVarint(2<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *BatchMessage_PbftMessage: n += proto.SizeVarint(3<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.PbftMessage))) n += len(x.PbftMessage) case *BatchMessage_Complaint: s := proto.Size(x.Complaint) n += proto.SizeVarint(4<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _Value_OneofSizer(msg proto.Message) (n int) { m := msg.(*Value) // kind switch x := m.Kind.(type) { case *Value_NullValue: n += proto.SizeVarint(1<<3 | proto.WireVarint) n += proto.SizeVarint(uint64(x.NullValue)) case *Value_NumberValue: n += proto.SizeVarint(2<<3 | proto.WireFixed64) n += 8 case *Value_StringValue: n += proto.SizeVarint(3<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.StringValue))) n += len(x.StringValue) case *Value_BoolValue: n += proto.SizeVarint(4<<3 | proto.WireVarint) n += 1 case *Value_StructValue: s := proto.Size(x.StructValue) n += proto.SizeVarint(5<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Value_ListValue: s := proto.Size(x.ListValue) n += proto.SizeVarint(6<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _Value_OneofSizer(msg proto.Message) (n int) { m := msg.(*Value) // value_type switch x := m.ValueType.(type) { case *Value_NullValue: n += proto.SizeVarint(11<<3 | proto.WireVarint) n += proto.SizeVarint(uint64(x.NullValue)) case *Value_BooleanValue: n += proto.SizeVarint(1<<3 | proto.WireVarint) n += 1 case *Value_IntegerValue: n += proto.SizeVarint(2<<3 | proto.WireVarint) n += proto.SizeVarint(uint64(x.IntegerValue)) case *Value_DoubleValue: n += proto.SizeVarint(3<<3 | proto.WireFixed64) n += 8 case *Value_TimestampValue: s := proto.Size(x.TimestampValue) n += proto.SizeVarint(10<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Value_KeyValue: s := proto.Size(x.KeyValue) n += proto.SizeVarint(5<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Value_StringValue: n += proto.SizeVarint(17<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.StringValue))) n += len(x.StringValue) case *Value_BlobValue: n += proto.SizeVarint(18<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.BlobValue))) n += len(x.BlobValue) case *Value_GeoPointValue: s := proto.Size(x.GeoPointValue) n += proto.SizeVarint(8<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Value_EntityValue: s := proto.Size(x.EntityValue) n += proto.SizeVarint(6<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Value_ArrayValue: s := proto.Size(x.ArrayValue) n += proto.SizeVarint(9<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _Response_OneofSizer(msg proto.Message) (n int) { m := msg.(*Response) // message switch x := m.Message.(type) { case *Response_Info: s := proto.Size(x.Info) n += proto.SizeVarint(1<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Response_Init: s := proto.Size(x.Init) n += proto.SizeVarint(2<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Response_Keepalive: s := proto.Size(x.Keepalive) n += proto.SizeVarint(3<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Response_Snapshot: s := proto.Size(x.Snapshot) n += proto.SizeVarint(4<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Response_Restore: s := proto.Size(x.Restore) n += proto.SizeVarint(5<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Response_Error: s := proto.Size(x.Error) n += proto.SizeVarint(6<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Response_Begin: s := proto.Size(x.Begin) n += proto.SizeVarint(16<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Response_Point: s := proto.Size(x.Point) n += proto.SizeVarint(17<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Response_End: s := proto.Size(x.End) n += proto.SizeVarint(18<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _Message_OneofSizer(msg proto.Message) (n int) { m := msg.(*Message) // payload switch x := m.Payload.(type) { case *Message_RequestBatch: s := proto.Size(x.RequestBatch) n += proto.SizeVarint(1<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Message_PrePrepare: s := proto.Size(x.PrePrepare) n += proto.SizeVarint(2<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Message_Prepare: s := proto.Size(x.Prepare) n += proto.SizeVarint(3<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Message_Commit: s := proto.Size(x.Commit) n += proto.SizeVarint(4<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Message_Checkpoint: s := proto.Size(x.Checkpoint) n += proto.SizeVarint(5<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Message_ViewChange: s := proto.Size(x.ViewChange) n += proto.SizeVarint(6<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Message_NewView: s := proto.Size(x.NewView) n += proto.SizeVarint(7<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Message_FetchRequestBatch: s := proto.Size(x.FetchRequestBatch) n += proto.SizeVarint(8<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Message_ReturnRequestBatch: s := proto.Size(x.ReturnRequestBatch) n += proto.SizeVarint(9<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _HttpRule_OneofSizer(msg proto.Message) (n int) { m := msg.(*HttpRule) // pattern switch x := m.Pattern.(type) { case *HttpRule_Get: n += proto.SizeVarint(2<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.Get))) n += len(x.Get) case *HttpRule_Put: n += proto.SizeVarint(3<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.Put))) n += len(x.Put) case *HttpRule_Post: n += proto.SizeVarint(4<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.Post))) n += len(x.Post) case *HttpRule_Delete: n += proto.SizeVarint(5<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.Delete))) n += len(x.Delete) case *HttpRule_Patch: n += proto.SizeVarint(6<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.Patch))) n += len(x.Patch) case *HttpRule_Custom: s := proto.Size(x.Custom) n += proto.SizeVarint(8<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _ServerReflectionRequest_OneofSizer(msg proto.Message) (n int) { m := msg.(*ServerReflectionRequest) // message_request switch x := m.MessageRequest.(type) { case *ServerReflectionRequest_FileByFilename: n += proto.SizeVarint(3<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.FileByFilename))) n += len(x.FileByFilename) case *ServerReflectionRequest_FileContainingSymbol: n += proto.SizeVarint(4<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.FileContainingSymbol))) n += len(x.FileContainingSymbol) case *ServerReflectionRequest_FileContainingExtension: s := proto.Size(x.FileContainingExtension) n += proto.SizeVarint(5<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *ServerReflectionRequest_AllExtensionNumbersOfType: n += proto.SizeVarint(6<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.AllExtensionNumbersOfType))) n += len(x.AllExtensionNumbersOfType) case *ServerReflectionRequest_ListServices: n += proto.SizeVarint(7<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.ListServices))) n += len(x.ListServices) case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _RowValue_OneofSizer(msg proto.Message) (n int) { m := msg.(*RowValue) // value switch x := m.Value.(type) { case *RowValue_Str: n += proto.SizeVarint(1<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.Str))) n += len(x.Str) case *RowValue_Int: n += proto.SizeVarint(2<<3 | proto.WireVarint) n += proto.SizeVarint(uint64(x.Int)) case *RowValue_Real: n += proto.SizeVarint(3<<3 | proto.WireFixed32) n += 4 case *RowValue_Date: n += proto.SizeVarint(4<<3 | proto.WireVarint) n += proto.SizeVarint(uint64(x.Date)) case *RowValue_DateOfTime: n += proto.SizeVarint(5<<3 | proto.WireVarint) n += proto.SizeVarint(uint64(x.DateOfTime)) case *RowValue_TimeOfDay: s := proto.Size(x.TimeOfDay) n += proto.SizeVarint(6<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
// parseAndAck parses the UDP payload and sends anwACK to the client receiver. // TODO(jvesuna): Keep parseAndAck routine live with a connection. Have the ackServer channel data // to this routine for faster processing. func parseAndAck(buf []byte, ServerConn *net.UDPConn, clientUDPAddr *net.UDPAddr) { messageAck := &ptpb.PingtestMessage{} if err := proto.Unmarshal(buf, messageAck); err != nil { //TODO(jvesuna): Fix this error handling. log.Println("error: failed to unmarshal packet in parseAndAck:", err) } if *tinyAck { // Don't include padding. // Here, messageAck should always be about the same size. messageAck = &ptpb.PingtestMessage{ PingtestParams: messageAck.PingtestParams, Type: messageAck.Type, } } wireBytesAck, err := proto.Marshal(messageAck) if err != nil { fmt.Println("error marshalling ACK:", err) } // Send ACK. ServerConn.SetWriteBuffer(proto.Size(messageAck)) _, err = ServerConn.WriteToUDP(wireBytesAck, clientUDPAddr) if err != nil { log.Println("Failed to send ACK:", err) } log.Println("Sent Ack") }
func _Communique_OneofSizer(msg proto.Message) (n int) { m := msg.(*Communique) // union switch x := m.Union.(type) { case *Communique_Number: n += proto.SizeVarint(5<<3 | proto.WireVarint) n += proto.SizeVarint(uint64(x.Number)) case *Communique_Name: n += proto.SizeVarint(6<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.Name))) n += len(x.Name) case *Communique_Data: n += proto.SizeVarint(7<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.Data))) n += len(x.Data) case *Communique_TempC: n += proto.SizeVarint(8<<3 | proto.WireFixed64) n += 8 case *Communique_Height: n += proto.SizeVarint(9<<3 | proto.WireFixed32) n += 4 case *Communique_Today: n += proto.SizeVarint(10<<3 | proto.WireVarint) n += proto.SizeVarint(uint64(x.Today)) case *Communique_Maybe: n += proto.SizeVarint(11<<3 | proto.WireVarint) n += 1 case *Communique_Delta_: n += proto.SizeVarint(12<<3 | proto.WireVarint) n += proto.SizeVarint(uint64((uint32(x.Delta) << 1) ^ uint32((int32(x.Delta) >> 31)))) case *Communique_Msg: s := proto.Size(x.Msg) n += proto.SizeVarint(13<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Communique_Somegroup: n += proto.SizeVarint(14<<3 | proto.WireStartGroup) n += proto.Size(x.Somegroup) n += proto.SizeVarint(14<<3 | proto.WireEndGroup) case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
// Log buffers the Entry for output to the logging service. It never blocks. func (l *Logger) Log(e Entry) { ent, err := toLogEntry(e) if err != nil { l.error(err) return } if err := l.bundler.Add(ent, proto.Size(ent)); err != nil { l.error(err) } }
// flushLog attempts to flush any pending logs to the appserver. // It should not be called concurrently. func (c *context) flushLog(force bool) (flushed bool) { c.pendingLogs.Lock() // Grab up to 30 MB. We can get away with up to 32 MB, but let's be cautious. n, rem := 0, 30<<20 for ; n < len(c.pendingLogs.lines); n++ { ll := c.pendingLogs.lines[n] // Each log line will require about 3 bytes of overhead. nb := proto.Size(ll) + 3 if nb > rem { break } rem -= nb } lines := c.pendingLogs.lines[:n] c.pendingLogs.lines = c.pendingLogs.lines[n:] c.pendingLogs.Unlock() if len(lines) == 0 && !force { // Nothing to flush. return false } rescueLogs := false defer func() { if rescueLogs { c.pendingLogs.Lock() c.pendingLogs.lines = append(lines, c.pendingLogs.lines...) c.pendingLogs.Unlock() } }() buf, err := proto.Marshal(&logpb.UserAppLogGroup{ LogLine: lines, }) if err != nil { log.Printf("internal.flushLog: marshaling UserAppLogGroup: %v", err) rescueLogs = true return false } req := &logpb.FlushRequest{ Logs: buf, } res := &basepb.VoidProto{} c.pendingLogs.Lock() c.pendingLogs.flushes++ c.pendingLogs.Unlock() if err := Call(toContext(c), "logservice", "Flush", req, res); err != nil { log.Printf("internal.flushLog: Flush RPC: %v", err) rescueLogs = true return false } return true }
func _RunQueryRequest_OneofSizer(msg proto.Message) (n int) { m := msg.(*RunQueryRequest) // query_type switch x := m.QueryType.(type) { case *RunQueryRequest_Query: s := proto.Size(x.Query) n += proto.SizeVarint(3<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *RunQueryRequest_GqlQuery: s := proto.Size(x.GqlQuery) n += proto.SizeVarint(7<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _Filter_OneofSizer(msg proto.Message) (n int) { m := msg.(*Filter) // filter_type switch x := m.FilterType.(type) { case *Filter_CompositeFilter: s := proto.Size(x.CompositeFilter) n += proto.SizeVarint(1<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Filter_PropertyFilter: s := proto.Size(x.PropertyFilter) n += proto.SizeVarint(2<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _ServerArgs_OneofSizer(msg proto.Message) (n int) { m := msg.(*ServerArgs) // argtype switch x := m.Argtype.(type) { case *ServerArgs_Setup: s := proto.Size(x.Setup) n += proto.SizeVarint(1<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *ServerArgs_Mark: s := proto.Size(x.Mark) n += proto.SizeVarint(2<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }
func _Operation_OneofSizer(msg proto.Message) (n int) { m := msg.(*Operation) // result switch x := m.Result.(type) { case *Operation_Error: s := proto.Size(x.Error) n += proto.SizeVarint(4<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case *Operation_Response: s := proto.Size(x.Response) n += proto.SizeVarint(5<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n }