re make

liuxiaolong

2020-02-13 05e00f2f739e1bed1744e950a90305c339d1d4c5

 commsg.pb.go

@@ -20,7 +20,7 @@
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type SdkmsgWithTask struct {
   Ipcid   string `protobuf:"bytes,1,opt,name=ipcid,proto3" json:"ipcid,omitempty"`
@@ -42,7 +42,7 @@
      return xxx_messageInfo_SdkmsgWithTask.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -103,7 +103,7 @@
      return xxx_messageInfo_TaskLabel.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -172,7 +172,7 @@
      return xxx_messageInfo_SdkMessage.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -246,7 +246,7 @@
      return xxx_messageInfo_Recvmsg.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -324,7 +324,7 @@
func (m *SdkmsgWithTask) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -332,43 +332,35 @@
}

func (m *SdkmsgWithTask) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SdkmsgWithTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Sdkdata) > 0 {
      i -= len(m.Sdkdata)
      copy(dAtA[i:], m.Sdkdata)
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Sdkdata)))
      i--
      dAtA[i] = 0x22
   if len(m.Ipcid) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Ipcid)))
      i += copy(dAtA[i:], m.Ipcid)
   }
   if len(m.Sdktype) > 0 {
      i -= len(m.Sdktype)
      copy(dAtA[i:], m.Sdktype)
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Sdktype)))
      i--
      dAtA[i] = 0x12
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Sdktype)))
      i += copy(dAtA[i:], m.Sdktype)
   }
   if len(m.Ipcid) > 0 {
      i -= len(m.Ipcid)
      copy(dAtA[i:], m.Ipcid)
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Ipcid)))
      i--
      dAtA[i] = 0xa
   if len(m.Sdkdata) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Sdkdata)))
      i += copy(dAtA[i:], m.Sdkdata)
   }
   return len(dAtA) - i, nil
   return i, nil
}

func (m *TaskLabel) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -376,55 +368,46 @@
}

func (m *TaskLabel) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TaskLabel) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if m.Index != 0 {
      i = encodeVarintCommsg(dAtA, i, uint64(m.Index))
      i--
      dAtA[i] = 0x20
   }
   if len(m.Sdkinfos) > 0 {
      for iNdEx := len(m.Sdkinfos) - 1; iNdEx >= 0; iNdEx-- {
         {
            size, err := m.Sdkinfos[iNdEx].MarshalToSizedBuffer(dAtA[:i])
            if err != nil {
               return 0, err
            }
            i -= size
            i = encodeVarintCommsg(dAtA, i, uint64(size))
         }
         i--
         dAtA[i] = 0x1a
      }
   if len(m.Taskid) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Taskid)))
      i += copy(dAtA[i:], m.Taskid)
   }
   if len(m.Taskname) > 0 {
      i -= len(m.Taskname)
      copy(dAtA[i:], m.Taskname)
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Taskname)))
      i--
      dAtA[i] = 0x12
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Taskname)))
      i += copy(dAtA[i:], m.Taskname)
   }
   if len(m.Taskid) > 0 {
      i -= len(m.Taskid)
      copy(dAtA[i:], m.Taskid)
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Taskid)))
      i--
      dAtA[i] = 0xa
   if len(m.Sdkinfos) > 0 {
      for _, msg := range m.Sdkinfos {
         dAtA[i] = 0x1a
         i++
         i = encodeVarintCommsg(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   return len(dAtA) - i, nil
   if m.Index != 0 {
      dAtA[i] = 0x20
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(m.Index))
   }
   return i, nil
}

func (m *SdkMessage) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -432,67 +415,55 @@
}

func (m *SdkMessage) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SdkMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if m.Push != nil {
      {
         size, err := m.Push.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintCommsg(dAtA, i, uint64(size))
      }
      i--
      dAtA[i] = 0x2a
   }
   if len(m.Data) > 0 {
      i -= len(m.Data)
      copy(dAtA[i:], m.Data)
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Data)))
      i--
      dAtA[i] = 0x22
   }
   if m.Tasklab != nil {
      {
         size, err := m.Tasklab.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintCommsg(dAtA, i, uint64(size))
      }
      i--
      dAtA[i] = 0x1a
   if len(m.Cid) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Cid)))
      i += copy(dAtA[i:], m.Cid)
   }
   if len(m.Caddr) > 0 {
      i -= len(m.Caddr)
      copy(dAtA[i:], m.Caddr)
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Caddr)))
      i--
      dAtA[i] = 0x12
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Caddr)))
      i += copy(dAtA[i:], m.Caddr)
   }
   if len(m.Cid) > 0 {
      i -= len(m.Cid)
      copy(dAtA[i:], m.Cid)
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Cid)))
      i--
      dAtA[i] = 0xa
   if m.Tasklab != nil {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(m.Tasklab.Size()))
      n1, err1 := m.Tasklab.MarshalTo(dAtA[i:])
      if err1 != nil {
         return 0, err1
      }
      i += n1
   }
   return len(dAtA) - i, nil
   if len(m.Data) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Data)))
      i += copy(dAtA[i:], m.Data)
   }
   if m.Push != nil {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(m.Push.Size()))
      n2, err2 := m.Push.MarshalTo(dAtA[i:])
      if err2 != nil {
         return 0, err2
      }
      i += n2
   }
   return i, nil
}

func (m *Recvmsg) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -500,49 +471,39 @@
}

func (m *Recvmsg) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Recvmsg) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Picdata) > 0 {
      i -= len(m.Picdata)
      copy(dAtA[i:], m.Picdata)
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Picdata)))
      i--
      dAtA[i] = 0x1a
   if len(m.Id) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Id)))
      i += copy(dAtA[i:], m.Id)
   }
   if len(m.Addr) > 0 {
      i -= len(m.Addr)
      copy(dAtA[i:], m.Addr)
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Addr)))
      i--
      dAtA[i] = 0x12
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Addr)))
      i += copy(dAtA[i:], m.Addr)
   }
   if len(m.Id) > 0 {
      i -= len(m.Id)
      copy(dAtA[i:], m.Id)
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Id)))
      i--
      dAtA[i] = 0xa
   if len(m.Picdata) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Picdata)))
      i += copy(dAtA[i:], m.Picdata)
   }
   return len(dAtA) - i, nil
   return i, nil
}

func encodeVarintCommsg(dAtA []byte, offset int, v uint64) int {
   offset -= sovCommsg(v)
   base := offset
   for v >= 1<<7 {
      dAtA[offset] = uint8(v&0x7f | 0x80)
      v >>= 7
      offset++
   }
   dAtA[offset] = uint8(v)
   return base
   return offset + 1
}
func (m *SdkmsgWithTask) Size() (n int) {
   if m == nil {
@@ -1345,7 +1306,6 @@
func skipCommsg(dAtA []byte) (n int, err error) {
   l := len(dAtA)
   iNdEx := 0
   depth := 0
   for iNdEx < l {
      var wire uint64
      for shift := uint(0); ; shift += 7 {
@@ -1377,8 +1337,10 @@
               break
            }
         }
         return iNdEx, nil
      case 1:
         iNdEx += 8
         return iNdEx, nil
      case 2:
         var length int
         for shift := uint(0); ; shift += 7 {
@@ -1399,30 +1361,55 @@
            return 0, ErrInvalidLengthCommsg
         }
         iNdEx += length
      case 3:
         depth++
      case 4:
         if depth == 0 {
            return 0, ErrUnexpectedEndOfGroupCommsg
         if iNdEx < 0 {
            return 0, ErrInvalidLengthCommsg
         }
         depth--
         return iNdEx, nil
      case 3:
         for {
            var innerWire uint64
            var start int = iNdEx
            for shift := uint(0); ; shift += 7 {
               if shift >= 64 {
                  return 0, ErrIntOverflowCommsg
               }
               if iNdEx >= l {
                  return 0, io.ErrUnexpectedEOF
               }
               b := dAtA[iNdEx]
               iNdEx++
               innerWire |= (uint64(b) & 0x7F) << shift
               if b < 0x80 {
                  break
               }
            }
            innerWireType := int(innerWire & 0x7)
            if innerWireType == 4 {
               break
            }
            next, err := skipCommsg(dAtA[start:])
            if err != nil {
               return 0, err
            }
            iNdEx = start + next
            if iNdEx < 0 {
               return 0, ErrInvalidLengthCommsg
            }
         }
         return iNdEx, nil
      case 4:
         return iNdEx, nil
      case 5:
         iNdEx += 4
         return iNdEx, nil
      default:
         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
      }
      if iNdEx < 0 {
         return 0, ErrInvalidLengthCommsg
      }
      if depth == 0 {
         return iNdEx, nil
      }
   }
   return 0, io.ErrUnexpectedEOF
   panic("unreachable")
}

var (
   ErrInvalidLengthCommsg        = fmt.Errorf("proto: negative length found during unmarshaling")
   ErrIntOverflowCommsg          = fmt.Errorf("proto: integer overflow")
   ErrUnexpectedEndOfGroupCommsg = fmt.Errorf("proto: unexpected end of group")
   ErrInvalidLengthCommsg = fmt.Errorf("proto: negative length found during unmarshaling")
   ErrIntOverflowCommsg   = fmt.Errorf("proto: integer overflow")
)