func _LoadParams_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*LoadParams)
// load
switch x := m.Load.(type) {
case *LoadParams_ClosedLoop:
b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ClosedLoop); err != nil {
return err
}
case *LoadParams_Poisson:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Poisson); err != nil {
return err
}
case *LoadParams_Uniform:
b.EncodeVarint(3<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Uniform); err != nil {
return err
}
case *LoadParams_Determ:
b.EncodeVarint(4<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Determ); err != nil {
return err
}
case *LoadParams_Pareto:
b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Pareto); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("LoadParams.Load has unexpected type %T", x)
}
return nil
}
func _Command_OneofMarshaler(msg proto1.Message, b *proto1.Buffer) error {
m := msg.(*Command)
// command
switch x := m.Command.(type) {
case *Command_Say:
b.EncodeVarint(2<<3 | proto1.WireBytes)
if err := b.EncodeMessage(x.Say); err != nil {
return err
}
case *Command_Nick:
b.EncodeVarint(3<<3 | proto1.WireBytes)
if err := b.EncodeMessage(x.Nick); err != nil {
return err
}
case *Command_Join:
b.EncodeVarint(4<<3 | proto1.WireBytes)
if err := b.EncodeMessage(x.Join); err != nil {
return err
}
case *Command_Leave:
b.EncodeVarint(5<<3 | proto1.WireBytes)
if err := b.EncodeMessage(x.Leave); err != nil {
return err
}
case *Command_Exit:
b.EncodeVarint(6<<3 | proto1.WireBytes)
if err := b.EncodeMessage(x.Exit); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Command.Command has unexpected type %T", x)
}
return nil
}
func _Event_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Event)
// Event
switch x := m.Event.(type) {
case *Event_Register:
b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Register); err != nil {
return err
}
case *Event_Block:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Block); err != nil {
return err
}
case *Event_ChaincodeEvent:
b.EncodeVarint(3<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ChaincodeEvent); err != nil {
return err
}
case *Event_Rejection:
b.EncodeVarint(4<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Rejection); err != nil {
return err
}
case *Event_Unregister:
b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Unregister); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Event.Event has unexpected type %T", x)
}
return nil
}
func _StreamMessage_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*StreamMessage)
// message_oneof
switch x := m.MessageOneof.(type) {
case *StreamMessage_Rpc:
b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Rpc); err != nil {
return err
}
case *StreamMessage_Message:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Message); err != nil {
return err
}
case *StreamMessage_ByteMessage:
b.EncodeVarint(3<<3 | proto.WireBytes)
b.EncodeRawBytes(x.ByteMessage)
case *StreamMessage_Error:
b.EncodeVarint(4<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Error); err != nil {
return err
}
case *StreamMessage_ByteError:
b.EncodeVarint(5<<3 | proto.WireBytes)
b.EncodeRawBytes(x.ByteError)
case nil:
default:
return fmt.Errorf("StreamMessage.MessageOneof has unexpected type %T", x)
}
return nil
}
func _ReadRowsResponse_Chunk_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*ReadRowsResponse_Chunk)
// chunk
switch x := m.Chunk.(type) {
case *ReadRowsResponse_Chunk_RowContents:
b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.RowContents); err != nil {
return err
}
case *ReadRowsResponse_Chunk_ResetRow:
t := uint64(0)
if x.ResetRow {
t = 1
}
b.EncodeVarint(2<<3 | proto.WireVarint)
b.EncodeVarint(t)
case *ReadRowsResponse_Chunk_CommitRow:
t := uint64(0)
if x.CommitRow {
t = 1
}
b.EncodeVarint(3<<3 | proto.WireVarint)
b.EncodeVarint(t)
case nil:
default:
return fmt.Errorf("ReadRowsResponse_Chunk.Chunk has unexpected type %T", x)
}
return nil
}
func _SieveMessage_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*SieveMessage)
// payload
switch x := m.Payload.(type) {
case *SieveMessage_Request:
b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Request); err != nil {
return err
}
case *SieveMessage_Execute:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Execute); err != nil {
return err
}
case *SieveMessage_Verify:
b.EncodeVarint(3<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Verify); err != nil {
return err
}
case *SieveMessage_PbftMessage:
b.EncodeVarint(4<<3 | proto.WireBytes)
b.EncodeRawBytes(x.PbftMessage)
case *SieveMessage_Complaint:
b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Complaint); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("SieveMessage.Payload has unexpected type %T", x)
}
return nil
}
func _ServerReflectionRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*ServerReflectionRequest)
// message_request
switch x := m.MessageRequest.(type) {
case *ServerReflectionRequest_FileByFilename:
b.EncodeVarint(3<<3 | proto.WireBytes)
b.EncodeStringBytes(x.FileByFilename)
case *ServerReflectionRequest_FileContainingSymbol:
b.EncodeVarint(4<<3 | proto.WireBytes)
b.EncodeStringBytes(x.FileContainingSymbol)
case *ServerReflectionRequest_FileContainingExtension:
b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.FileContainingExtension); err != nil {
return err
}
case *ServerReflectionRequest_AllExtensionNumbersOfType:
b.EncodeVarint(6<<3 | proto.WireBytes)
b.EncodeStringBytes(x.AllExtensionNumbersOfType)
case *ServerReflectionRequest_ListServices:
b.EncodeVarint(7<<3 | proto.WireBytes)
b.EncodeStringBytes(x.ListServices)
case nil:
default:
return fmt.Errorf("ServerReflectionRequest.MessageRequest has unexpected type %T", x)
}
return nil
}
func _GcRule_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*GcRule)
// rule
switch x := m.Rule.(type) {
case *GcRule_MaxNumVersions:
b.EncodeVarint(1<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.MaxNumVersions))
case *GcRule_MaxAge:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.MaxAge); err != nil {
return err
}
case *GcRule_Intersection_:
b.EncodeVarint(3<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Intersection); err != nil {
return err
}
case *GcRule_Union_:
b.EncodeVarint(4<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Union); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("GcRule.Rule has unexpected type %T", x)
}
return nil
}
func addHeaderBytes(blockHeader *common.BlockHeader, buf *proto.Buffer) error {
if err := buf.EncodeVarint(blockHeader.Number); err != nil {
return err
}
if err := buf.EncodeRawBytes(blockHeader.DataHash); err != nil {
return err
}
if err := buf.EncodeRawBytes(blockHeader.PreviousHash); err != nil {
return err
}
return 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 _ModifyColumnFamiliesRequest_Modification_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*ModifyColumnFamiliesRequest_Modification)
// mod
switch x := m.Mod.(type) {
case *ModifyColumnFamiliesRequest_Modification_Create:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Create); err != nil {
return err
}
case *ModifyColumnFamiliesRequest_Modification_Update:
b.EncodeVarint(3<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Update); err != nil {
return err
}
case *ModifyColumnFamiliesRequest_Modification_Drop:
t := uint64(0)
if x.Drop {
t = 1
}
b.EncodeVarint(4<<3 | proto.WireVarint)
b.EncodeVarint(t)
case nil:
default:
return fmt.Errorf("ModifyColumnFamiliesRequest_Modification.Mod has unexpected type %T", x)
}
return nil
}
func _Event_OneofMarshaler(msg proto1.Message, b *proto1.Buffer) error {
m := msg.(*Event)
// event
switch x := m.Event.(type) {
case *Event_None:
b.EncodeVarint(1<<3 | proto1.WireBytes)
if err := b.EncodeMessage(x.None); err != nil {
return err
}
case *Event_Join:
b.EncodeVarint(2<<3 | proto1.WireBytes)
if err := b.EncodeMessage(x.Join); err != nil {
return err
}
case *Event_Leave:
b.EncodeVarint(3<<3 | proto1.WireBytes)
if err := b.EncodeMessage(x.Leave); err != nil {
return err
}
case *Event_Log:
b.EncodeVarint(4<<3 | proto1.WireBytes)
if err := b.EncodeMessage(x.Log); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Event.Event 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 _ServerReflectionResponse_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*ServerReflectionResponse)
// message_response
switch x := m.MessageResponse.(type) {
case *ServerReflectionResponse_FileDescriptorResponse:
b.EncodeVarint(4<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.FileDescriptorResponse); err != nil {
return err
}
case *ServerReflectionResponse_AllExtensionNumbersResponse:
b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.AllExtensionNumbersResponse); err != nil {
return err
}
case *ServerReflectionResponse_ListServicesResponse:
b.EncodeVarint(6<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ListServicesResponse); err != nil {
return err
}
case *ServerReflectionResponse_ErrorResponse:
b.EncodeVarint(7<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ErrorResponse); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("ServerReflectionResponse.MessageResponse has unexpected type %T", x)
}
return nil
}
func _Cred_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Cred)
// statement
switch x := m.Statement.(type) {
case *Cred_HumanReadable:
b.EncodeVarint(7<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.HumanReadable); err != nil {
return err
}
case *Cred_CredSeen:
b.EncodeVarint(8<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.CredSeen); err != nil {
return err
}
case *Cred_ApplicationSpecific:
b.EncodeVarint(9<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ApplicationSpecific); err != nil {
return err
}
case *Cred_IdentityDeclaration:
b.EncodeVarint(10<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.IdentityDeclaration); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Cred.Statement has unexpected type %T", x)
}
return nil
}
func _RPCReply_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*RPCReply)
// result_oneof
switch x := m.ResultOneof.(type) {
case *RPCReply_Result:
b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Result); err != nil {
return err
}
case *RPCReply_ByteResult:
b.EncodeVarint(2<<3 | proto.WireBytes)
b.EncodeRawBytes(x.ByteResult)
case *RPCReply_Error:
b.EncodeVarint(3<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Error); err != nil {
return err
}
case *RPCReply_ByteError:
b.EncodeVarint(4<<3 | proto.WireBytes)
b.EncodeRawBytes(x.ByteError)
case nil:
default:
return fmt.Errorf("RPCReply.ResultOneof has unexpected type %T", x)
}
return nil
}
func (chaincodeStateDelta *ChaincodeStateDelta) marshal(buffer *proto.Buffer) {
err := buffer.EncodeVarint(uint64(len(chaincodeStateDelta.UpdatedKVs)))
if err != nil {
panic(fmt.Errorf("This error should not occur: %s", err))
}
for key, valueHolder := range chaincodeStateDelta.UpdatedKVs {
err = buffer.EncodeStringBytes(key)
if err != nil {
panic(fmt.Errorf("This error should not occur: %s", err))
}
chaincodeStateDelta.marshalValueWithMarker(buffer, valueHolder.Value)
chaincodeStateDelta.marshalValueWithMarker(buffer, valueHolder.PreviousValue)
}
return
}
func _PipelineSource_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*PipelineSource)
// typed_pipeline_source
switch x := m.TypedPipelineSource.(type) {
case *PipelineSource_GithubPipelineSource:
b.EncodeVarint(4<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.GithubPipelineSource); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("PipelineSource.TypedPipelineSource 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 _ArchiveServerConfig_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*ArchiveServerConfig)
// credentials
switch x := m.Credentials.(type) {
case *ArchiveServerConfig_SslCredentials_:
b.EncodeVarint(3<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.SslCredentials); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("ArchiveServerConfig.Credentials has unexpected type %T", x)
}
return nil
}
func _Policy_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Policy)
// Type
switch x := m.Type.(type) {
case *Policy_SignaturePolicy:
b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.SignaturePolicy); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Policy.Type has unexpected type %T", x)
}
return nil
}
func _ZoneServerMsg_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*ZoneServerMsg)
// Msg
switch x := m.Msg.(type) {
case *ZoneServerMsg_ForWardZoneStartupMsg:
b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ForWardZoneStartupMsg); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("ZoneServerMsg.Msg has unexpected type %T", x)
}
return nil
}
func _Message_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Message)
// protocol
switch x := m.Protocol.(type) {
case *Message_Lorawan:
_ = b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Lorawan); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Message.Protocol has unexpected type %T", x)
}
return nil
}
func _Interest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Interest)
// RegInfo
switch x := m.RegInfo.(type) {
case *Interest_ChaincodeRegInfo:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ChaincodeRegInfo); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Interest.RegInfo has unexpected type %T", x)
}
return nil
}
func _IPOrDomain_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*IPOrDomain)
// address
switch x := m.Address.(type) {
case *IPOrDomain_Ip:
b.EncodeVarint(1<<3 | proto.WireBytes)
b.EncodeRawBytes(x.Ip)
case *IPOrDomain_Domain:
b.EncodeVarint(2<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Domain)
case nil:
default:
return fmt.Errorf("IPOrDomain.Address has unexpected type %T", x)
}
return nil
}
func _FileServer_Entry_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*FileServer_Entry)
// FileOrDir
switch x := m.FileOrDir.(type) {
case *FileServer_Entry_File:
b.EncodeVarint(1<<3 | proto.WireBytes)
b.EncodeStringBytes(x.File)
case *FileServer_Entry_Directory:
b.EncodeVarint(2<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Directory)
case nil:
default:
return fmt.Errorf("FileServer_Entry.FileOrDir has unexpected type %T", x)
}
return nil
}
func _BatchMessage_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*BatchMessage)
// payload
switch x := m.Payload.(type) {
case *BatchMessage_Request:
b.EncodeVarint(1<<3 | proto.WireBytes)
b.EncodeRawBytes(x.Request)
case *BatchMessage_PbftMessage:
b.EncodeVarint(4<<3 | proto.WireBytes)
b.EncodeRawBytes(x.PbftMessage)
case nil:
default:
return fmt.Errorf("BatchMessage.Payload has unexpected type %T", x)
}
return nil
}
func addMetadataBytes(blockMetadata *common.BlockMetadata, buf *proto.Buffer) error {
numItems := uint64(0)
if blockMetadata != nil {
numItems = uint64(len(blockMetadata.Metadata))
}
if err := buf.EncodeVarint(numItems); err != nil {
return err
}
if numItems == 0 {
return nil
}
for _, b := range blockMetadata.Metadata {
if err := buf.EncodeRawBytes(b); err != nil {
return err
}
}
return nil
}
func _JobInfo_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*JobInfo)
// spec
switch x := m.Spec.(type) {
case *JobInfo_Transform:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Transform); err != nil {
return err
}
case *JobInfo_PipelineName:
b.EncodeVarint(3<<3 | proto.WireBytes)
b.EncodeStringBytes(x.PipelineName)
case nil:
default:
return fmt.Errorf("JobInfo.Spec 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
}