func _Metric_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Metric)
// data
switch x := m.Data.(type) {
case *Metric_StringData:
b.EncodeVarint(9<<3 | proto.WireBytes)
b.EncodeStringBytes(x.StringData)
case *Metric_Float32Data:
b.EncodeVarint(10<<3 | proto.WireFixed32)
b.EncodeFixed32(uint64(math.Float32bits(x.Float32Data)))
case *Metric_Float64Data:
b.EncodeVarint(11<<3 | proto.WireFixed64)
b.EncodeFixed64(math.Float64bits(x.Float64Data))
case *Metric_Int32Data:
b.EncodeVarint(12<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.Int32Data))
case *Metric_Int64Data:
b.EncodeVarint(13<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.Int64Data))
case *Metric_BytesData:
b.EncodeVarint(14<<3 | proto.WireBytes)
b.EncodeRawBytes(x.BytesData)
case *Metric_BoolData:
t := uint64(0)
if x.BoolData {
t = 1
}
b.EncodeVarint(15<<3 | proto.WireVarint)
b.EncodeVarint(t)
case nil:
default:
return fmt.Errorf("Metric.Data 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)
b.EncodeRawBytes(x.Request)
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 nil:
default:
return fmt.Errorf("SieveMessage.Payload 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 _Column_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Column)
// value
switch x := m.Value.(type) {
case *Column_String_:
b.EncodeVarint(1<<3 | proto.WireBytes)
b.EncodeStringBytes(x.String_)
case *Column_Int32:
b.EncodeVarint(2<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.Int32))
case *Column_Int64:
b.EncodeVarint(3<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.Int64))
case *Column_Uint32:
b.EncodeVarint(4<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.Uint32))
case *Column_Uint64:
b.EncodeVarint(5<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.Uint64))
case *Column_Bytes:
b.EncodeVarint(6<<3 | proto.WireBytes)
b.EncodeRawBytes(x.Bytes)
case *Column_Bool:
t := uint64(0)
if x.Bool {
t = 1
}
b.EncodeVarint(7<<3 | proto.WireVarint)
b.EncodeVarint(t)
case nil:
default:
return fmt.Errorf("Column.Value 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 _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)
if err := b.EncodeMessage(x.Request); err != nil {
return err
}
case *BatchMessage_RequestBatch:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.RequestBatch); err != nil {
return err
}
case *BatchMessage_PbftMessage:
b.EncodeVarint(3<<3 | proto.WireBytes)
b.EncodeRawBytes(x.PbftMessage)
case *BatchMessage_Complaint:
b.EncodeVarint(4<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Complaint); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("BatchMessage.Payload 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 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
}
// Marshal serializes a `KVRead`
func (r *KVRead) Marshal(buf *proto.Buffer) error {
if err := buf.EncodeStringBytes(r.Key); err != nil {
return err
}
versionBytes := []byte{}
if r.Version != nil {
versionBytes = r.Version.ToBytes()
}
if err := buf.EncodeRawBytes(versionBytes); 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 _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 _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 _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 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 _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 _ReadRowsRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*ReadRowsRequest)
// target
switch x := m.Target.(type) {
case *ReadRowsRequest_RowKey:
b.EncodeVarint(2<<3 | proto.WireBytes)
b.EncodeRawBytes(x.RowKey)
case *ReadRowsRequest_RowRange:
b.EncodeVarint(3<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.RowRange); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("ReadRowsRequest.Target has unexpected type %T", x)
}
return nil
}
func _RPC_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*RPC)
// args_oneof
switch x := m.ArgsOneof.(type) {
case *RPC_Args:
b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Args); err != nil {
return err
}
case *RPC_ByteArgs:
b.EncodeVarint(2<<3 | proto.WireBytes)
b.EncodeRawBytes(x.ByteArgs)
case nil:
default:
return fmt.Errorf("RPC.ArgsOneof has unexpected type %T", x)
}
return nil
}
func _PrintContent_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*PrintContent)
// print_content_type
switch x := m.PrintContentType.(type) {
case *PrintContent_PrintInfo:
b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.PrintInfo); err != nil {
return err
}
case *PrintContent_Content:
b.EncodeVarint(2<<3 | proto.WireBytes)
b.EncodeRawBytes(x.Content)
case nil:
default:
return fmt.Errorf("PrintContent.PrintContentType has unexpected type %T", x)
}
return nil
}
// Marshal serializes a `KVWrite`
func (w *KVWrite) Marshal(buf *proto.Buffer) error {
var err error
if err = buf.EncodeStringBytes(w.Key); err != nil {
return err
}
deleteMarker := 0
if w.IsDelete {
deleteMarker = 1
}
if err = buf.EncodeVarint(uint64(deleteMarker)); err != nil {
return err
}
if deleteMarker == 0 {
if err = buf.EncodeRawBytes(w.Value); err != nil {
return err
}
}
return nil
}
func _DropRowRangeRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*DropRowRangeRequest)
// target
switch x := m.Target.(type) {
case *DropRowRangeRequest_RowKeyPrefix:
b.EncodeVarint(2<<3 | proto.WireBytes)
b.EncodeRawBytes(x.RowKeyPrefix)
case *DropRowRangeRequest_DeleteAllDataFromTable:
t := uint64(0)
if x.DeleteAllDataFromTable {
t = 1
}
b.EncodeVarint(3<<3 | proto.WireVarint)
b.EncodeVarint(t)
case nil:
default:
return fmt.Errorf("DropRowRangeRequest.Target has unexpected type %T", x)
}
return nil
}
func addDataBytes(blockData *common.BlockData, buf *proto.Buffer) ([]*txindexInfo, error) {
var txOffsets []*txindexInfo
if err := buf.EncodeVarint(uint64(len(blockData.Data))); err != nil {
return nil, err
}
for _, txEnvelopeBytes := range blockData.Data {
offset := len(buf.Bytes())
txid, err := extractTxID(txEnvelopeBytes)
if err != nil {
return nil, err
}
if err := buf.EncodeRawBytes(txEnvelopeBytes); err != nil {
return nil, err
}
idxInfo := &txindexInfo{txid, &locPointer{offset, len(buf.Bytes()) - offset}}
txOffsets = append(txOffsets, idxInfo)
}
return txOffsets, nil
}
func (chaincodeStateDelta *ChaincodeStateDelta) marshalValueWithMarker(buffer *proto.Buffer, value []byte) {
if value == nil {
// Just add a marker that the value is nil
err := buffer.EncodeVarint(uint64(0))
if err != nil {
panic(fmt.Errorf("This error should not occur: %s", err))
}
return
}
err := buffer.EncodeVarint(uint64(1))
if err != nil {
panic(fmt.Errorf("This error should not occur: %s", err))
}
// If the value happen to be an empty byte array, it would appear as a nil during
// deserialization - see method 'unmarshalValueWithMarker'
err = buffer.EncodeRawBytes(value)
if err != nil {
panic(fmt.Errorf("This error should not occur: %s", err))
}
}
func (chaincodeStateDelta *chaincodeStateDelta) marshal(buffer *proto.Buffer) {
err := buffer.EncodeVarint(uint64(len(chaincodeStateDelta.updatedKVs)))
if err != nil {
// in protobuf code the error return is always nil
panic(fmt.Errorf("This error should not occur: %s", err))
}
for key, valueHolder := range chaincodeStateDelta.updatedKVs {
err = buffer.EncodeStringBytes(key)
if err != nil {
return
}
err = buffer.EncodeRawBytes(valueHolder.value)
if err != nil {
// in protobuf code the error return is always nil
panic(fmt.Errorf("This error should not occur: %s", err))
}
err = buffer.EncodeRawBytes(valueHolder.previousValue)
if err != nil {
// in protobuf code the error return is always nil
panic(fmt.Errorf("This error should not occur: %s", err))
}
}
return
}