func _OptionValue_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*OptionValue)
// value
switch x := m.Value.(type) {
case *OptionValue_BoolValue:
t := uint64(0)
if x.BoolValue {
t = 1
}
b.EncodeVarint(2<<3 | proto.WireVarint)
b.EncodeVarint(t)
case *OptionValue_IntValue:
b.EncodeVarint(3<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.IntValue))
case *OptionValue_DoubleValue:
b.EncodeVarint(4<<3 | proto.WireFixed64)
b.EncodeFixed64(math.Float64bits(x.DoubleValue))
case *OptionValue_StringValue:
b.EncodeVarint(5<<3 | proto.WireBytes)
b.EncodeStringBytes(x.StringValue)
case *OptionValue_DurationValue:
b.EncodeVarint(6<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.DurationValue))
case nil:
default:
return fmt.Errorf("OptionValue.Value has unexpected type %T", x)
}
return nil
}
func _HttpRule_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*HttpRule)
// pattern
switch x := m.Pattern.(type) {
case *HttpRule_Get:
b.EncodeVarint(2<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Get)
case *HttpRule_Put:
b.EncodeVarint(3<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Put)
case *HttpRule_Post:
b.EncodeVarint(4<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Post)
case *HttpRule_Delete:
b.EncodeVarint(5<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Delete)
case *HttpRule_Patch:
b.EncodeVarint(6<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Patch)
case *HttpRule_Custom:
b.EncodeVarint(8<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Custom); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("HttpRule.Pattern has unexpected type %T", x)
}
return nil
}
func _JSON_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*JSON)
// json_value_oneof
switch x := m.JsonValueOneof.(type) {
case *JSON_JsonString:
b.EncodeVarint(1<<3 | proto.WireBytes)
b.EncodeStringBytes(x.JsonString)
case *JSON_JsonNumber:
b.EncodeVarint(2<<3 | proto.WireFixed64)
b.EncodeFixed64(math.Float64bits(x.JsonNumber))
case *JSON_JsonBool:
t := uint64(0)
if x.JsonBool {
t = 1
}
b.EncodeVarint(3<<3 | proto.WireVarint)
b.EncodeVarint(t)
case *JSON_JsonObject:
b.EncodeVarint(4<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.JsonObject); err != nil {
return err
}
case *JSON_JsonArray:
b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.JsonArray); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("JSON.JsonValueOneof has unexpected type %T", x)
}
return nil
}
func _RowValue_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*RowValue)
// value
switch x := m.Value.(type) {
case *RowValue_Str:
_ = b.EncodeVarint(1<<3 | proto.WireBytes)
_ = b.EncodeStringBytes(x.Str)
case *RowValue_Int:
_ = b.EncodeVarint(2<<3 | proto.WireVarint)
_ = b.EncodeVarint(uint64(x.Int))
case *RowValue_Real:
_ = b.EncodeVarint(3<<3 | proto.WireFixed32)
_ = b.EncodeFixed32(uint64(math.Float32bits(x.Real)))
case *RowValue_Date:
_ = b.EncodeVarint(4<<3 | proto.WireVarint)
_ = b.EncodeVarint(uint64(x.Date))
case *RowValue_DateOfTime:
_ = b.EncodeVarint(5<<3 | proto.WireVarint)
_ = b.EncodeVarint(uint64(x.DateOfTime))
case *RowValue_TimeOfDay:
_ = b.EncodeVarint(6<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.TimeOfDay); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("RowValue.Value has unexpected type %T", x)
}
return nil
}
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 _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 _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
}
// 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 _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 _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 (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 _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 _Flag_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Flag)
// flag
switch x := m.Flag.(type) {
case *Flag_Reserved_:
b.EncodeVarint(1<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.Reserved))
case *Flag_Custom:
b.EncodeVarint(2<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Custom)
case nil:
default:
return fmt.Errorf("Flag.Flag has unexpected type %T", x)
}
return nil
}
func _Key_PathElement_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Key_PathElement)
// id_type
switch x := m.IdType.(type) {
case *Key_PathElement_Id:
b.EncodeVarint(2<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.Id))
case *Key_PathElement_Name:
b.EncodeVarint(3<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Name)
case nil:
default:
return fmt.Errorf("Key_PathElement.IdType 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 _MsgWithOneof_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*MsgWithOneof)
// union
switch x := m.Union.(type) {
case *MsgWithOneof_Title:
b.EncodeVarint(1<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Title)
case *MsgWithOneof_Salary:
b.EncodeVarint(2<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.Salary))
case nil:
default:
return fmt.Errorf("MsgWithOneof.Union has unexpected type %T", x)
}
return nil
}
func _Test_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Test)
// union
switch x := m.Union.(type) {
case *Test_Number:
b.EncodeVarint(6<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.Number))
case *Test_Name:
b.EncodeVarint(7<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Name)
case nil:
default:
return fmt.Errorf("Test.Union has unexpected type %T", x)
}
return nil
}
func _ABitOfEverything_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*ABitOfEverything)
// oneof_value
switch x := m.OneofValue.(type) {
case *ABitOfEverything_OneofEmpty:
b.EncodeVarint(20<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.OneofEmpty); err != nil {
return err
}
case *ABitOfEverything_OneofString:
b.EncodeVarint(21<<3 | proto.WireBytes)
b.EncodeStringBytes(x.OneofString)
case nil:
default:
return fmt.Errorf("ABitOfEverything.OneofValue has unexpected type %T", x)
}
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
}
// 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
}
// Marshal serializes a `NsReadWriteSet`
func (nsRW *NsReadWriteSet) Marshal(buf *proto.Buffer) error {
var err error
if err = buf.EncodeStringBytes(nsRW.NameSpace); err != nil {
return err
}
if err = buf.EncodeVarint(uint64(len(nsRW.Reads))); err != nil {
return err
}
for i := 0; i < len(nsRW.Reads); i++ {
nsRW.Reads[i].Marshal(buf)
}
if err = buf.EncodeVarint(uint64(len(nsRW.Writes))); err != nil {
return err
}
for i := 0; i < len(nsRW.Writes); i++ {
nsRW.Writes[i].Marshal(buf)
}
return nil
}
func _GaugeResponse_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*GaugeResponse)
// value
switch x := m.Value.(type) {
case *GaugeResponse_LongValue:
b.EncodeVarint(2<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.LongValue))
case *GaugeResponse_DoubleValue:
b.EncodeVarint(3<<3 | proto.WireFixed64)
b.EncodeFixed64(math.Float64bits(x.DoubleValue))
case *GaugeResponse_StringValue:
b.EncodeVarint(4<<3 | proto.WireBytes)
b.EncodeStringBytes(x.StringValue)
case nil:
default:
return fmt.Errorf("GaugeResponse.Value has unexpected type %T", x)
}
return nil
}
func _Field_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Field)
// value
switch x := m.Value.(type) {
case *Field_Number:
b.EncodeVarint(2<<3 | proto.WireFixed64)
b.EncodeFixed64(math.Float64bits(x.Number))
case *Field_Str:
b.EncodeVarint(3<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Str)
case *Field_Boolean:
t := uint64(0)
if x.Boolean {
t = 1
}
b.EncodeVarint(4<<3 | proto.WireVarint)
b.EncodeVarint(t)
case *Field_Object:
b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Object); err != nil {
return err
}
case *Field_Array:
b.EncodeVarint(6<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Array); err != nil {
return err
}
case *Field_Link:
b.EncodeVarint(7<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Link); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Field.Value has unexpected type %T", x)
}
return nil
}
func _LogEntry_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*LogEntry)
// payload
switch x := m.Payload.(type) {
case *LogEntry_ProtoPayload:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ProtoPayload); err != nil {
return err
}
case *LogEntry_TextPayload:
b.EncodeVarint(3<<3 | proto.WireBytes)
b.EncodeStringBytes(x.TextPayload)
case *LogEntry_JsonPayload:
b.EncodeVarint(6<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.JsonPayload); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("LogEntry.Payload has unexpected type %T", x)
}
return nil
}
func _TestQuery_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*TestQuery)
// query
switch x := m.Query.(type) {
case *TestQuery_Id:
b.EncodeVarint(1<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Id)
case *TestQuery_Wildcard_:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Wildcard); err != nil {
return err
}
case *TestQuery_Regex_:
b.EncodeVarint(3<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Regex); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("TestQuery.Query has unexpected type %T", x)
}
return nil
}
func _Argument_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Argument)
// value
switch x := m.Value.(type) {
case *Argument_Number:
b.EncodeVarint(1<<3 | proto.WireFixed64)
b.EncodeFixed64(math.Float64bits(x.Number))
case *Argument_Str:
b.EncodeVarint(2<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Str)
case *Argument_Boolean:
t := uint64(0)
if x.Boolean {
t = 1
}
b.EncodeVarint(3<<3 | proto.WireVarint)
b.EncodeVarint(t)
case nil:
default:
return fmt.Errorf("Argument.Value has unexpected type %T", x)
}
return nil
}
func _Value_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Value)
// kind
switch x := m.Kind.(type) {
case *Value_NullValue:
b.EncodeVarint(1<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.NullValue))
case *Value_NumberValue:
b.EncodeVarint(2<<3 | proto.WireFixed64)
b.EncodeFixed64(math.Float64bits(x.NumberValue))
case *Value_StringValue:
b.EncodeVarint(3<<3 | proto.WireBytes)
b.EncodeStringBytes(x.StringValue)
case *Value_BoolValue:
t := uint64(0)
if x.BoolValue {
t = 1
}
b.EncodeVarint(4<<3 | proto.WireVarint)
b.EncodeVarint(t)
case *Value_StructValue:
b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.StructValue); err != nil {
return err
}
case *Value_ListValue:
b.EncodeVarint(6<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ListValue); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Value.Kind has unexpected type %T", x)
}
return nil
}
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
}
