1// Code generated by protoc-gen-gogo. DO NOT EDIT.
2// source: typedeclimport.proto
3
4/*
5Package typedeclimport is a generated protocol buffer package.
6
7It is generated from these files:
8	typedeclimport.proto
9
10It has these top-level messages:
11	SomeMessage
12*/
13package typedeclimport
14
15import proto "github.com/gogo/protobuf/proto"
16import fmt "fmt"
17import math "math"
18import _ "github.com/gogo/protobuf/gogoproto"
19import subpkg "github.com/gogo/protobuf/test/typedeclimport/subpkg"
20
21import io "io"
22
23// Reference imports to suppress errors if they are not otherwise used.
24var _ = proto.Marshal
25var _ = fmt.Errorf
26var _ = math.Inf
27
28// This is a compile-time assertion to ensure that this generated file
29// is compatible with the proto package it is being compiled against.
30// A compilation error at this line likely means your copy of the
31// proto package needs to be updated.
32const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
33
34func (m *SomeMessage) Reset()                    { *m = SomeMessage{} }
35func (m *SomeMessage) String() string            { return proto.CompactTextString(m) }
36func (*SomeMessage) ProtoMessage()               {}
37func (*SomeMessage) Descriptor() ([]byte, []int) { return fileDescriptorTypedeclimport, []int{0} }
38
39func (m *SomeMessage) GetImported() subpkg.AnotherMessage {
40	if m != nil {
41		return m.Imported
42	}
43	return subpkg.AnotherMessage{}
44}
45
46func init() {
47	proto.RegisterType((*SomeMessage)(nil), "typedeclimport.SomeMessage")
48}
49func (this *SomeMessage) VerboseEqual(that interface{}) error {
50	if that == nil {
51		if this == nil {
52			return nil
53		}
54		return fmt.Errorf("that == nil && this != nil")
55	}
56
57	that1, ok := that.(*SomeMessage)
58	if !ok {
59		that2, ok := that.(SomeMessage)
60		if ok {
61			that1 = &that2
62		} else {
63			return fmt.Errorf("that is not of type *SomeMessage")
64		}
65	}
66	if that1 == nil {
67		if this == nil {
68			return nil
69		}
70		return fmt.Errorf("that is type *SomeMessage but is nil && this != nil")
71	} else if this == nil {
72		return fmt.Errorf("that is type *SomeMessage but is not nil && this == nil")
73	}
74	if !this.Imported.Equal(&that1.Imported) {
75		return fmt.Errorf("Imported this(%v) Not Equal that(%v)", this.Imported, that1.Imported)
76	}
77	return nil
78}
79func (this *SomeMessage) Equal(that interface{}) bool {
80	if that == nil {
81		if this == nil {
82			return true
83		}
84		return false
85	}
86
87	that1, ok := that.(*SomeMessage)
88	if !ok {
89		that2, ok := that.(SomeMessage)
90		if ok {
91			that1 = &that2
92		} else {
93			return false
94		}
95	}
96	if that1 == nil {
97		if this == nil {
98			return true
99		}
100		return false
101	} else if this == nil {
102		return false
103	}
104	if !this.Imported.Equal(&that1.Imported) {
105		return false
106	}
107	return true
108}
109func (m *SomeMessage) Marshal() (dAtA []byte, err error) {
110	size := m.Size()
111	dAtA = make([]byte, size)
112	n, err := m.MarshalTo(dAtA)
113	if err != nil {
114		return nil, err
115	}
116	return dAtA[:n], nil
117}
118
119func (m *SomeMessage) MarshalTo(dAtA []byte) (int, error) {
120	var i int
121	_ = i
122	var l int
123	_ = l
124	dAtA[i] = 0xa
125	i++
126	i = encodeVarintTypedeclimport(dAtA, i, uint64(m.Imported.Size()))
127	n1, err := m.Imported.MarshalTo(dAtA[i:])
128	if err != nil {
129		return 0, err
130	}
131	i += n1
132	return i, nil
133}
134
135func encodeFixed64Typedeclimport(dAtA []byte, offset int, v uint64) int {
136	dAtA[offset] = uint8(v)
137	dAtA[offset+1] = uint8(v >> 8)
138	dAtA[offset+2] = uint8(v >> 16)
139	dAtA[offset+3] = uint8(v >> 24)
140	dAtA[offset+4] = uint8(v >> 32)
141	dAtA[offset+5] = uint8(v >> 40)
142	dAtA[offset+6] = uint8(v >> 48)
143	dAtA[offset+7] = uint8(v >> 56)
144	return offset + 8
145}
146func encodeFixed32Typedeclimport(dAtA []byte, offset int, v uint32) int {
147	dAtA[offset] = uint8(v)
148	dAtA[offset+1] = uint8(v >> 8)
149	dAtA[offset+2] = uint8(v >> 16)
150	dAtA[offset+3] = uint8(v >> 24)
151	return offset + 4
152}
153func encodeVarintTypedeclimport(dAtA []byte, offset int, v uint64) int {
154	for v >= 1<<7 {
155		dAtA[offset] = uint8(v&0x7f | 0x80)
156		v >>= 7
157		offset++
158	}
159	dAtA[offset] = uint8(v)
160	return offset + 1
161}
162func (m *SomeMessage) Size() (n int) {
163	var l int
164	_ = l
165	l = m.Imported.Size()
166	n += 1 + l + sovTypedeclimport(uint64(l))
167	return n
168}
169
170func sovTypedeclimport(x uint64) (n int) {
171	for {
172		n++
173		x >>= 7
174		if x == 0 {
175			break
176		}
177	}
178	return n
179}
180func sozTypedeclimport(x uint64) (n int) {
181	return sovTypedeclimport(uint64((x << 1) ^ uint64((int64(x) >> 63))))
182}
183func (m *SomeMessage) Unmarshal(dAtA []byte) error {
184	l := len(dAtA)
185	iNdEx := 0
186	for iNdEx < l {
187		preIndex := iNdEx
188		var wire uint64
189		for shift := uint(0); ; shift += 7 {
190			if shift >= 64 {
191				return ErrIntOverflowTypedeclimport
192			}
193			if iNdEx >= l {
194				return io.ErrUnexpectedEOF
195			}
196			b := dAtA[iNdEx]
197			iNdEx++
198			wire |= (uint64(b) & 0x7F) << shift
199			if b < 0x80 {
200				break
201			}
202		}
203		fieldNum := int32(wire >> 3)
204		wireType := int(wire & 0x7)
205		if wireType == 4 {
206			return fmt.Errorf("proto: SomeMessage: wiretype end group for non-group")
207		}
208		if fieldNum <= 0 {
209			return fmt.Errorf("proto: SomeMessage: illegal tag %d (wire type %d)", fieldNum, wire)
210		}
211		switch fieldNum {
212		case 1:
213			if wireType != 2 {
214				return fmt.Errorf("proto: wrong wireType = %d for field Imported", wireType)
215			}
216			var msglen int
217			for shift := uint(0); ; shift += 7 {
218				if shift >= 64 {
219					return ErrIntOverflowTypedeclimport
220				}
221				if iNdEx >= l {
222					return io.ErrUnexpectedEOF
223				}
224				b := dAtA[iNdEx]
225				iNdEx++
226				msglen |= (int(b) & 0x7F) << shift
227				if b < 0x80 {
228					break
229				}
230			}
231			if msglen < 0 {
232				return ErrInvalidLengthTypedeclimport
233			}
234			postIndex := iNdEx + msglen
235			if postIndex > l {
236				return io.ErrUnexpectedEOF
237			}
238			if err := m.Imported.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
239				return err
240			}
241			iNdEx = postIndex
242		default:
243			iNdEx = preIndex
244			skippy, err := skipTypedeclimport(dAtA[iNdEx:])
245			if err != nil {
246				return err
247			}
248			if skippy < 0 {
249				return ErrInvalidLengthTypedeclimport
250			}
251			if (iNdEx + skippy) > l {
252				return io.ErrUnexpectedEOF
253			}
254			iNdEx += skippy
255		}
256	}
257
258	if iNdEx > l {
259		return io.ErrUnexpectedEOF
260	}
261	return nil
262}
263func skipTypedeclimport(dAtA []byte) (n int, err error) {
264	l := len(dAtA)
265	iNdEx := 0
266	for iNdEx < l {
267		var wire uint64
268		for shift := uint(0); ; shift += 7 {
269			if shift >= 64 {
270				return 0, ErrIntOverflowTypedeclimport
271			}
272			if iNdEx >= l {
273				return 0, io.ErrUnexpectedEOF
274			}
275			b := dAtA[iNdEx]
276			iNdEx++
277			wire |= (uint64(b) & 0x7F) << shift
278			if b < 0x80 {
279				break
280			}
281		}
282		wireType := int(wire & 0x7)
283		switch wireType {
284		case 0:
285			for shift := uint(0); ; shift += 7 {
286				if shift >= 64 {
287					return 0, ErrIntOverflowTypedeclimport
288				}
289				if iNdEx >= l {
290					return 0, io.ErrUnexpectedEOF
291				}
292				iNdEx++
293				if dAtA[iNdEx-1] < 0x80 {
294					break
295				}
296			}
297			return iNdEx, nil
298		case 1:
299			iNdEx += 8
300			return iNdEx, nil
301		case 2:
302			var length int
303			for shift := uint(0); ; shift += 7 {
304				if shift >= 64 {
305					return 0, ErrIntOverflowTypedeclimport
306				}
307				if iNdEx >= l {
308					return 0, io.ErrUnexpectedEOF
309				}
310				b := dAtA[iNdEx]
311				iNdEx++
312				length |= (int(b) & 0x7F) << shift
313				if b < 0x80 {
314					break
315				}
316			}
317			iNdEx += length
318			if length < 0 {
319				return 0, ErrInvalidLengthTypedeclimport
320			}
321			return iNdEx, nil
322		case 3:
323			for {
324				var innerWire uint64
325				var start int = iNdEx
326				for shift := uint(0); ; shift += 7 {
327					if shift >= 64 {
328						return 0, ErrIntOverflowTypedeclimport
329					}
330					if iNdEx >= l {
331						return 0, io.ErrUnexpectedEOF
332					}
333					b := dAtA[iNdEx]
334					iNdEx++
335					innerWire |= (uint64(b) & 0x7F) << shift
336					if b < 0x80 {
337						break
338					}
339				}
340				innerWireType := int(innerWire & 0x7)
341				if innerWireType == 4 {
342					break
343				}
344				next, err := skipTypedeclimport(dAtA[start:])
345				if err != nil {
346					return 0, err
347				}
348				iNdEx = start + next
349			}
350			return iNdEx, nil
351		case 4:
352			return iNdEx, nil
353		case 5:
354			iNdEx += 4
355			return iNdEx, nil
356		default:
357			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
358		}
359	}
360	panic("unreachable")
361}
362
363var (
364	ErrInvalidLengthTypedeclimport = fmt.Errorf("proto: negative length found during unmarshaling")
365	ErrIntOverflowTypedeclimport   = fmt.Errorf("proto: integer overflow")
366)
367
368func init() { proto.RegisterFile("typedeclimport.proto", fileDescriptorTypedeclimport) }
369
370var fileDescriptorTypedeclimport = []byte{
371	// 189 bytes of a gzipped FileDescriptorProto
372	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x29, 0xa9, 0x2c, 0x48,
373	0x4d, 0x49, 0x4d, 0xce, 0xc9, 0xcc, 0x2d, 0xc8, 0x2f, 0x2a, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9,
374	0x17, 0xe2, 0x43, 0x15, 0x95, 0xd2, 0x4d, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf,
375	0xd5, 0x4f, 0xcf, 0x4f, 0xcf, 0xd7, 0x07, 0x2b, 0x4b, 0x2a, 0x4d, 0x03, 0xf3, 0xc0, 0x1c, 0x30,
376	0x0b, 0xa2, 0x5d, 0xca, 0x01, 0xa7, 0xf2, 0x92, 0xd4, 0xe2, 0x12, 0x7d, 0x54, 0xc3, 0xf5, 0x8b,
377	0x4b, 0x93, 0x0a, 0xb2, 0xd3, 0xa1, 0x14, 0xc4, 0x04, 0x25, 0x5f, 0x2e, 0xee, 0xe0, 0xfc, 0xdc,
378	0x54, 0xdf, 0xd4, 0xe2, 0xe2, 0xc4, 0xf4, 0x54, 0x21, 0x0b, 0x2e, 0x0e, 0x88, 0xe2, 0xd4, 0x14,
379	0x09, 0x46, 0x05, 0x46, 0x0d, 0x6e, 0x23, 0x31, 0x3d, 0xa8, 0x7a, 0xc7, 0xbc, 0xfc, 0x92, 0x8c,
380	0xd4, 0x22, 0xa8, 0x4a, 0x27, 0x96, 0x13, 0xf7, 0xe4, 0x19, 0x82, 0xe0, 0xaa, 0xad, 0x58, 0x3e,
381	0x2c, 0x94, 0x67, 0x70, 0x12, 0x79, 0xf0, 0x50, 0x8e, 0x71, 0xc5, 0x23, 0x39, 0xc6, 0x13, 0x8f,
382	0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x31, 0x89, 0x0d, 0x6c, 0x97, 0x31,
383	0x20, 0x00, 0x00, 0xff, 0xff, 0x54, 0x23, 0xca, 0x44, 0x04, 0x01, 0x00, 0x00,
384}
385