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
}