1
2
3
4 package nopackage
5
6 import (
7 encoding_binary "encoding/binary"
8 fmt "fmt"
9 proto "github.com/gogo/protobuf/proto"
10 io "io"
11 math "math"
12 math_bits "math/bits"
13 )
14
15
16 var _ = proto.Marshal
17 var _ = fmt.Errorf
18 var _ = math.Inf
19
20
21
22
23
24 const _ = proto.GoGoProtoPackageIsVersion3
25
26 type M struct {
27 F map[string]float64 `protobuf:"bytes,1,rep,name=f,proto3" json:"f,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
28 XXX_NoUnkeyedLiteral struct{} `json:"-"`
29 XXX_unrecognized []byte `json:"-"`
30 XXX_sizecache int32 `json:"-"`
31 }
32
33 func (m *M) Reset() { *m = M{} }
34 func (m *M) String() string { return proto.CompactTextString(m) }
35 func (*M) ProtoMessage() {}
36 func (*M) Descriptor() ([]byte, []int) {
37 return fileDescriptor_b1b32965c0afa91f, []int{0}
38 }
39 func (m *M) XXX_Unmarshal(b []byte) error {
40 return m.Unmarshal(b)
41 }
42 func (m *M) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
43 if deterministic {
44 return xxx_messageInfo_M.Marshal(b, m, deterministic)
45 } else {
46 b = b[:cap(b)]
47 n, err := m.MarshalToSizedBuffer(b)
48 if err != nil {
49 return nil, err
50 }
51 return b[:n], nil
52 }
53 }
54 func (m *M) XXX_Merge(src proto.Message) {
55 xxx_messageInfo_M.Merge(m, src)
56 }
57 func (m *M) XXX_Size() int {
58 return m.Size()
59 }
60 func (m *M) XXX_DiscardUnknown() {
61 xxx_messageInfo_M.DiscardUnknown(m)
62 }
63
64 var xxx_messageInfo_M proto.InternalMessageInfo
65
66 func (m *M) GetF() map[string]float64 {
67 if m != nil {
68 return m.F
69 }
70 return nil
71 }
72
73 func init() {
74 proto.RegisterType((*M)(nil), "M")
75 proto.RegisterMapType((map[string]float64)(nil), "M.FEntry")
76 }
77
78 func init() { proto.RegisterFile("nopackage.proto", fileDescriptor_b1b32965c0afa91f) }
79
80 var fileDescriptor_b1b32965c0afa91f = []byte{
81
82 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0xcf, 0xcb, 0x2f, 0x48,
83 0x4c, 0xce, 0x4e, 0x4c, 0x4f, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x57, 0x0a, 0xe2, 0x62, 0xf4,
84 0x15, 0x12, 0xe7, 0x62, 0x4c, 0x93, 0x60, 0x54, 0x60, 0xd6, 0xe0, 0x36, 0xe2, 0xd4, 0xf3, 0xd5,
85 0x73, 0x73, 0xcd, 0x2b, 0x29, 0xaa, 0x0c, 0x62, 0x4c, 0x93, 0x32, 0xe1, 0x62, 0x83, 0x70, 0x84,
86 0x04, 0xb8, 0x98, 0xb3, 0x53, 0x2b, 0x25, 0x18, 0x15, 0x18, 0x35, 0x38, 0x83, 0x40, 0x4c, 0x21,
87 0x11, 0x2e, 0xd6, 0xb2, 0xc4, 0x9c, 0xd2, 0x54, 0x09, 0x26, 0x05, 0x46, 0x0d, 0xc6, 0x20, 0x08,
88 0xc7, 0x8a, 0xc9, 0x82, 0xd1, 0x89, 0xe7, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f,
89 0x3c, 0x92, 0x63, 0x4c, 0x62, 0x03, 0x5b, 0x64, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x62, 0x62,
90 0xb2, 0xed, 0x7b, 0x00, 0x00, 0x00,
91 }
92
93 func (m *M) Marshal() (dAtA []byte, err error) {
94 size := m.Size()
95 dAtA = make([]byte, size)
96 n, err := m.MarshalToSizedBuffer(dAtA[:size])
97 if err != nil {
98 return nil, err
99 }
100 return dAtA[:n], nil
101 }
102
103 func (m *M) MarshalTo(dAtA []byte) (int, error) {
104 size := m.Size()
105 return m.MarshalToSizedBuffer(dAtA[:size])
106 }
107
108 func (m *M) MarshalToSizedBuffer(dAtA []byte) (int, error) {
109 i := len(dAtA)
110 _ = i
111 var l int
112 _ = l
113 if m.XXX_unrecognized != nil {
114 i -= len(m.XXX_unrecognized)
115 copy(dAtA[i:], m.XXX_unrecognized)
116 }
117 if len(m.F) > 0 {
118 for k := range m.F {
119 v := m.F[k]
120 baseI := i
121 i -= 8
122 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(v))))
123 i--
124 dAtA[i] = 0x11
125 i -= len(k)
126 copy(dAtA[i:], k)
127 i = encodeVarintNopackage(dAtA, i, uint64(len(k)))
128 i--
129 dAtA[i] = 0xa
130 i = encodeVarintNopackage(dAtA, i, uint64(baseI-i))
131 i--
132 dAtA[i] = 0xa
133 }
134 }
135 return len(dAtA) - i, nil
136 }
137
138 func encodeVarintNopackage(dAtA []byte, offset int, v uint64) int {
139 offset -= sovNopackage(v)
140 base := offset
141 for v >= 1<<7 {
142 dAtA[offset] = uint8(v&0x7f | 0x80)
143 v >>= 7
144 offset++
145 }
146 dAtA[offset] = uint8(v)
147 return base
148 }
149 func (m *M) Size() (n int) {
150 if m == nil {
151 return 0
152 }
153 var l int
154 _ = l
155 if len(m.F) > 0 {
156 for k, v := range m.F {
157 _ = k
158 _ = v
159 mapEntrySize := 1 + len(k) + sovNopackage(uint64(len(k))) + 1 + 8
160 n += mapEntrySize + 1 + sovNopackage(uint64(mapEntrySize))
161 }
162 }
163 if m.XXX_unrecognized != nil {
164 n += len(m.XXX_unrecognized)
165 }
166 return n
167 }
168
169 func sovNopackage(x uint64) (n int) {
170 return (math_bits.Len64(x|1) + 6) / 7
171 }
172 func sozNopackage(x uint64) (n int) {
173 return sovNopackage(uint64((x << 1) ^ uint64((int64(x) >> 63))))
174 }
175 func (m *M) Unmarshal(dAtA []byte) error {
176 l := len(dAtA)
177 iNdEx := 0
178 for iNdEx < l {
179 preIndex := iNdEx
180 var wire uint64
181 for shift := uint(0); ; shift += 7 {
182 if shift >= 64 {
183 return ErrIntOverflowNopackage
184 }
185 if iNdEx >= l {
186 return io.ErrUnexpectedEOF
187 }
188 b := dAtA[iNdEx]
189 iNdEx++
190 wire |= uint64(b&0x7F) << shift
191 if b < 0x80 {
192 break
193 }
194 }
195 fieldNum := int32(wire >> 3)
196 wireType := int(wire & 0x7)
197 if wireType == 4 {
198 return fmt.Errorf("proto: M: wiretype end group for non-group")
199 }
200 if fieldNum <= 0 {
201 return fmt.Errorf("proto: M: illegal tag %d (wire type %d)", fieldNum, wire)
202 }
203 switch fieldNum {
204 case 1:
205 if wireType != 2 {
206 return fmt.Errorf("proto: wrong wireType = %d for field F", wireType)
207 }
208 var msglen int
209 for shift := uint(0); ; shift += 7 {
210 if shift >= 64 {
211 return ErrIntOverflowNopackage
212 }
213 if iNdEx >= l {
214 return io.ErrUnexpectedEOF
215 }
216 b := dAtA[iNdEx]
217 iNdEx++
218 msglen |= int(b&0x7F) << shift
219 if b < 0x80 {
220 break
221 }
222 }
223 if msglen < 0 {
224 return ErrInvalidLengthNopackage
225 }
226 postIndex := iNdEx + msglen
227 if postIndex < 0 {
228 return ErrInvalidLengthNopackage
229 }
230 if postIndex > l {
231 return io.ErrUnexpectedEOF
232 }
233 if m.F == nil {
234 m.F = make(map[string]float64)
235 }
236 var mapkey string
237 var mapvalue float64
238 for iNdEx < postIndex {
239 entryPreIndex := iNdEx
240 var wire uint64
241 for shift := uint(0); ; shift += 7 {
242 if shift >= 64 {
243 return ErrIntOverflowNopackage
244 }
245 if iNdEx >= l {
246 return io.ErrUnexpectedEOF
247 }
248 b := dAtA[iNdEx]
249 iNdEx++
250 wire |= uint64(b&0x7F) << shift
251 if b < 0x80 {
252 break
253 }
254 }
255 fieldNum := int32(wire >> 3)
256 if fieldNum == 1 {
257 var stringLenmapkey uint64
258 for shift := uint(0); ; shift += 7 {
259 if shift >= 64 {
260 return ErrIntOverflowNopackage
261 }
262 if iNdEx >= l {
263 return io.ErrUnexpectedEOF
264 }
265 b := dAtA[iNdEx]
266 iNdEx++
267 stringLenmapkey |= uint64(b&0x7F) << shift
268 if b < 0x80 {
269 break
270 }
271 }
272 intStringLenmapkey := int(stringLenmapkey)
273 if intStringLenmapkey < 0 {
274 return ErrInvalidLengthNopackage
275 }
276 postStringIndexmapkey := iNdEx + intStringLenmapkey
277 if postStringIndexmapkey < 0 {
278 return ErrInvalidLengthNopackage
279 }
280 if postStringIndexmapkey > l {
281 return io.ErrUnexpectedEOF
282 }
283 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
284 iNdEx = postStringIndexmapkey
285 } else if fieldNum == 2 {
286 var mapvaluetemp uint64
287 if (iNdEx + 8) > l {
288 return io.ErrUnexpectedEOF
289 }
290 mapvaluetemp = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
291 iNdEx += 8
292 mapvalue = math.Float64frombits(mapvaluetemp)
293 } else {
294 iNdEx = entryPreIndex
295 skippy, err := skipNopackage(dAtA[iNdEx:])
296 if err != nil {
297 return err
298 }
299 if (skippy < 0) || (iNdEx+skippy) < 0 {
300 return ErrInvalidLengthNopackage
301 }
302 if (iNdEx + skippy) > postIndex {
303 return io.ErrUnexpectedEOF
304 }
305 iNdEx += skippy
306 }
307 }
308 m.F[mapkey] = mapvalue
309 iNdEx = postIndex
310 default:
311 iNdEx = preIndex
312 skippy, err := skipNopackage(dAtA[iNdEx:])
313 if err != nil {
314 return err
315 }
316 if (skippy < 0) || (iNdEx+skippy) < 0 {
317 return ErrInvalidLengthNopackage
318 }
319 if (iNdEx + skippy) > l {
320 return io.ErrUnexpectedEOF
321 }
322 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
323 iNdEx += skippy
324 }
325 }
326
327 if iNdEx > l {
328 return io.ErrUnexpectedEOF
329 }
330 return nil
331 }
332 func skipNopackage(dAtA []byte) (n int, err error) {
333 l := len(dAtA)
334 iNdEx := 0
335 depth := 0
336 for iNdEx < l {
337 var wire uint64
338 for shift := uint(0); ; shift += 7 {
339 if shift >= 64 {
340 return 0, ErrIntOverflowNopackage
341 }
342 if iNdEx >= l {
343 return 0, io.ErrUnexpectedEOF
344 }
345 b := dAtA[iNdEx]
346 iNdEx++
347 wire |= (uint64(b) & 0x7F) << shift
348 if b < 0x80 {
349 break
350 }
351 }
352 wireType := int(wire & 0x7)
353 switch wireType {
354 case 0:
355 for shift := uint(0); ; shift += 7 {
356 if shift >= 64 {
357 return 0, ErrIntOverflowNopackage
358 }
359 if iNdEx >= l {
360 return 0, io.ErrUnexpectedEOF
361 }
362 iNdEx++
363 if dAtA[iNdEx-1] < 0x80 {
364 break
365 }
366 }
367 case 1:
368 iNdEx += 8
369 case 2:
370 var length int
371 for shift := uint(0); ; shift += 7 {
372 if shift >= 64 {
373 return 0, ErrIntOverflowNopackage
374 }
375 if iNdEx >= l {
376 return 0, io.ErrUnexpectedEOF
377 }
378 b := dAtA[iNdEx]
379 iNdEx++
380 length |= (int(b) & 0x7F) << shift
381 if b < 0x80 {
382 break
383 }
384 }
385 if length < 0 {
386 return 0, ErrInvalidLengthNopackage
387 }
388 iNdEx += length
389 case 3:
390 depth++
391 case 4:
392 if depth == 0 {
393 return 0, ErrUnexpectedEndOfGroupNopackage
394 }
395 depth--
396 case 5:
397 iNdEx += 4
398 default:
399 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
400 }
401 if iNdEx < 0 {
402 return 0, ErrInvalidLengthNopackage
403 }
404 if depth == 0 {
405 return iNdEx, nil
406 }
407 }
408 return 0, io.ErrUnexpectedEOF
409 }
410
411 var (
412 ErrInvalidLengthNopackage = fmt.Errorf("proto: negative length found during unmarshaling")
413 ErrIntOverflowNopackage = fmt.Errorf("proto: integer overflow")
414 ErrUnexpectedEndOfGroupNopackage = fmt.Errorf("proto: unexpected end of group")
415 )
416
View as plain text