go和delphi基于proto数据标准
用代码工厂生成units.proto
用代码工厂生成DELPHI rest CRUD
用protoc将units.proto生成GO代码units.pb.go
protoc –gofast_out=. units.proto
csharp;gutter:true;
// Code generated by protoc-gen-gogo. DO NOT EDIT.</p>
<p>// source: units.proto</p>
<p>package units</p>
<p>import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
io "io"
math "math"
math_bits "math/bits"
)</p>
<p>// Reference imports to suppress errors if they are not otherwise used.</p>
<p>var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf</p>
<p>// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.</p>
<p>// A compilation error at this line likely means your copy of the
// proto package needs to be updated.</p>
<p>const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package</p>
<p>type Tunit struct {
Unitid string <code>protobuf:"bytes,1,opt,name=unitid,proto3" json:"unitid,omitempty"</code>
Unitname string <code>protobuf:"bytes,2,opt,name=unitname,proto3" json:"unitname,omitempty"</code>
XXX_NoUnkeyedLiteral struct{} <code>json:"-"</code>
XXX_unrecognized []byte <code>json:"-"</code>
XXX_sizecache int32 <code>json:"-"</code>
}</p>
<p>func (m <em>Tunit) Reset() { </em>m = Tunit{} }
func (m <em>Tunit) String() string { return proto.CompactTextString(m) }
func (</em>Tunit) ProtoMessage() {}
func (<em>Tunit) Descriptor() ([]byte, []int) {
return fileDescriptor_27f59c1ddbd63328, []int{0}
}
func (m </em>Tunit) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m <em>Tunit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Tunit.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m </em>Tunit) XXX_Merge(src proto.Message) {
xxx_messageInfo_Tunit.Merge(m, src)
}
func (m <em>Tunit) XXX_Size() int {
return m.Size()
}
func (m </em>Tunit) XXX_DiscardUnknown() {
xxx_messageInfo_Tunit.DiscardUnknown(m)
}</p>
<p>var xxx_messageInfo_Tunit proto.InternalMessageInfo</p>
<p>func (m *Tunit) GetUnitid() string {
if m != nil {
return m.Unitid
}
return ""
}</p>
<p>func (m *Tunit) GetUnitname() string {
if m != nil {
return m.Unitname
}
return ""
}</p>
<p>type TunitArray struct {
Status int32 <code>protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"</code>
Exception string <code>protobuf:"bytes,2,opt,name=exception,proto3" json:"exception,omitempty"</code>
Message string <code>protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"</code>
Tunits []*Tunit <code>protobuf:"bytes,4,rep,name=tunits,proto3" json:"tunits,omitempty"</code>
XXX_NoUnkeyedLiteral struct{} <code>json:"-"</code>
XXX_unrecognized []byte <code>json:"-"</code>
XXX_sizecache int32 <code>json:"-"</code>
}</p>
<p>func (m <em>TunitArray) Reset() { </em>m = TunitArray{} }
func (m <em>TunitArray) String() string { return proto.CompactTextString(m) }
func (</em>TunitArray) ProtoMessage() {}
func (<em>TunitArray) Descriptor() ([]byte, []int) {
return fileDescriptor_27f59c1ddbd63328, []int{1}
}
func (m </em>TunitArray) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m <em>TunitArray) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_TunitArray.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m </em>TunitArray) XXX_Merge(src proto.Message) {
xxx_messageInfo_TunitArray.Merge(m, src)
}
func (m <em>TunitArray) XXX_Size() int {
return m.Size()
}
func (m </em>TunitArray) XXX_DiscardUnknown() {
xxx_messageInfo_TunitArray.DiscardUnknown(m)
}</p>
<p>var xxx_messageInfo_TunitArray proto.InternalMessageInfo</p>
<p>func (m *TunitArray) GetStatus() int32 {
if m != nil {
return m.Status
}
return 0
}</p>
<p>func (m *TunitArray) GetException() string {
if m != nil {
return m.Exception
}
return ""
}</p>
<p>func (m *TunitArray) GetMessage() string {
if m != nil {
return m.Message
}
return ""
}</p>
<p>func (m <em>TunitArray) GetTunits() []</em>Tunit {
if m != nil {
return m.Tunits
}
return nil
}</p>
<p>type Res struct {
Status int32 <code>protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"</code>
Exception string <code>protobuf:"bytes,2,opt,name=exception,proto3" json:"exception,omitempty"</code>
Message string <code>protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"</code>
XXX_NoUnkeyedLiteral struct{} <code>json:"-"</code>
XXX_unrecognized []byte <code>json:"-"</code>
XXX_sizecache int32 <code>json:"-"</code>
}</p>
<p>func (m <em>Res) Reset() { </em>m = Res{} }
func (m <em>Res) String() string { return proto.CompactTextString(m) }
func (</em>Res) ProtoMessage() {}
func (<em>Res) Descriptor() ([]byte, []int) {
return fileDescriptor_27f59c1ddbd63328, []int{2}
}
func (m </em>Res) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m <em>Res) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Res.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m </em>Res) XXX_Merge(src proto.Message) {
xxx_messageInfo_Res.Merge(m, src)
}
func (m <em>Res) XXX_Size() int {
return m.Size()
}
func (m </em>Res) XXX_DiscardUnknown() {
xxx_messageInfo_Res.DiscardUnknown(m)
}</p>
<p>var xxx_messageInfo_Res proto.InternalMessageInfo</p>
<p>func (m *Res) GetStatus() int32 {
if m != nil {
return m.Status
}
return 0
}</p>
<p>func (m *Res) GetException() string {
if m != nil {
return m.Exception
}
return ""
}</p>
<p>func (m *Res) GetMessage() string {
if m != nil {
return m.Message
}
return ""
}</p>
<p>func init() {
proto.RegisterType((<em>Tunit)(nil), "tunit")
proto.RegisterType((</em>TunitArray)(nil), "tunitArray")
proto.RegisterType((*Res)(nil), "Res")
}</p>
<p>func init() { proto.RegisterFile("units.proto", fileDescriptor_27f59c1ddbd63328) }</p>
<p>var fileDescriptor_27f59c1ddbd63328 = []byte{
// 189 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x2e, 0xcd, 0xcb, 0x2c,
0x29, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x57, 0xb2, 0xe6, 0x62, 0x2d, 0x01, 0xf1, 0x85, 0xc4,
0xb8, 0xd8, 0x40, 0x74, 0x66, 0x8a, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x67, 0x10, 0x94, 0x27, 0x24,
0xc5, 0xc5, 0x01, 0x62, 0xe5, 0x25, 0xe6, 0xa6, 0x4a, 0x30, 0x81, 0x65, 0xe0, 0x7c, 0xa5, 0x1a,
0x2e, 0x2e, 0xb0, 0x66, 0xc7, 0xa2, 0xa2, 0xc4, 0x4a, 0x90, 0x09, 0xc5, 0x25, 0x89, 0x25, 0xa5,
0xc5, 0x60, 0x13, 0x58, 0x83, 0xa0, 0x3c, 0x21, 0x19, 0x2e, 0xce, 0xd4, 0x8a, 0xe4, 0xd4, 0x82,
0x92, 0xcc, 0xfc, 0x3c, 0xa8, 0x11, 0x08, 0x01, 0x21, 0x09, 0x2e, 0xf6, 0xdc, 0xd4, 0xe2, 0xe2,
0xc4, 0xf4, 0x54, 0x09, 0x66, 0xb0, 0x1c, 0x8c, 0x2b, 0x24, 0xc7, 0xc5, 0x06, 0x36, 0xbd, 0x58,
0x82, 0x45, 0x81, 0x59, 0x83, 0xdb, 0x88, 0x4d, 0x0f, 0xcc, 0x0d, 0x82, 0x8a, 0x2a, 0x85, 0x72,
0x31, 0x07, 0xa5, 0x16, 0x53, 0xdb, 0x5a, 0x27, 0x81, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92,
0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc6, 0x63, 0x39, 0x86, 0x24, 0x36, 0x70, 0x50, 0x19, 0x03,
0x02, 0x00, 0x00, 0xff, 0xff, 0xc5, 0x43, 0x1f, 0xff, 0x39, 0x01, 0x00, 0x00,
}</p>
<p>func (m *Tunit) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}</p>
<p>func (m *Tunit) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}</p>
<p>func (m *Tunit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Unitname) > 0 {
i -= len(m.Unitname)
copy(dAtA[i:], m.Unitname)
i = encodeVarintUnits(dAtA, i, uint64(len(m.Unitname)))
i--
dAtA[i] = 0x12
}
if len(m.Unitid) > 0 {
i -= len(m.Unitid)
copy(dAtA[i:], m.Unitid)
i = encodeVarintUnits(dAtA, i, uint64(len(m.Unitid)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}</p>
<p>func (m *TunitArray) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}</p>
<p>func (m *TunitArray) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}</p>
<p>func (m *TunitArray) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Tunits) > 0 {
for iNdEx := len(m.Tunits) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Tunits[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintUnits(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
}
}
if len(m.Message) > 0 {
i -= len(m.Message)
copy(dAtA[i:], m.Message)
i = encodeVarintUnits(dAtA, i, uint64(len(m.Message)))
i--
dAtA[i] = 0x1a
}
if len(m.Exception) > 0 {
i -= len(m.Exception)
copy(dAtA[i:], m.Exception)
i = encodeVarintUnits(dAtA, i, uint64(len(m.Exception)))
i--
dAtA[i] = 0x12
}
if m.Status != 0 {
i = encodeVarintUnits(dAtA, i, uint64(m.Status))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}</p>
<p>func (m *Res) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}</p>
<p>func (m *Res) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}</p>
<p>func (m *Res) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Message) > 0 {
i -= len(m.Message)
copy(dAtA[i:], m.Message)
i = encodeVarintUnits(dAtA, i, uint64(len(m.Message)))
i--
dAtA[i] = 0x1a
}
if len(m.Exception) > 0 {
i -= len(m.Exception)
copy(dAtA[i:], m.Exception)
i = encodeVarintUnits(dAtA, i, uint64(len(m.Exception)))
i--
dAtA[i] = 0x12
}
if m.Status != 0 {
i = encodeVarintUnits(dAtA, i, uint64(m.Status))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}</p>
<p>func encodeVarintUnits(dAtA []byte, offset int, v uint64) int {
offset -= sovUnits(v)
base := offset
for v >= 1<>= 7
offset++
}
dAtA[offset] = uint8(v)
return base
}
func (m *Tunit) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Unitid)
if l > 0 {
n += 1 + l + sovUnits(uint64(l))
}
l = len(m.Unitname)
if l > 0 {
n += 1 + l + sovUnits(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}</p>
<p>func (m *TunitArray) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Status != 0 {
n += 1 + sovUnits(uint64(m.Status))
}
l = len(m.Exception)
if l > 0 {
n += 1 + l + sovUnits(uint64(l))
}
l = len(m.Message)
if l > 0 {
n += 1 + l + sovUnits(uint64(l))
}
if len(m.Tunits) > 0 {
for _, e := range m.Tunits {
l = e.Size()
n += 1 + l + sovUnits(uint64(l))
}
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}</p>
<p>func (m *Res) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Status != 0 {
n += 1 + sovUnits(uint64(m.Status))
}
l = len(m.Exception)
if l > 0 {
n += 1 + l + sovUnits(uint64(l))
}
l = len(m.Message)
if l > 0 {
n += 1 + l + sovUnits(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}</p>
<p>func sovUnits(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
func sozUnits(x uint64) (n int) {
return sovUnits(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Tunit) 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 ErrIntOverflowUnits
}
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: tunit: wiretype end group for non-group")
}
if fieldNum = 64 {
return ErrIntOverflowUnits
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthUnits
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthUnits
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Unitid = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Unitname", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowUnits
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthUnits
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthUnits
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Unitname = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipUnits(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthUnits
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}</p>
<pre><code>if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
</code></pre>
<p>}
func (m *TunitArray) 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 ErrIntOverflowUnits
}
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: tunitArray: wiretype end group for non-group")
}
if fieldNum = 64 {
return ErrIntOverflowUnits
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Status |= int32(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Exception", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowUnits
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthUnits
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthUnits
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Exception = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowUnits
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthUnits
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthUnits
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Message = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Tunits", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowUnits
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthUnits
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthUnits
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Tunits = append(m.Tunits, &Tunit{})
if err := m.Tunits[len(m.Tunits)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipUnits(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthUnits
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}</p>
<pre><code>if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
</code></pre>
<p>}
func (m *Res) 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 ErrIntOverflowUnits
}
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: Res: wiretype end group for non-group")
}
if fieldNum = 64 {
return ErrIntOverflowUnits
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Status |= int32(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Exception", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowUnits
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthUnits
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthUnits
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Exception = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowUnits
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthUnits
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthUnits
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Message = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipUnits(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthUnits
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}</p>
<pre><code>if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
</code></pre>
<p>}
func skipUnits(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 {
if shift >= 64 {
return 0, ErrIntOverflowUnits
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
wireType := int(wire & 0x7)
switch wireType {
case 0:
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowUnits
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
iNdEx++
if dAtA[iNdEx-1] < 0x80 {
break
}
}
case 1:
iNdEx += 8
case 2:
var length int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowUnits
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
length |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if length < 0 {
return 0, ErrInvalidLengthUnits
}
iNdEx += length
case 3:
depth++
case 4:
if depth == 0 {
return 0, ErrUnexpectedEndOfGroupUnits
}
depth--
case 5:
iNdEx += 4
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
if iNdEx < 0 {
return 0, ErrInvalidLengthUnits
}
if depth == 0 {
return iNdEx, nil
}
}
return 0, io.ErrUnexpectedEOF
}</p>
<p>var (
ErrInvalidLengthUnits = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowUnits = fmt.Errorf("proto: integer overflow")
ErrUnexpectedEndOfGroupUnits = fmt.Errorf("proto: unexpected end of group")
)</p>
<pre><code>
go数据序列
;gutter:true;
// test2 project main.go
package main
import (
"encoding/json"
"fmt"
"github.com/golang/protobuf/proto"
)
func main() {
var dw Tunit
dw.Unitid = "1"
dw.Unitname = "个"
var dw2 Tunit
dw2.Unitid = "2"
dw2.Unitname = "双"
var dws TunitArray
dws.Tunits = append(dws.Tunits, &dw)
dws.Tunits = append(dws.Tunits, &dw2)
//json序列
b, _ := json.Marshal(dws)
fmt.Println(string(b)) //{"UnitsArr":[{"Unitid":"1","Unitname":"个"},{"Unitid":"2","Unitname":"双"}]}
//protobuf序列
b2, _ := proto.Marshal(&dws)
fmt.Println(string(b2))
}
Original: https://www.cnblogs.com/hnxxcxg/p/16501514.html
Author: delphi中间件
Title: go和delphi基于proto数据标准
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/546006/
转载文章受原作者版权保护。转载请注明原作者出处！