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 }