zhangmeng
2019-06-25 4068a0c71829929d3b9526dc8df6a71bfb7f20da
Merge branch 'master' of ssh://192.168.1.14:29418/pubsub/protomsg
2个文件已修改
230 ■■■■■ 已修改文件
es.pb.go 226 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
es.proto 4 ●●●● 补丁 | 查看 | 原始文档 | blame | 历史
es.pb.go
@@ -157,32 +157,81 @@
    return ""
}
type Binfos struct {
    Infos                []*Baseinfo `protobuf:"bytes,1,rep,name=infos,proto3" json:"infos,omitempty"`
    XXX_NoUnkeyedLiteral struct{}    `json:"-"`
    XXX_unrecognized     []byte      `json:"-"`
    XXX_sizecache        int32       `json:"-"`
}
func (m *Binfos) Reset()         { *m = Binfos{} }
func (m *Binfos) String() string { return proto.CompactTextString(m) }
func (*Binfos) ProtoMessage()    {}
func (*Binfos) Descriptor() ([]byte, []int) {
    return fileDescriptor_718db5c20d0f3738, []int{1}
}
func (m *Binfos) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *Binfos) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_Binfos.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
}
func (m *Binfos) XXX_Merge(src proto.Message) {
    xxx_messageInfo_Binfos.Merge(m, src)
}
func (m *Binfos) XXX_Size() int {
    return m.Size()
}
func (m *Binfos) XXX_DiscardUnknown() {
    xxx_messageInfo_Binfos.DiscardUnknown(m)
}
var xxx_messageInfo_Binfos proto.InternalMessageInfo
func (m *Binfos) GetInfos() []*Baseinfo {
    if m != nil {
        return m.Infos
    }
    return nil
}
func init() {
    proto.RegisterType((*Baseinfo)(nil), "protomsg.Baseinfo")
    proto.RegisterType((*Binfos)(nil), "protomsg.Binfos")
}
func init() { proto.RegisterFile("es.proto", fileDescriptor_718db5c20d0f3738) }
var fileDescriptor_718db5c20d0f3738 = []byte{
    // 276 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x91, 0xc1, 0x4a, 0xf3, 0x40,
    0x10, 0xc7, 0xbf, 0x4d, 0x3f, 0xd3, 0x64, 0xda, 0x43, 0xd9, 0x83, 0x0c, 0x22, 0x21, 0xf4, 0xd4,
    0x93, 0x17, 0xdf, 0xa0, 0x07, 0xa1, 0x20, 0x45, 0x2a, 0x3e, 0xc0, 0x76, 0x33, 0xd5, 0x40, 0xb2,
    0x1b, 0x76, 0xb7, 0xe2, 0xa3, 0xf8, 0x48, 0x1e, 0x7d, 0x04, 0x89, 0x57, 0x1f, 0x42, 0x32, 0x89,
    0x9a, 0x9e, 0x32, 0xbf, 0xdf, 0x84, 0xf9, 0x0f, 0xb3, 0x90, 0x90, 0xbf, 0x6a, 0x9c, 0x0d, 0x56,
    0x26, 0xfc, 0xa9, 0xfd, 0xe3, 0xf2, 0x2b, 0x82, 0x64, 0xad, 0x3c, 0x95, 0xe6, 0x60, 0x65, 0x0e,
    0xb3, 0x83, 0xd2, 0x74, 0x43, 0x2a, 0x1c, 0x1d, 0xa1, 0xc8, 0xc5, 0x2a, 0xdd, 0x8d, 0x95, 0xbc,
    0x80, 0xa4, 0x21, 0xe7, 0xad, 0xd9, 0x14, 0x18, 0x71, 0xfb, 0x97, 0x25, 0xc2, 0x34, 0xa8, 0x7d,
    0x45, 0x9b, 0x02, 0x27, 0xdc, 0xfa, 0x41, 0x79, 0x09, 0x29, 0x97, 0x5b, 0x55, 0x13, 0xfe, 0xe7,
    0xde, 0x9f, 0x90, 0x4b, 0x98, 0x6b, 0x5b, 0x37, 0xca, 0xd1, 0xbd, 0xb6, 0x8e, 0xf0, 0x2c, 0x17,
    0xab, 0x68, 0x77, 0xe2, 0x64, 0x06, 0xd0, 0xe7, 0xf0, 0x88, 0x98, 0x47, 0x8c, 0x4c, 0x37, 0xa3,
    0xa7, 0xbb, 0x52, 0x3f, 0xb8, 0x0a, 0xa7, 0xfc, 0xc7, 0x89, 0xe3, 0xdd, 0x9f, 0xac, 0xa1, 0xed,
    0xb1, 0xc6, 0x64, 0xd8, 0x7d, 0x60, 0xb9, 0x80, 0x89, 0xa7, 0x17, 0x4c, 0x59, 0x77, 0xa5, 0x3c,
    0x87, 0xb8, 0x2c, 0xb4, 0x72, 0x05, 0x02, 0xcb, 0x81, 0xba, 0xa4, 0xda, 0x9a, 0x32, 0x58, 0x77,
    0x4b, 0xcf, 0x54, 0xe1, 0xac, 0x4f, 0x1a, 0xbb, 0xee, 0x12, 0xda, 0x9a, 0x40, 0x26, 0xe0, 0xbc,
    0xbf, 0xc4, 0x80, 0xeb, 0xc5, 0x5b, 0x9b, 0x89, 0xf7, 0x36, 0x13, 0x1f, 0x6d, 0x26, 0x5e, 0x3f,
    0xb3, 0x7f, 0xfb, 0x98, 0x9f, 0xe2, 0xfa, 0x3b, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x67, 0xdb, 0x72,
    0x9d, 0x01, 0x00, 0x00,
    // 301 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x91, 0xc1, 0x4a, 0xc3, 0x40,
    0x10, 0x40, 0xdd, 0xd6, 0xa6, 0xe9, 0xb4, 0x87, 0xb2, 0x07, 0x19, 0x44, 0x42, 0xe8, 0x29, 0xa7,
    0x1e, 0xea, 0x1f, 0xf4, 0x20, 0x14, 0xa4, 0x48, 0xc5, 0x0f, 0xd8, 0x6e, 0xa6, 0x1a, 0x68, 0x76,
    0xcb, 0xee, 0x56, 0xfc, 0x14, 0x3f, 0xc9, 0xa3, 0x9f, 0x20, 0xf5, 0xea, 0x47, 0x48, 0x26, 0x89,
    0xa6, 0xa7, 0x9d, 0xf7, 0x66, 0x98, 0x59, 0x66, 0x20, 0x26, 0x3f, 0x3f, 0x38, 0x1b, 0xac, 0x8c,
    0xf9, 0x29, 0xfd, 0xf3, 0xec, 0xa7, 0x07, 0xf1, 0x52, 0x79, 0x2a, 0xcc, 0xce, 0xca, 0x14, 0xc6,
    0x3b, 0xa5, 0xe9, 0x8e, 0x54, 0x38, 0x3a, 0x42, 0x91, 0x8a, 0x6c, 0xb4, 0xe9, 0x2a, 0x79, 0x0d,
    0xf1, 0x81, 0x9c, 0xb7, 0x66, 0x95, 0x63, 0x8f, 0xd3, 0x7f, 0x2c, 0x11, 0x86, 0x41, 0x6d, 0xf7,
    0xb4, 0xca, 0xb1, 0xcf, 0xa9, 0x16, 0xe5, 0x0d, 0x8c, 0x38, 0x5c, 0xab, 0x92, 0xf0, 0x92, 0x73,
    0xff, 0x42, 0xce, 0x60, 0xa2, 0x6d, 0x79, 0x50, 0x8e, 0x1e, 0xb5, 0x75, 0x84, 0x83, 0x54, 0x64,
    0xbd, 0xcd, 0x99, 0x93, 0x09, 0x40, 0x3d, 0x87, 0x5b, 0x44, 0xdc, 0xa2, 0x63, 0xaa, 0x1e, 0x35,
    0x3d, 0x14, 0xfa, 0xc9, 0xed, 0x71, 0xc8, 0x15, 0x67, 0x8e, 0xff, 0xfe, 0x62, 0x0d, 0xad, 0x8f,
    0x25, 0xc6, 0xcd, 0xdf, 0x1b, 0x96, 0x53, 0xe8, 0x7b, 0x7a, 0xc3, 0x11, 0xeb, 0x2a, 0x94, 0x57,
    0x10, 0x15, 0xb9, 0x56, 0x2e, 0x47, 0x60, 0xd9, 0x50, 0x35, 0xa9, 0xb4, 0xa6, 0x08, 0xd6, 0xdd,
    0xd3, 0x2b, 0xed, 0x71, 0x5c, 0x4f, 0xea, 0xba, 0x6a, 0x13, 0xda, 0x9a, 0x40, 0x26, 0xe0, 0xa4,
    0xde, 0x44, 0x83, 0xb3, 0x05, 0x44, 0xcb, 0x6a, 0xd5, 0x5e, 0x66, 0x30, 0xe0, 0x00, 0x45, 0xda,
    0xcf, 0xc6, 0x0b, 0x39, 0x6f, 0x4f, 0x32, 0x6f, 0xcf, 0xb1, 0xa9, 0x0b, 0x96, 0xd3, 0x8f, 0x53,
    0x22, 0x3e, 0x4f, 0x89, 0xf8, 0x3a, 0x25, 0xe2, 0xfd, 0x3b, 0xb9, 0xd8, 0x46, 0x5c, 0x7b, 0xfb,
    0x1b, 0x00, 0x00, 0xff, 0xff, 0xf7, 0x50, 0xf0, 0x3c, 0xd1, 0x01, 0x00, 0x00,
}
func (m *Baseinfo) Marshal() (dAtA []byte, err error) {
@@ -278,6 +327,39 @@
    return i, nil
}
func (m *Binfos) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}
func (m *Binfos) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if len(m.Infos) > 0 {
        for _, msg := range m.Infos {
            dAtA[i] = 0xa
            i++
            i = encodeVarintEs(dAtA, i, uint64(msg.Size()))
            n, err := msg.MarshalTo(dAtA[i:])
            if err != nil {
                return 0, err
            }
            i += n
        }
    }
    if m.XXX_unrecognized != nil {
        i += copy(dAtA[i:], m.XXX_unrecognized)
    }
    return i, nil
}
func encodeVarintEs(dAtA []byte, offset int, v uint64) int {
    for v >= 1<<7 {
        dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -339,6 +421,24 @@
    l = len(m.Content)
    if l > 0 {
        n += 1 + l + sovEs(uint64(l))
    }
    if m.XXX_unrecognized != nil {
        n += len(m.XXX_unrecognized)
    }
    return n
}
func (m *Binfos) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if len(m.Infos) > 0 {
        for _, e := range m.Infos {
            l = e.Size()
            n += 1 + l + sovEs(uint64(l))
        }
    }
    if m.XXX_unrecognized != nil {
        n += len(m.XXX_unrecognized)
@@ -776,6 +876,94 @@
    }
    return nil
}
func (m *Binfos) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowEs
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: Binfos: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: Binfos: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Infos", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowEs
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthEs
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthEs
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Infos = append(m.Infos, &Baseinfo{})
            if err := m.Infos[len(m.Infos)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        default:
            iNdEx = preIndex
            skippy, err := skipEs(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthEs
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthEs
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
            iNdEx += skippy
        }
    }
    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func skipEs(dAtA []byte) (n int, err error) {
    l := len(dAtA)
    iNdEx := 0
es.proto
@@ -17,5 +17,9 @@
    string content = 12;
}
message Binfos{
    repeated   Baseinfo infos  = 1;
}