Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(138)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: lib/src/protobuf/generated_message.dart

Issue 1277863003: cleanup: move fieldType constants and functions to a separate file (Closed) Base URL: git@github.com:dart-lang/dart-protobuf.git@master
Patch Set: _validateMessage should call _baseType, not callers Created 5 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « lib/src/protobuf/field_type.dart ('k') | lib/src/protobuf/unknown_field_set.dart » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file 1 // Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
2 // for details. All rights reserved. Use of this source code is governed by a 2 // for details. All rights reserved. Use of this source code is governed by a
3 // BSD-style license that can be found in the LICENSE file. 3 // BSD-style license that can be found in the LICENSE file.
4 4
5 part of protobuf; 5 part of protobuf;
6 6
7 typedef GeneratedMessage CreateBuilderFunc(); 7 typedef GeneratedMessage CreateBuilderFunc();
8 typedef Object MakeDefaultFunc(); 8 typedef Object MakeDefaultFunc();
9 typedef ProtobufEnum ValueOfFunc(int value); 9 typedef ProtobufEnum ValueOfFunc(int value);
10 10
11 bool _inRange(min, value, max) => (min <= value) && (value <= max); 11 bool _inRange(min, value, max) => (min <= value) && (value <= max);
12 12
13 bool _isSigned32(int value) => _inRange(-2147483648, value, 2147483647); 13 bool _isSigned32(int value) => _inRange(-2147483648, value, 2147483647);
14 bool _isUnsigned32(int value) => _inRange(0, value, 4294967295); 14 bool _isUnsigned32(int value) => _inRange(0, value, 4294967295);
15 bool _isSigned64(Int64 value) => _isUnsigned64(value); 15 bool _isSigned64(Int64 value) => _isUnsigned64(value);
16 bool _isUnsigned64(Int64 value) => value is Int64; 16 bool _isUnsigned64(Int64 value) => value is Int64;
17 bool _isFloat32(double value) => value.isNaN || value.isInfinite || 17 bool _isFloat32(double value) => value.isNaN || value.isInfinite ||
18 _inRange(-3.4028234663852886E38, value, 3.4028234663852886E38); 18 _inRange(-3.4028234663852886E38, value, 3.4028234663852886E38);
19 19
20 abstract class GeneratedMessage { 20 abstract class GeneratedMessage {
21 static const int _REQUIRED_BIT = 0x1;
22 static const int _REPEATED_BIT = 0x2;
23 static const int _PACKED_BIT = 0x4;
24
25 static const int _BOOL_BIT = 0x10;
26 static const int _BYTES_BIT = 0x20;
27 static const int _STRING_BIT = 0x40;
28 static const int _DOUBLE_BIT = 0x80;
29 static const int _FLOAT_BIT = 0x100;
30 static const int _ENUM_BIT = 0x200;
31 static const int _GROUP_BIT = 0x400;
32 static const int _INT32_BIT = 0x800;
33 static const int _INT64_BIT = 0x1000;
34 static const int _SINT32_BIT = 0x2000;
35 static const int _SINT64_BIT = 0x4000;
36 static const int _UINT32_BIT = 0x8000;
37 static const int _UINT64_BIT = 0x10000;
38 static const int _FIXED32_BIT = 0x20000;
39 static const int _FIXED64_BIT = 0x40000;
40 static const int _SFIXED32_BIT = 0x80000;
41 static const int _SFIXED64_BIT = 0x100000;
42 static const int _MESSAGE_BIT = 0x200000;
43
44 static const int _OPTIONAL_BOOL = _BOOL_BIT;
45 static const int _OPTIONAL_BYTES = _BYTES_BIT;
46 static const int _OPTIONAL_STRING = _STRING_BIT;
47 static const int _OPTIONAL_FLOAT = _FLOAT_BIT;
48 static const int _OPTIONAL_DOUBLE = _DOUBLE_BIT;
49 static const int _OPTIONAL_ENUM = _ENUM_BIT;
50 static const int _OPTIONAL_GROUP = _GROUP_BIT;
51 static const int _OPTIONAL_INT32 = _INT32_BIT;
52 static const int _OPTIONAL_INT64 = _INT64_BIT;
53 static const int _OPTIONAL_SINT32 = _SINT32_BIT;
54 static const int _OPTIONAL_SINT64 = _SINT64_BIT;
55 static const int _OPTIONAL_UINT32 = _UINT32_BIT;
56 static const int _OPTIONAL_UINT64 = _UINT64_BIT;
57 static const int _OPTIONAL_FIXED32 = _FIXED32_BIT;
58 static const int _OPTIONAL_FIXED64 = _FIXED64_BIT;
59 static const int _OPTIONAL_SFIXED32 = _SFIXED32_BIT;
60 static const int _OPTIONAL_SFIXED64 = _SFIXED64_BIT;
61 static const int _OPTIONAL_MESSAGE = _MESSAGE_BIT;
62
63 static const int _REQUIRED_BOOL = _REQUIRED_BIT | _BOOL_BIT;
64 static const int _REQUIRED_BYTES = _REQUIRED_BIT | _BYTES_BIT;
65 static const int _REQUIRED_STRING = _REQUIRED_BIT | _STRING_BIT;
66 static const int _REQUIRED_FLOAT = _REQUIRED_BIT | _FLOAT_BIT;
67 static const int _REQUIRED_DOUBLE = _REQUIRED_BIT | _DOUBLE_BIT;
68 static const int _REQUIRED_ENUM = _REQUIRED_BIT | _ENUM_BIT;
69 static const int _REQUIRED_GROUP = _REQUIRED_BIT | _GROUP_BIT;
70 static const int _REQUIRED_INT32 = _REQUIRED_BIT | _INT32_BIT;
71 static const int _REQUIRED_INT64 = _REQUIRED_BIT | _INT64_BIT;
72 static const int _REQUIRED_SINT32 = _REQUIRED_BIT | _SINT32_BIT;
73 static const int _REQUIRED_SINT64 = _REQUIRED_BIT | _SINT64_BIT;
74 static const int _REQUIRED_UINT32 = _REQUIRED_BIT | _UINT32_BIT;
75 static const int _REQUIRED_UINT64 = _REQUIRED_BIT | _UINT64_BIT;
76 static const int _REQUIRED_FIXED32 = _REQUIRED_BIT | _FIXED32_BIT;
77 static const int _REQUIRED_FIXED64 = _REQUIRED_BIT | _FIXED64_BIT;
78 static const int _REQUIRED_SFIXED32 = _REQUIRED_BIT | _SFIXED32_BIT;
79 static const int _REQUIRED_SFIXED64 = _REQUIRED_BIT | _SFIXED64_BIT;
80 static const int _REQUIRED_MESSAGE = _REQUIRED_BIT | _MESSAGE_BIT;
81
82 static const int _REPEATED_BOOL = _REPEATED_BIT | _BOOL_BIT;
83 static const int _REPEATED_BYTES = _REPEATED_BIT | _BYTES_BIT;
84 static const int _REPEATED_STRING = _REPEATED_BIT | _STRING_BIT;
85 static const int _REPEATED_FLOAT = _REPEATED_BIT | _FLOAT_BIT;
86 static const int _REPEATED_DOUBLE = _REPEATED_BIT | _DOUBLE_BIT;
87 static const int _REPEATED_ENUM = _REPEATED_BIT | _ENUM_BIT;
88 static const int _REPEATED_GROUP = _REPEATED_BIT | _GROUP_BIT;
89 static const int _REPEATED_INT32 = _REPEATED_BIT | _INT32_BIT;
90 static const int _REPEATED_INT64 = _REPEATED_BIT | _INT64_BIT;
91 static const int _REPEATED_SINT32 = _REPEATED_BIT | _SINT32_BIT;
92 static const int _REPEATED_SINT64 = _REPEATED_BIT | _SINT64_BIT;
93 static const int _REPEATED_UINT32 = _REPEATED_BIT | _UINT32_BIT;
94 static const int _REPEATED_UINT64 = _REPEATED_BIT | _UINT64_BIT;
95 static const int _REPEATED_FIXED32 = _REPEATED_BIT | _FIXED32_BIT;
96 static const int _REPEATED_FIXED64 = _REPEATED_BIT | _FIXED64_BIT;
97 static const int _REPEATED_SFIXED32 = _REPEATED_BIT | _SFIXED32_BIT;
98 static const int _REPEATED_SFIXED64 = _REPEATED_BIT | _SFIXED64_BIT;
99 static const int _REPEATED_MESSAGE = _REPEATED_BIT | _MESSAGE_BIT;
100
101 static const int _PACKED_BOOL = _REPEATED_BIT | _PACKED_BIT | _BOOL_BIT;
102 static const int _PACKED_FLOAT = _REPEATED_BIT | _PACKED_BIT | _FLOAT_BIT;
103 static const int _PACKED_DOUBLE = _REPEATED_BIT | _PACKED_BIT | _DOUBLE_BIT;
104 static const int _PACKED_ENUM = _REPEATED_BIT | _PACKED_BIT | _ENUM_BIT;
105 static const int _PACKED_INT32 = _REPEATED_BIT | _PACKED_BIT | _INT32_BIT;
106 static const int _PACKED_INT64 = _REPEATED_BIT | _PACKED_BIT | _INT64_BIT;
107 static const int _PACKED_SINT32 = _REPEATED_BIT | _PACKED_BIT | _SINT32_BIT;
108 static const int _PACKED_SINT64 = _REPEATED_BIT | _PACKED_BIT | _SINT64_BIT;
109 static const int _PACKED_UINT32 = _REPEATED_BIT | _PACKED_BIT | _UINT32_BIT;
110 static const int _PACKED_UINT64 = _REPEATED_BIT | _PACKED_BIT | _UINT64_BIT;
111 static const int _PACKED_FIXED32 = _REPEATED_BIT | _PACKED_BIT | _FIXED32_BIT;
112 static const int _PACKED_FIXED64 = _REPEATED_BIT | _PACKED_BIT | _FIXED64_BIT;
113 static const int _PACKED_SFIXED32 = _REPEATED_BIT | _PACKED_BIT |
114 _SFIXED32_BIT;
115 static const int _PACKED_SFIXED64 = _REPEATED_BIT | _PACKED_BIT |
116 _SFIXED64_BIT;
117 21
118 // Short names for use in generated code. 22 // Short names for use in generated code.
23 // TODO(skybrian) change generated code to use FieldType instead.
119 24
120 // _O_ptional. 25 // _O_ptional.
121 static const int OB = _OPTIONAL_BOOL; 26 static const int OB = FieldType._OPTIONAL_BOOL;
122 static const int OY = _OPTIONAL_BYTES; 27 static const int OY = FieldType._OPTIONAL_BYTES;
123 static const int OS = _OPTIONAL_STRING; 28 static const int OS = FieldType._OPTIONAL_STRING;
124 static const int OF = _OPTIONAL_FLOAT; 29 static const int OF = FieldType._OPTIONAL_FLOAT;
125 static const int OD = _OPTIONAL_DOUBLE; 30 static const int OD = FieldType._OPTIONAL_DOUBLE;
126 static const int OE = _OPTIONAL_ENUM; 31 static const int OE = FieldType._OPTIONAL_ENUM;
127 static const int OG = _OPTIONAL_GROUP; 32 static const int OG = FieldType._OPTIONAL_GROUP;
128 static const int O3 = _OPTIONAL_INT32; 33 static const int O3 = FieldType._OPTIONAL_INT32;
129 static const int O6 = _OPTIONAL_INT64; 34 static const int O6 = FieldType._OPTIONAL_INT64;
130 static const int OS3 = _OPTIONAL_SINT32; 35 static const int OS3 = FieldType._OPTIONAL_SINT32;
131 static const int OS6 = _OPTIONAL_SINT64; 36 static const int OS6 = FieldType._OPTIONAL_SINT64;
132 static const int OU3 = _OPTIONAL_UINT32; 37 static const int OU3 = FieldType._OPTIONAL_UINT32;
133 static const int OU6 = _OPTIONAL_UINT64; 38 static const int OU6 = FieldType._OPTIONAL_UINT64;
134 static const int OF3 = _OPTIONAL_FIXED32; 39 static const int OF3 = FieldType._OPTIONAL_FIXED32;
135 static const int OF6 = _OPTIONAL_FIXED64; 40 static const int OF6 = FieldType._OPTIONAL_FIXED64;
136 static const int OSF3 = _OPTIONAL_SFIXED32; 41 static const int OSF3 = FieldType._OPTIONAL_SFIXED32;
137 static const int OSF6 = _OPTIONAL_SFIXED64; 42 static const int OSF6 = FieldType._OPTIONAL_SFIXED64;
138 static const int OM = _OPTIONAL_MESSAGE; 43 static const int OM = FieldType._OPTIONAL_MESSAGE;
139 44
140 // re_Q_uired. 45 // re_Q_uired.
141 static const int QB = _REQUIRED_BOOL; 46 static const int QB = FieldType._REQUIRED_BOOL;
142 static const int QY = _REQUIRED_BYTES; 47 static const int QY = FieldType._REQUIRED_BYTES;
143 static const int QS = _REQUIRED_STRING; 48 static const int QS = FieldType._REQUIRED_STRING;
144 static const int QF = _REQUIRED_FLOAT; 49 static const int QF = FieldType._REQUIRED_FLOAT;
145 static const int QD = _REQUIRED_DOUBLE; 50 static const int QD = FieldType._REQUIRED_DOUBLE;
146 static const int QE = _REQUIRED_ENUM; 51 static const int QE = FieldType._REQUIRED_ENUM;
147 static const int QG = _REQUIRED_GROUP; 52 static const int QG = FieldType._REQUIRED_GROUP;
148 static const int Q3 = _REQUIRED_INT32; 53 static const int Q3 = FieldType._REQUIRED_INT32;
149 static const int Q6 = _REQUIRED_INT64; 54 static const int Q6 = FieldType._REQUIRED_INT64;
150 static const int QS3 = _REQUIRED_SINT32; 55 static const int QS3 = FieldType._REQUIRED_SINT32;
151 static const int QS6 = _REQUIRED_SINT64; 56 static const int QS6 = FieldType._REQUIRED_SINT64;
152 static const int QU3 = _REQUIRED_UINT32; 57 static const int QU3 = FieldType._REQUIRED_UINT32;
153 static const int QU6 = _REQUIRED_UINT64; 58 static const int QU6 = FieldType._REQUIRED_UINT64;
154 static const int QF3 = _REQUIRED_FIXED32; 59 static const int QF3 = FieldType._REQUIRED_FIXED32;
155 static const int QF6 = _REQUIRED_FIXED64; 60 static const int QF6 = FieldType._REQUIRED_FIXED64;
156 static const int QSF3 = _REQUIRED_SFIXED32; 61 static const int QSF3 = FieldType._REQUIRED_SFIXED32;
157 static const int QSF6 = _REQUIRED_SFIXED64; 62 static const int QSF6 = FieldType._REQUIRED_SFIXED64;
158 static const int QM = _REQUIRED_MESSAGE; 63 static const int QM = FieldType._REQUIRED_MESSAGE;
159 64
160 // re_P_eated. 65 // re_P_eated.
161 static const int PB = _REPEATED_BOOL; 66 static const int PB = FieldType._REPEATED_BOOL;
162 static const int PY = _REPEATED_BYTES; 67 static const int PY = FieldType._REPEATED_BYTES;
163 static const int PS = _REPEATED_STRING; 68 static const int PS = FieldType._REPEATED_STRING;
164 static const int PF = _REPEATED_FLOAT; 69 static const int PF = FieldType._REPEATED_FLOAT;
165 static const int PD = _REPEATED_DOUBLE; 70 static const int PD = FieldType._REPEATED_DOUBLE;
166 static const int PE = _REPEATED_ENUM; 71 static const int PE = FieldType._REPEATED_ENUM;
167 static const int PG = _REPEATED_GROUP; 72 static const int PG = FieldType._REPEATED_GROUP;
168 static const int P3 = _REPEATED_INT32; 73 static const int P3 = FieldType._REPEATED_INT32;
169 static const int P6 = _REPEATED_INT64; 74 static const int P6 = FieldType._REPEATED_INT64;
170 static const int PS3 = _REPEATED_SINT32; 75 static const int PS3 = FieldType._REPEATED_SINT32;
171 static const int PS6 = _REPEATED_SINT64; 76 static const int PS6 = FieldType._REPEATED_SINT64;
172 static const int PU3 = _REPEATED_UINT32; 77 static const int PU3 = FieldType._REPEATED_UINT32;
173 static const int PU6 = _REPEATED_UINT64; 78 static const int PU6 = FieldType._REPEATED_UINT64;
174 static const int PF3 = _REPEATED_FIXED32; 79 static const int PF3 = FieldType._REPEATED_FIXED32;
175 static const int PF6 = _REPEATED_FIXED64; 80 static const int PF6 = FieldType._REPEATED_FIXED64;
176 static const int PSF3 = _REPEATED_SFIXED32; 81 static const int PSF3 = FieldType._REPEATED_SFIXED32;
177 static const int PSF6 = _REPEATED_SFIXED64; 82 static const int PSF6 = FieldType._REPEATED_SFIXED64;
178 static const int PM = _REPEATED_MESSAGE; 83 static const int PM = FieldType._REPEATED_MESSAGE;
179 84
180 // pac_K_ed. 85 // pac_K_ed.
181 static const int KB = _PACKED_BOOL; 86 static const int KB = FieldType._PACKED_BOOL;
182 static const int KE = _PACKED_ENUM; 87 static const int KE = FieldType._PACKED_ENUM;
183 static const int KF = _PACKED_FLOAT; 88 static const int KF = FieldType._PACKED_FLOAT;
184 static const int KD = _PACKED_DOUBLE; 89 static const int KD = FieldType._PACKED_DOUBLE;
185 static const int K3 = _PACKED_INT32; 90 static const int K3 = FieldType._PACKED_INT32;
186 static const int K6 = _PACKED_INT64; 91 static const int K6 = FieldType._PACKED_INT64;
187 static const int KS3 = _PACKED_SINT32; 92 static const int KS3 = FieldType._PACKED_SINT32;
188 static const int KS6 = _PACKED_SINT64; 93 static const int KS6 = FieldType._PACKED_SINT64;
189 static const int KU3 = _PACKED_UINT32; 94 static const int KU3 = FieldType._PACKED_UINT32;
190 static const int KU6 = _PACKED_UINT64; 95 static const int KU6 = FieldType._PACKED_UINT64;
191 static const int KF3 = _PACKED_FIXED32; 96 static const int KF3 = FieldType._PACKED_FIXED32;
192 static const int KF6 = _PACKED_FIXED64; 97 static const int KF6 = FieldType._PACKED_FIXED64;
193 static const int KSF3 = _PACKED_SFIXED32; 98 static const int KSF3 = FieldType._PACKED_SFIXED32;
194 static const int KSF6 = _PACKED_SFIXED64; 99 static const int KSF6 = FieldType._PACKED_SFIXED64;
195 100
196 // Range of integers in JSON (53-bit integers). 101 // Range of integers in JSON (53-bit integers).
197 static Int64 MAX_JSON_INT = new Int64.fromInts(0x200000, 0); 102 static Int64 MAX_JSON_INT = new Int64.fromInts(0x200000, 0);
198 static Int64 MIN_JSON_INT = -MAX_JSON_INT; 103 static Int64 MIN_JSON_INT = -MAX_JSON_INT;
199 104
200 // Closures commonly used by initializers.
201 static String _STRING_EMPTY() => '';
202 static List<int> _BYTES_EMPTY() => new PbList<int>();
203 static bool _BOOL_FALSE() => false;
204 static int _INT_ZERO() => 0;
205 static double _DOUBLE_ZERO() => 0.0;
206
207 static MakeDefaultFunc _defaultForType(int type) {
208 switch (type) {
209 case _OPTIONAL_BOOL: case _REQUIRED_BOOL:
210 return _BOOL_FALSE;
211 case _OPTIONAL_BYTES: case _REQUIRED_BYTES:
212 return _BYTES_EMPTY;
213 case _OPTIONAL_STRING: case _REQUIRED_STRING:
214 return _STRING_EMPTY;
215 case _OPTIONAL_FLOAT: case _REQUIRED_FLOAT:
216 case _OPTIONAL_DOUBLE: case _REQUIRED_DOUBLE:
217 return _DOUBLE_ZERO;
218 case _OPTIONAL_INT32: case _REQUIRED_INT32:
219 case _OPTIONAL_INT64: case _REQUIRED_INT64:
220 case _OPTIONAL_SINT32: case _REQUIRED_SINT32:
221 case _OPTIONAL_SINT64: case _REQUIRED_SINT64:
222 case _OPTIONAL_UINT32: case _REQUIRED_UINT32:
223 case _OPTIONAL_UINT64: case _REQUIRED_UINT64:
224 case _OPTIONAL_FIXED32: case _REQUIRED_FIXED32:
225 case _OPTIONAL_FIXED64: case _REQUIRED_FIXED64:
226 case _OPTIONAL_SFIXED32: case _REQUIRED_SFIXED32:
227 case _OPTIONAL_SFIXED64: case _REQUIRED_SFIXED64:
228 return _INT_ZERO;
229 default:
230 return null;
231 }
232 }
233
234 final Map<int, dynamic> _fieldValues = new Map<int, dynamic>(); 105 final Map<int, dynamic> _fieldValues = new Map<int, dynamic>();
235 final Map<int, Extension> _extensions = new Map<int, Extension>(); 106 final Map<int, Extension> _extensions = new Map<int, Extension>();
236 final UnknownFieldSet unknownFields = new UnknownFieldSet(); 107 final UnknownFieldSet unknownFields = new UnknownFieldSet();
237 108
238 GeneratedMessage() { 109 GeneratedMessage() {
239 if (eventPlugin != null) eventPlugin.attach(this); 110 if (eventPlugin != null) eventPlugin.attach(this);
240 } 111 }
241 112
242 GeneratedMessage.fromBuffer(List<int> input, 113 GeneratedMessage.fromBuffer(List<int> input,
243 ExtensionRegistry extensionRegistry) { 114 ExtensionRegistry extensionRegistry) {
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after
310 hash = (31 * hash + enm.value) & 0x3fffffff; 181 hash = (31 * hash + enm.value) & 0x3fffffff;
311 }); 182 });
312 } 183 }
313 184
314 void hashFields() { 185 void hashFields() {
315 for (int tagNumber in sorted(_fieldValues.keys)) { 186 for (int tagNumber in sorted(_fieldValues.keys)) {
316 if (!hasField(tagNumber)) continue; 187 if (!hasField(tagNumber)) continue;
317 var value = _fieldValues[tagNumber]; 188 var value = _fieldValues[tagNumber];
318 hash = ((37 * hash) + tagNumber) & 0x3fffffff; 189 hash = ((37 * hash) + tagNumber) & 0x3fffffff;
319 int fieldType = _getFieldType(tagNumber); 190 int fieldType = _getFieldType(tagNumber);
320 if (_toBaseFieldType(fieldType) != _ENUM_BIT) { 191 if (!_isEnum(fieldType)) {
321 // TODO(sgjesse): Remove 'as Object' here when issue 14951 is fixed. 192 // TODO(sgjesse): Remove 'as Object' here when issue 14951 is fixed.
322 hash = ((53 * hash) + (value as Object).hashCode) & 0x3fffffff; 193 hash = ((53 * hash) + (value as Object).hashCode) & 0x3fffffff;
323 } else if ((fieldType & _REPEATED_BIT) != 0) { 194 } else if (_isRepeated(fieldType)) {
324 hashEnumList(value); 195 hashEnumList(value);
325 } else { 196 } else {
326 ProtobufEnum enm = value; 197 ProtobufEnum enm = value;
327 hash = ((53 * hash) + enm.value) & 0x3fffffff; 198 hash = ((53 * hash) + enm.value) & 0x3fffffff;
328 } 199 }
329 } 200 }
330 } 201 }
331 202
332 // Generate hash. 203 // Generate hash.
333 hash = 41; 204 hash = 41;
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after
437 // Not packed. 308 // Not packed.
438 readToList(list); 309 readToList(list);
439 } 310 }
440 } 311 }
441 312
442 void readPackable(int wireType, int tagNumber, Function readFunc) { 313 void readPackable(int wireType, int tagNumber, Function readFunc) {
443 void readToList(List list) => list.add(readFunc()); 314 void readToList(List list) => list.add(readFunc());
444 readPackableToList(wireType, tagNumber, readToList); 315 readPackableToList(wireType, tagNumber, readToList);
445 } 316 }
446 317
447 bool wireTypeMatch(int tagNumber, int fieldType, int wireType) {
448 switch (_toBaseFieldType(fieldType)) {
449 case _BOOL_BIT:
450 case _ENUM_BIT:
451 case _INT32_BIT:
452 case _INT64_BIT:
453 case _SINT32_BIT:
454 case _SINT64_BIT:
455 case _UINT32_BIT:
456 case _UINT64_BIT:
457 return wireType == WIRETYPE_VARINT ||
458 wireType == WIRETYPE_LENGTH_DELIMITED;
459 case _FLOAT_BIT:
460 case _FIXED32_BIT:
461 case _SFIXED32_BIT:
462 return wireType == WIRETYPE_FIXED32 ||
463 wireType == WIRETYPE_LENGTH_DELIMITED;
464 case _DOUBLE_BIT:
465 case _FIXED64_BIT:
466 case _SFIXED64_BIT:
467 return wireType == WIRETYPE_FIXED64 ||
468 wireType == WIRETYPE_LENGTH_DELIMITED;
469 case _BYTES_BIT:
470 case _STRING_BIT:
471 case _MESSAGE_BIT:
472 return wireType == WIRETYPE_LENGTH_DELIMITED;
473 case _GROUP_BIT:
474 return wireType == WIRETYPE_START_GROUP;
475 default:
476 return false;
477 }
478 }
479
480 while (true) { 318 while (true) {
481 int tag = input.readTag(); 319 int tag = input.readTag();
482 if (tag == 0) { 320 if (tag == 0) {
483 return; 321 return;
484 } 322 }
485 int wireType = tag & 0x7; 323 int wireType = tag & 0x7;
486 int tagNumber = tag >> 3; 324 int tagNumber = tag >> 3;
487 int fieldType = -1; 325 int fieldType = -1;
488 326
489 if (info_.containsTagNumber(tagNumber)) { 327 if (info_.containsTagNumber(tagNumber)) {
490 fieldType = info_.fieldType(tagNumber); 328 fieldType = info_.fieldType(tagNumber);
491 } else { 329 } else {
492 Extension extension = extensionRegistry 330 Extension extension = extensionRegistry
493 .getExtension(info_.messageName, tagNumber); 331 .getExtension(info_.messageName, tagNumber);
494 if (extension != null) { 332 if (extension != null) {
495 _addExtensionToMap(extension); 333 _addExtensionToMap(extension);
496 fieldType = extension.type; 334 fieldType = extension.type;
497 } 335 }
498 } 336 }
499 if (fieldType == -1 || !wireTypeMatch(tagNumber, fieldType, wireType)) { 337 if (fieldType == -1 || !_wireTypeMatches(fieldType, wireType)) {
500 if (!unknownFields.mergeFieldFromBuffer(tag, input)) { 338 if (!unknownFields.mergeFieldFromBuffer(tag, input)) {
501 return; 339 return;
502 } else { 340 } else {
503 continue; 341 continue;
504 } 342 }
505 } 343 }
506 344
507 // Ignore required/optional packed/unpacked. 345 // Ignore required/optional packed/unpacked.
508 fieldType &= ~(_PACKED_BIT | _REQUIRED_BIT); 346 fieldType &= ~(FieldType._PACKED_BIT | FieldType._REQUIRED_BIT);
509 switch (fieldType) { 347 switch (fieldType) {
510 case _OPTIONAL_BOOL: 348 case FieldType._OPTIONAL_BOOL:
511 _setField(tagNumber, input.readBool()); 349 _setField(tagNumber, input.readBool());
512 break; 350 break;
513 case _OPTIONAL_BYTES: 351 case FieldType._OPTIONAL_BYTES:
514 _setField(tagNumber, input.readBytes()); 352 _setField(tagNumber, input.readBytes());
515 break; 353 break;
516 case _OPTIONAL_STRING: 354 case FieldType._OPTIONAL_STRING:
517 _setField(tagNumber, input.readString()); 355 _setField(tagNumber, input.readString());
518 break; 356 break;
519 case _OPTIONAL_FLOAT: 357 case FieldType._OPTIONAL_FLOAT:
520 _setField(tagNumber, input.readFloat()); 358 _setField(tagNumber, input.readFloat());
521 break; 359 break;
522 case _OPTIONAL_DOUBLE: 360 case FieldType._OPTIONAL_DOUBLE:
523 _setField(tagNumber, input.readDouble()); 361 _setField(tagNumber, input.readDouble());
524 break; 362 break;
525 case _OPTIONAL_ENUM: 363 case FieldType._OPTIONAL_ENUM:
526 int rawValue = input.readEnum(); 364 int rawValue = input.readEnum();
527 var value = _getValueOfFunc(tagNumber, extensionRegistry)(rawValue); 365 var value = _getValueOfFunc(tagNumber, extensionRegistry)(rawValue);
528 if (value == null) { 366 if (value == null) {
529 unknownFields.mergeVarintField(tagNumber, new Int64(rawValue)); 367 unknownFields.mergeVarintField(tagNumber, new Int64(rawValue));
530 } else { 368 } else {
531 _setField(tagNumber, value); 369 _setField(tagNumber, value);
532 } 370 }
533 break; 371 break;
534 case _OPTIONAL_GROUP: 372 case FieldType._OPTIONAL_GROUP:
535 GeneratedMessage subMessage = 373 GeneratedMessage subMessage =
536 _getEmptyMessage(tagNumber, extensionRegistry); 374 _getEmptyMessage(tagNumber, extensionRegistry);
537 if (_fieldValues.containsKey(tagNumber)) { 375 if (_fieldValues.containsKey(tagNumber)) {
538 subMessage.mergeFromMessage(getField(tagNumber)); 376 subMessage.mergeFromMessage(getField(tagNumber));
539 } 377 }
540 input.readGroup(tagNumber, subMessage, extensionRegistry); 378 input.readGroup(tagNumber, subMessage, extensionRegistry);
541 _setField(tagNumber, subMessage); 379 _setField(tagNumber, subMessage);
542 break; 380 break;
543 case _OPTIONAL_INT32: 381 case FieldType._OPTIONAL_INT32:
544 _setField(tagNumber, input.readInt32()); 382 _setField(tagNumber, input.readInt32());
545 break; 383 break;
546 case _OPTIONAL_INT64: 384 case FieldType._OPTIONAL_INT64:
547 _setField(tagNumber, input.readInt64()); 385 _setField(tagNumber, input.readInt64());
548 break; 386 break;
549 case _OPTIONAL_SINT32: 387 case FieldType._OPTIONAL_SINT32:
550 _setField(tagNumber, input.readSint32()); 388 _setField(tagNumber, input.readSint32());
551 break; 389 break;
552 case _OPTIONAL_SINT64: 390 case FieldType._OPTIONAL_SINT64:
553 _setField(tagNumber, input.readSint64()); 391 _setField(tagNumber, input.readSint64());
554 break; 392 break;
555 case _OPTIONAL_UINT32: 393 case FieldType._OPTIONAL_UINT32:
556 _setField(tagNumber, input.readUint32()); 394 _setField(tagNumber, input.readUint32());
557 break; 395 break;
558 case _OPTIONAL_UINT64: 396 case FieldType._OPTIONAL_UINT64:
559 _setField(tagNumber, input.readUint64()); 397 _setField(tagNumber, input.readUint64());
560 break; 398 break;
561 case _OPTIONAL_FIXED32: 399 case FieldType._OPTIONAL_FIXED32:
562 _setField(tagNumber, input.readFixed32()); 400 _setField(tagNumber, input.readFixed32());
563 break; 401 break;
564 case _OPTIONAL_FIXED64: 402 case FieldType._OPTIONAL_FIXED64:
565 _setField(tagNumber, input.readFixed64()); 403 _setField(tagNumber, input.readFixed64());
566 break; 404 break;
567 case _OPTIONAL_SFIXED32: 405 case FieldType._OPTIONAL_SFIXED32:
568 _setField(tagNumber, input.readSfixed32()); 406 _setField(tagNumber, input.readSfixed32());
569 break; 407 break;
570 case _OPTIONAL_SFIXED64: 408 case FieldType._OPTIONAL_SFIXED64:
571 _setField(tagNumber, input.readSfixed64()); 409 _setField(tagNumber, input.readSfixed64());
572 break; 410 break;
573 case _OPTIONAL_MESSAGE: 411 case FieldType._OPTIONAL_MESSAGE:
574 GeneratedMessage subMessage = 412 GeneratedMessage subMessage =
575 _getEmptyMessage(tagNumber, extensionRegistry); 413 _getEmptyMessage(tagNumber, extensionRegistry);
576 if (_fieldValues.containsKey(tagNumber)) { 414 if (_fieldValues.containsKey(tagNumber)) {
577 subMessage.mergeFromMessage(getField(tagNumber)); 415 subMessage.mergeFromMessage(getField(tagNumber));
578 } 416 }
579 input.readMessage(subMessage, extensionRegistry); 417 input.readMessage(subMessage, extensionRegistry);
580 _setField(tagNumber, subMessage); 418 _setField(tagNumber, subMessage);
581 break; 419 break;
582 case _REPEATED_BOOL: 420 case FieldType._REPEATED_BOOL:
583 readPackable(wireType, tagNumber, input.readBool); 421 readPackable(wireType, tagNumber, input.readBool);
584 break; 422 break;
585 case _REPEATED_BYTES: 423 case FieldType._REPEATED_BYTES:
586 appendToRepeated(tagNumber, input.readBytes()); 424 appendToRepeated(tagNumber, input.readBytes());
587 break; 425 break;
588 case _REPEATED_STRING: 426 case FieldType._REPEATED_STRING:
589 appendToRepeated(tagNumber, input.readString()); 427 appendToRepeated(tagNumber, input.readString());
590 break; 428 break;
591 case _REPEATED_FLOAT: 429 case FieldType._REPEATED_FLOAT:
592 readPackable(wireType, tagNumber, input.readFloat); 430 readPackable(wireType, tagNumber, input.readFloat);
593 break; 431 break;
594 case _REPEATED_DOUBLE: 432 case FieldType._REPEATED_DOUBLE:
595 readPackable(wireType, tagNumber, input.readDouble); 433 readPackable(wireType, tagNumber, input.readDouble);
596 break; 434 break;
597 case _REPEATED_ENUM: 435 case FieldType._REPEATED_ENUM:
598 readPackableToList(wireType, tagNumber, (List list) { 436 readPackableToList(wireType, tagNumber, (List list) {
599 int rawValue = input.readEnum(); 437 int rawValue = input.readEnum();
600 var value = _getValueOfFunc(tagNumber, extensionRegistry)(rawValue); 438 var value = _getValueOfFunc(tagNumber, extensionRegistry)(rawValue);
601 if (value == null) { 439 if (value == null) {
602 unknownFields.mergeVarintField(tagNumber, new Int64(rawValue)); 440 unknownFields.mergeVarintField(tagNumber, new Int64(rawValue));
603 } else { 441 } else {
604 list.add(value); 442 list.add(value);
605 } 443 }
606 }); 444 });
607 break; 445 break;
608 case _REPEATED_GROUP: 446 case FieldType._REPEATED_GROUP:
609 GeneratedMessage subMessage = 447 GeneratedMessage subMessage =
610 _getEmptyMessage(tagNumber, extensionRegistry); 448 _getEmptyMessage(tagNumber, extensionRegistry);
611 input.readGroup(tagNumber, subMessage, extensionRegistry); 449 input.readGroup(tagNumber, subMessage, extensionRegistry);
612 appendToRepeated(tagNumber, subMessage); 450 appendToRepeated(tagNumber, subMessage);
613 break; 451 break;
614 case _REPEATED_INT32: 452 case FieldType._REPEATED_INT32:
615 readPackable(wireType, tagNumber, input.readInt32); 453 readPackable(wireType, tagNumber, input.readInt32);
616 break; 454 break;
617 case _REPEATED_INT64: 455 case FieldType._REPEATED_INT64:
618 readPackable(wireType, tagNumber, input.readInt64); 456 readPackable(wireType, tagNumber, input.readInt64);
619 break; 457 break;
620 case _REPEATED_SINT32: 458 case FieldType._REPEATED_SINT32:
621 readPackable(wireType, tagNumber, input.readSint32); 459 readPackable(wireType, tagNumber, input.readSint32);
622 break; 460 break;
623 case _REPEATED_SINT64: 461 case FieldType._REPEATED_SINT64:
624 readPackable(wireType, tagNumber, input.readSint64); 462 readPackable(wireType, tagNumber, input.readSint64);
625 break; 463 break;
626 case _REPEATED_UINT32: 464 case FieldType._REPEATED_UINT32:
627 readPackable(wireType, tagNumber, input.readUint32); 465 readPackable(wireType, tagNumber, input.readUint32);
628 break; 466 break;
629 case _REPEATED_UINT64: 467 case FieldType._REPEATED_UINT64:
630 readPackable(wireType, tagNumber, input.readUint64); 468 readPackable(wireType, tagNumber, input.readUint64);
631 break; 469 break;
632 case _REPEATED_FIXED32: 470 case FieldType._REPEATED_FIXED32:
633 readPackable(wireType, tagNumber, input.readFixed32); 471 readPackable(wireType, tagNumber, input.readFixed32);
634 break; 472 break;
635 case _REPEATED_FIXED64: 473 case FieldType._REPEATED_FIXED64:
636 readPackable(wireType, tagNumber, input.readFixed64); 474 readPackable(wireType, tagNumber, input.readFixed64);
637 break; 475 break;
638 case _REPEATED_SFIXED32: 476 case FieldType._REPEATED_SFIXED32:
639 readPackable(wireType, tagNumber, input.readSfixed32); 477 readPackable(wireType, tagNumber, input.readSfixed32);
640 break; 478 break;
641 case _REPEATED_SFIXED64: 479 case FieldType._REPEATED_SFIXED64:
642 readPackable(wireType, tagNumber, input.readSfixed64); 480 readPackable(wireType, tagNumber, input.readSfixed64);
643 break; 481 break;
644 case _REPEATED_MESSAGE: 482 case FieldType._REPEATED_MESSAGE:
645 GeneratedMessage subMessage = 483 GeneratedMessage subMessage =
646 _getEmptyMessage(tagNumber, extensionRegistry); 484 _getEmptyMessage(tagNumber, extensionRegistry);
647 input.readMessage(subMessage, extensionRegistry); 485 input.readMessage(subMessage, extensionRegistry);
648 appendToRepeated(tagNumber, subMessage); 486 appendToRepeated(tagNumber, subMessage);
649 break; 487 break;
650 default: 488 default:
651 throw 'Unknown field type $fieldType'; 489 throw 'Unknown field type $fieldType';
652 } 490 }
653 } 491 }
654 } 492 }
(...skipping 14 matching lines...) Expand all
669 codedInput.checkLastTagWas(0); 507 codedInput.checkLastTagWas(0);
670 } 508 }
671 509
672 // JSON support. 510 // JSON support.
673 511
674 /// Returns the JSON encoding of this message as a Dart [Map]. 512 /// Returns the JSON encoding of this message as a Dart [Map].
675 /// 513 ///
676 /// The encoding is described in [GeneratedMessage.writeToJson]. 514 /// The encoding is described in [GeneratedMessage.writeToJson].
677 Map<String, dynamic> writeToJsonMap() { 515 Map<String, dynamic> writeToJsonMap() {
678 convertToMap(fieldValue, fieldType) { 516 convertToMap(fieldValue, fieldType) {
679 int scalarType = fieldType & ~(_REPEATED_BIT | _PACKED_BIT); 517 int baseType = FieldType._baseType(fieldType);
680 518
681 if ((fieldType & _REPEATED_BIT) != 0) { 519 if (_isRepeated(fieldType)) {
682 return new List.from(fieldValue.map((e) => convertToMap(e, scalarType))) ; 520 return new List.from(fieldValue.map((e) => convertToMap(e, baseType)));
683 } 521 }
684 522
685 switch (scalarType) { 523 switch (baseType) {
686 case _BOOL_BIT: 524 case FieldType._BOOL_BIT:
687 case _STRING_BIT: 525 case FieldType._STRING_BIT:
688 case _FLOAT_BIT: 526 case FieldType._FLOAT_BIT:
689 case _DOUBLE_BIT: 527 case FieldType._DOUBLE_BIT:
690 case _INT32_BIT: 528 case FieldType._INT32_BIT:
691 case _SINT32_BIT: 529 case FieldType._SINT32_BIT:
692 case _UINT32_BIT: 530 case FieldType._UINT32_BIT:
693 case _FIXED32_BIT: 531 case FieldType._FIXED32_BIT:
694 case _SFIXED32_BIT: 532 case FieldType._SFIXED32_BIT:
695 return fieldValue; 533 return fieldValue;
696 case _BYTES_BIT: 534 case FieldType._BYTES_BIT:
697 // Encode 'bytes' as a base64-encoded string. 535 // Encode 'bytes' as a base64-encoded string.
698 return CryptoUtils.bytesToBase64(fieldValue); 536 return CryptoUtils.bytesToBase64(fieldValue);
699 case _ENUM_BIT: 537 case FieldType._ENUM_BIT:
700 return fieldValue.value; // assume |value| < 2^52 538 return fieldValue.value; // assume |value| < 2^52
701 case _INT64_BIT: 539 case FieldType._INT64_BIT:
702 case _SINT64_BIT: 540 case FieldType._SINT64_BIT:
703 case _UINT64_BIT: 541 case FieldType._UINT64_BIT:
704 case _FIXED64_BIT: 542 case FieldType._FIXED64_BIT:
705 case _SFIXED64_BIT: 543 case FieldType._SFIXED64_BIT:
706 // Use strings for 64-bit integers which cannot fit in doubles. 544 // Use strings for 64-bit integers which cannot fit in doubles.
707 if (MIN_JSON_INT <= fieldValue && fieldValue <= MAX_JSON_INT) { 545 if (MIN_JSON_INT <= fieldValue && fieldValue <= MAX_JSON_INT) {
708 return fieldValue.toInt(); 546 return fieldValue.toInt();
709 } 547 }
710 return fieldValue.toString(); 548 return fieldValue.toString();
711 case _GROUP_BIT: 549 case FieldType._GROUP_BIT:
712 case _MESSAGE_BIT: 550 case FieldType._MESSAGE_BIT:
713 return fieldValue.writeToJsonMap(); 551 return fieldValue.writeToJsonMap();
714 default: 552 default:
715 throw 'Unknown type $fieldType'; 553 throw 'Unknown type $fieldType';
716 } 554 }
717 } 555 }
718 556
719 var result = <String, dynamic>{}; 557 var result = <String, dynamic>{};
720 for (int tagNumber in sorted(_fieldValues.keys)) { 558 for (int tagNumber in sorted(_fieldValues.keys)) {
721 if (!hasField(tagNumber)) continue; 559 if (!hasField(tagNumber)) continue;
722 String key = '$tagNumber'; 560 String key = '$tagNumber';
723 var fieldValue = _fieldValues[tagNumber]; 561 var fieldValue = _fieldValues[tagNumber];
724 int fieldType = _getFieldType(tagNumber) & ~_REQUIRED_BIT; 562 int fieldType = _getFieldType(tagNumber);
725 result[key] = convertToMap(fieldValue, fieldType); 563 result[key] = convertToMap(fieldValue, fieldType);
726 } 564 }
727 return result; 565 return result;
728 } 566 }
729 567
730 /// Returns a JSON string that encodes this message. 568 /// Returns a JSON string that encodes this message.
731 /// 569 ///
732 /// Each message (top level or nested) is represented as an object delimited 570 /// Each message (top level or nested) is represented as an object delimited
733 /// by curly braces. Within a message, elements are indexed by tag number 571 /// by curly braces. Within a message, elements are indexed by tag number
734 /// (surrounded by quotes). Repeated elements are represented as arrays. 572 /// (surrounded by quotes). Repeated elements are represented as arrays.
(...skipping 26 matching lines...) Expand all
761 if (extension == null) { 599 if (extension == null) {
762 // Unknown extensions can be skipped. 600 // Unknown extensions can be skipped.
763 continue; 601 continue;
764 } 602 }
765 _addExtensionToMap(extension); 603 _addExtensionToMap(extension);
766 fieldType = extension.type; 604 fieldType = extension.type;
767 } 605 }
768 if (fieldType == -1) { 606 if (fieldType == -1) {
769 throw new StateError('Unknown field type for tag number $tagNumber'); 607 throw new StateError('Unknown field type for tag number $tagNumber');
770 } 608 }
771 if ((fieldType & _REPEATED_BIT) != 0) { 609 if (_isRepeated(fieldType)) {
772 List thisList = getField(tagNumber); 610 List thisList = getField(tagNumber);
773 for (var value in fieldValue) { 611 for (var value in fieldValue) {
774 thisList.add(_convertJsonValue(value, tagNumber, fieldType, 612 thisList.add(_convertJsonValue(value, tagNumber, fieldType,
775 extensionRegistry)); 613 extensionRegistry));
776 } 614 }
777 } else { 615 } else {
778 var value = _convertJsonValue(fieldValue, tagNumber, fieldType, 616 var value = _convertJsonValue(fieldValue, tagNumber, fieldType,
779 extensionRegistry); 617 extensionRegistry);
780 setField(tagNumber, value, fieldType); 618 setField(tagNumber, value, fieldType);
781 } 619 }
782 } 620 }
783 } 621 }
784 622
785 _convertJsonValue(value, int tagNumber, int fieldType, 623 _convertJsonValue(value, int tagNumber, int fieldType,
786 ExtensionRegistry extensionRegistry) { 624 ExtensionRegistry extensionRegistry) {
787 String expectedType; // for exception message 625 String expectedType; // for exception message
788 switch (_toBaseFieldType(fieldType)) { 626 switch (FieldType._baseType(fieldType)) {
789 case _BOOL_BIT: 627 case FieldType._BOOL_BIT:
790 if (value is bool) { 628 if (value is bool) {
791 return value; 629 return value;
792 } else if (value is String) { 630 } else if (value is String) {
793 if (value == 'true') { 631 if (value == 'true') {
794 return true; 632 return true;
795 } else if (value == 'false') { 633 } else if (value == 'false') {
796 return false; 634 return false;
797 } 635 }
798 expectedType = 'bool, "true", or "false"'; 636 expectedType = 'bool, "true", or "false"';
799 } else if (value is num) { 637 } else if (value is num) {
800 if (value == 1) { 638 if (value == 1) {
801 return true; 639 return true;
802 } else if (value == 0) { 640 } else if (value == 0) {
803 return false; 641 return false;
804 } 642 }
805 expectedType = 'bool, 0, or 1'; 643 expectedType = 'bool, 0, or 1';
806 } 644 }
807 break; 645 break;
808 case _BYTES_BIT: 646 case FieldType._BYTES_BIT:
809 if (value is String) { 647 if (value is String) {
810 return CryptoUtils.base64StringToBytes(value); 648 return CryptoUtils.base64StringToBytes(value);
811 } 649 }
812 expectedType = 'Base64 String'; 650 expectedType = 'Base64 String';
813 break; 651 break;
814 case _STRING_BIT: 652 case FieldType._STRING_BIT:
815 if (value is String) { 653 if (value is String) {
816 return value; 654 return value;
817 } 655 }
818 expectedType = 'String'; 656 expectedType = 'String';
819 break; 657 break;
820 case _FLOAT_BIT: 658 case FieldType._FLOAT_BIT:
821 case _DOUBLE_BIT: 659 case FieldType._DOUBLE_BIT:
822 // Allow quoted values, although we don't emit them. 660 // Allow quoted values, although we don't emit them.
823 if (value is double) { 661 if (value is double) {
824 return value; 662 return value;
825 } else if (value is num) { 663 } else if (value is num) {
826 return value.toDouble(); 664 return value.toDouble();
827 } else if (value is String) { 665 } else if (value is String) {
828 return double.parse(value); 666 return double.parse(value);
829 } 667 }
830 expectedType = 'num or stringified num'; 668 expectedType = 'num or stringified num';
831 break; 669 break;
832 case _ENUM_BIT: 670 case FieldType._ENUM_BIT:
833 // Allow quoted values, although we don't emit them. 671 // Allow quoted values, although we don't emit them.
834 if (value is String) { 672 if (value is String) {
835 value = int.parse(value); 673 value = int.parse(value);
836 } 674 }
837 if (value is int) { 675 if (value is int) {
838 return _getValueOfFunc(tagNumber, extensionRegistry)(value); 676 return _getValueOfFunc(tagNumber, extensionRegistry)(value);
839 } 677 }
840 expectedType = 'int or stringified int'; 678 expectedType = 'int or stringified int';
841 break; 679 break;
842 case _INT32_BIT: 680 case FieldType._INT32_BIT:
843 case _SINT32_BIT: 681 case FieldType._SINT32_BIT:
844 case _UINT32_BIT: 682 case FieldType._UINT32_BIT:
845 case _FIXED32_BIT: 683 case FieldType._FIXED32_BIT:
846 case _SFIXED32_BIT: 684 case FieldType._SFIXED32_BIT:
847 if (value is String) { 685 if (value is String) {
848 value = int.parse(value); 686 value = int.parse(value);
849 } 687 }
850 // Allow unquoted values, although we don't emit them. 688 // Allow unquoted values, although we don't emit them.
851 if (value is int) { 689 if (value is int) {
852 return value; 690 return value;
853 } 691 }
854 expectedType = 'int or stringified int'; 692 expectedType = 'int or stringified int';
855 break; 693 break;
856 case _INT64_BIT: 694 case FieldType._INT64_BIT:
857 case _SINT64_BIT: 695 case FieldType._SINT64_BIT:
858 case _UINT64_BIT: 696 case FieldType._UINT64_BIT:
859 case _FIXED64_BIT: 697 case FieldType._FIXED64_BIT:
860 case _SFIXED64_BIT: 698 case FieldType._SFIXED64_BIT:
861 // Allow quoted values, although we don't emit them. 699 // Allow quoted values, although we don't emit them.
862 if (value is String) { 700 if (value is String) {
863 return Int64.parseRadix(value, 10); 701 return Int64.parseRadix(value, 10);
864 } 702 }
865 if (value is int) { 703 if (value is int) {
866 return new Int64(value); 704 return new Int64(value);
867 } 705 }
868 expectedType = 'int or stringified int'; 706 expectedType = 'int or stringified int';
869 break; 707 break;
870 case _GROUP_BIT: 708 case FieldType._GROUP_BIT:
871 case _MESSAGE_BIT: 709 case FieldType._MESSAGE_BIT:
872 if (value is Map) { 710 if (value is Map) {
873 GeneratedMessage subMessage = 711 GeneratedMessage subMessage =
874 _getEmptyMessage(tagNumber, extensionRegistry); 712 _getEmptyMessage(tagNumber, extensionRegistry);
875 subMessage._mergeFromJson(value, extensionRegistry); 713 subMessage._mergeFromJson(value, extensionRegistry);
876 return subMessage; 714 return subMessage;
877 } 715 }
878 expectedType = 'nested message or group'; 716 expectedType = 'nested message or group';
879 break; 717 break;
880 default: 718 default:
881 throw new ArgumentError('Unknown type $fieldType'); 719 throw new ArgumentError('Unknown type $fieldType');
(...skipping 16 matching lines...) Expand all
898 Map<String, dynamic> json, 736 Map<String, dynamic> json,
899 [ExtensionRegistry extensionRegistry = ExtensionRegistry.EMPTY]) { 737 [ExtensionRegistry extensionRegistry = ExtensionRegistry.EMPTY]) {
900 _mergeFromJson(json, extensionRegistry); 738 _mergeFromJson(json, extensionRegistry);
901 } 739 }
902 740
903 /// Adds an extension field value to a repeated field. 741 /// Adds an extension field value to a repeated field.
904 /// 742 ///
905 /// The backing [List] will be created if necessary. 743 /// The backing [List] will be created if necessary.
906 void addExtension(Extension extension, var value) { 744 void addExtension(Extension extension, var value) {
907 _checkExtension(extension); 745 _checkExtension(extension);
908 if ((extension.type & _REPEATED_BIT) == 0) { 746 if (!_isRepeated(extension.type)) {
909 throw new ArgumentError( 747 throw new ArgumentError(
910 'Cannot add to a non-repeated field (use setExtension())'); 748 'Cannot add to a non-repeated field (use setExtension())');
911 } 749 }
912 // Validate type and range. 750 // Validate type and range.
913 _validate(extension.tagNumber, extension.type & ~0x7, value); 751 _validate(extension.tagNumber, extension.type, value);
914 752
915 var list = _fieldValues[extension.tagNumber]; 753 var list = _fieldValues[extension.tagNumber];
916 if (list == null) { 754 if (list == null) {
917 list = extension.makeDefault(); 755 list = extension.makeDefault();
918 _setExtension(extension, list); 756 _setExtension(extension, list);
919 } 757 }
920 758
921 list.add(value); 759 list.add(value);
922 } 760 }
923 761
(...skipping 114 matching lines...) Expand 10 before | Expand all | Expand 10 after
1038 /// recursively merged. 876 /// recursively merged.
1039 void mergeFromMessage(GeneratedMessage other) { 877 void mergeFromMessage(GeneratedMessage other) {
1040 for (int tagNumber in other._fieldValues.keys) { 878 for (int tagNumber in other._fieldValues.keys) {
1041 var fieldValue = other._fieldValues[tagNumber]; 879 var fieldValue = other._fieldValues[tagNumber];
1042 880
1043 if (other._extensions.containsKey(tagNumber)) { 881 if (other._extensions.containsKey(tagNumber)) {
1044 _addExtensionToMap(other._extensions[tagNumber]); 882 _addExtensionToMap(other._extensions[tagNumber]);
1045 } 883 }
1046 int fieldType = other._getFieldType(tagNumber); 884 int fieldType = other._getFieldType(tagNumber);
1047 var cloner = (x) => x; 885 var cloner = (x) => x;
1048 if ((fieldType & (_GROUP_BIT | _MESSAGE_BIT)) != 0) { 886 if ((fieldType & (FieldType._GROUP_BIT | FieldType._MESSAGE_BIT)) != 0) {
1049 cloner = (message) => message.clone(); 887 cloner = (message) => message.clone();
1050 } 888 }
1051 if ((fieldType & _REPEATED_BIT) != 0) { 889 if (_isRepeated(fieldType)) {
1052 getField(tagNumber).addAll(new List.from(fieldValue).map(cloner)); 890 getField(tagNumber).addAll(new List.from(fieldValue).map(cloner));
1053 } else { 891 } else {
1054 setField(tagNumber, cloner(fieldValue), fieldType); 892 setField(tagNumber, cloner(fieldValue), fieldType);
1055 } 893 }
1056 } 894 }
1057 895
1058 mergeUnknownFields(other.unknownFields); 896 mergeUnknownFields(other.unknownFields);
1059 } 897 }
1060 898
1061 void mergeUnknownFields(UnknownFieldSet unknownFieldSet) { 899 void mergeUnknownFields(UnknownFieldSet unknownFieldSet) {
(...skipping 17 matching lines...) Expand all
1079 void setField(int tagNumber, value, [int fieldType = null]) { 917 void setField(int tagNumber, value, [int fieldType = null]) {
1080 if (value == null) { 918 if (value == null) {
1081 throw new ArgumentError('value is null'); 919 throw new ArgumentError('value is null');
1082 } 920 }
1083 if (fieldType == null) { 921 if (fieldType == null) {
1084 if (!info_.containsTagNumber(tagNumber)) { 922 if (!info_.containsTagNumber(tagNumber)) {
1085 throw new ArgumentError('Unknown tag: $tagNumber'); 923 throw new ArgumentError('Unknown tag: $tagNumber');
1086 } 924 }
1087 fieldType = info_.fieldType(tagNumber); 925 fieldType = info_.fieldType(tagNumber);
1088 } 926 }
1089 if ((fieldType & _REPEATED_BIT) != 0) { 927 if (_isRepeated(fieldType)) {
1090 throw new ArgumentError(_generateMessage(tagNumber, value, 928 throw new ArgumentError(_generateMessage(tagNumber, value,
1091 'repeating field (use get + .add())')); 929 'repeating field (use get + .add())'));
1092 } 930 }
1093 931
1094 // Validate type and range. 932 // Validate type and range.
1095 _validate(tagNumber, fieldType & ~0x7, value); 933 _validate(tagNumber, fieldType, value);
1096 934
1097 _setField(tagNumber, value); 935 _setField(tagNumber, value);
1098 } 936 }
1099 937
1100 void _setField(int tagNumber, value) { 938 void _setField(int tagNumber, value) {
1101 if (_hasObservers) { 939 if (_hasObservers) {
1102 eventPlugin.beforeSetField(tagNumber, value); 940 eventPlugin.beforeSetField(tagNumber, value);
1103 } 941 }
1104 _fieldValues[tagNumber] = value; 942 _fieldValues[tagNumber] = value;
1105 } 943 }
(...skipping 15 matching lines...) Expand all
1121 /// [GeneratedMessage], or from a known extension. If the type is unknown, 959 /// [GeneratedMessage], or from a known extension. If the type is unknown,
1122 /// [null] is returned. 960 /// [null] is returned.
1123 int _getFieldType(int tagNumber) { 961 int _getFieldType(int tagNumber) {
1124 int type = info_.fieldType(tagNumber); 962 int type = info_.fieldType(tagNumber);
1125 if (type == null && _extensions.containsKey(tagNumber)) { 963 if (type == null && _extensions.containsKey(tagNumber)) {
1126 type = _extensions[tagNumber].type; 964 type = _extensions[tagNumber].type;
1127 } 965 }
1128 return type; 966 return type;
1129 } 967 }
1130 968
1131 /// Returns the base field type without any of the required, repeated
1132 /// and packed bits.
1133 int _toBaseFieldType(int fieldType) {
1134 return fieldType & ~(_REQUIRED_BIT | _REPEATED_BIT | _PACKED_BIT);
1135 }
1136
1137 GeneratedMessage _getEmptyMessage( 969 GeneratedMessage _getEmptyMessage(
1138 int tagNumber, ExtensionRegistry extensionRegistry) { 970 int tagNumber, ExtensionRegistry extensionRegistry) {
1139 CreateBuilderFunc subBuilderFunc = info_.subBuilder(tagNumber); 971 CreateBuilderFunc subBuilderFunc = info_.subBuilder(tagNumber);
1140 if (subBuilderFunc == null && extensionRegistry != null) { 972 if (subBuilderFunc == null && extensionRegistry != null) {
1141 subBuilderFunc = extensionRegistry.getExtension(info_.messageName, 973 subBuilderFunc = extensionRegistry.getExtension(info_.messageName,
1142 tagNumber).subBuilder; 974 tagNumber).subBuilder;
1143 } 975 }
1144 return subBuilderFunc(); 976 return subBuilderFunc();
1145 } 977 }
1146 978
(...skipping 19 matching lines...) Expand all
1166 fieldName = _extensions[tagNumber].name; 998 fieldName = _extensions[tagNumber].name;
1167 } else { 999 } else {
1168 fieldName = info_.fieldName(tagNumber); 1000 fieldName = info_.fieldName(tagNumber);
1169 } 1001 }
1170 String messageType = info_.messageName; 1002 String messageType = info_.messageName;
1171 return 'Illegal to set field $fieldName ($tagNumber) of $messageType' 1003 return 'Illegal to set field $fieldName ($tagNumber) of $messageType'
1172 ' to value ($value): $detail'; 1004 ' to value ($value): $detail';
1173 } 1005 }
1174 1006
1175 void _validate(int tagNumber, int fieldType, var value) { 1007 void _validate(int tagNumber, int fieldType, var value) {
1176 switch (fieldType) { 1008 switch (FieldType._baseType(fieldType)) {
1177 case _BOOL_BIT: 1009 case FieldType._BOOL_BIT:
1178 if (value is !bool) { 1010 if (value is !bool) {
1179 throw new ArgumentError( 1011 throw new ArgumentError(
1180 _generateMessage(tagNumber, value, 'not type bool')); 1012 _generateMessage(tagNumber, value, 'not type bool'));
1181 } 1013 }
1182 break; 1014 break;
1183 case _BYTES_BIT: 1015 case FieldType._BYTES_BIT:
1184 if (value is !List) { 1016 if (value is !List) {
1185 throw new ArgumentError( 1017 throw new ArgumentError(
1186 _generateMessage(tagNumber, value, 'not List')); 1018 _generateMessage(tagNumber, value, 'not List'));
1187 } 1019 }
1188 break; 1020 break;
1189 case _STRING_BIT: 1021 case FieldType._STRING_BIT:
1190 if (value is !String) { 1022 if (value is !String) {
1191 throw new ArgumentError( 1023 throw new ArgumentError(
1192 _generateMessage(tagNumber, value, 'not type String')); 1024 _generateMessage(tagNumber, value, 'not type String'));
1193 } 1025 }
1194 break; 1026 break;
1195 case _FLOAT_BIT: 1027 case FieldType._FLOAT_BIT:
1196 if (value is !double) { 1028 if (value is !double) {
1197 throw new ArgumentError( 1029 throw new ArgumentError(
1198 _generateMessage(tagNumber, value, 'not type double')); 1030 _generateMessage(tagNumber, value, 'not type double'));
1199 } 1031 }
1200 if (!_isFloat32(value)) { 1032 if (!_isFloat32(value)) {
1201 throw new ArgumentError(_generateMessage(tagNumber, value, 1033 throw new ArgumentError(_generateMessage(tagNumber, value,
1202 'out of range for float')); 1034 'out of range for float'));
1203 } 1035 }
1204 break; 1036 break;
1205 case _DOUBLE_BIT: 1037 case FieldType._DOUBLE_BIT:
1206 if (value is !double) { 1038 if (value is !double) {
1207 throw new ArgumentError( 1039 throw new ArgumentError(
1208 _generateMessage(tagNumber, value, 'not type double')); 1040 _generateMessage(tagNumber, value, 'not type double'));
1209 } 1041 }
1210 break; 1042 break;
1211 case _ENUM_BIT: 1043 case FieldType._ENUM_BIT:
1212 if (value is !ProtobufEnum) { 1044 if (value is !ProtobufEnum) {
1213 throw new ArgumentError( 1045 throw new ArgumentError(
1214 _generateMessage(tagNumber, value, 'not type ProtobufEnum')); 1046 _generateMessage(tagNumber, value, 'not type ProtobufEnum'));
1215 } 1047 }
1216 break; 1048 break;
1217 case _INT32_BIT: 1049 case FieldType._INT32_BIT:
1218 if (value is !int) { 1050 if (value is !int) {
1219 throw new ArgumentError( 1051 throw new ArgumentError(
1220 _generateMessage(tagNumber, value, 'not type int')); 1052 _generateMessage(tagNumber, value, 'not type int'));
1221 } 1053 }
1222 if (!_isSigned32(value)) { 1054 if (!_isSigned32(value)) {
1223 throw new ArgumentError(_generateMessage(tagNumber, value, 1055 throw new ArgumentError(_generateMessage(tagNumber, value,
1224 'out of range for int32')); 1056 'out of range for int32'));
1225 } 1057 }
1226 break; 1058 break;
1227 case _INT64_BIT: 1059 case FieldType._INT64_BIT:
1228 if (value is !Int64) { 1060 if (value is !Int64) {
1229 throw new ArgumentError( 1061 throw new ArgumentError(
1230 _generateMessage(tagNumber, value, 'not Int64')); 1062 _generateMessage(tagNumber, value, 'not Int64'));
1231 } 1063 }
1232 if (!_isSigned64(value)) { 1064 if (!_isSigned64(value)) {
1233 throw new ArgumentError(_generateMessage(tagNumber, value, 1065 throw new ArgumentError(_generateMessage(tagNumber, value,
1234 'out of range for int64')); 1066 'out of range for int64'));
1235 } 1067 }
1236 break; 1068 break;
1237 case _SINT32_BIT: 1069 case FieldType._SINT32_BIT:
1238 if (value is !int) { 1070 if (value is !int) {
1239 throw new ArgumentError( 1071 throw new ArgumentError(
1240 _generateMessage(tagNumber, value, 'not type int')); 1072 _generateMessage(tagNumber, value, 'not type int'));
1241 } 1073 }
1242 if (!_isSigned32(value)) { 1074 if (!_isSigned32(value)) {
1243 throw new ArgumentError(_generateMessage(tagNumber, value, 1075 throw new ArgumentError(_generateMessage(tagNumber, value,
1244 'out of range for sint32')); 1076 'out of range for sint32'));
1245 } 1077 }
1246 break; 1078 break;
1247 case _SINT64_BIT: 1079 case FieldType._SINT64_BIT:
1248 if (value is !Int64) { 1080 if (value is !Int64) {
1249 throw new ArgumentError( 1081 throw new ArgumentError(
1250 _generateMessage(tagNumber, value, 'not Int64')); 1082 _generateMessage(tagNumber, value, 'not Int64'));
1251 } 1083 }
1252 if (!_isSigned64(value)) { 1084 if (!_isSigned64(value)) {
1253 throw new ArgumentError(_generateMessage(tagNumber, value, 1085 throw new ArgumentError(_generateMessage(tagNumber, value,
1254 'out of range for sint64')); 1086 'out of range for sint64'));
1255 } 1087 }
1256 break; 1088 break;
1257 case _UINT32_BIT: 1089 case FieldType._UINT32_BIT:
1258 if (value is !int) { 1090 if (value is !int) {
1259 throw new ArgumentError( 1091 throw new ArgumentError(
1260 _generateMessage(tagNumber, value, 'not type int')); 1092 _generateMessage(tagNumber, value, 'not type int'));
1261 } 1093 }
1262 if (!_isUnsigned32(value)) { 1094 if (!_isUnsigned32(value)) {
1263 throw new ArgumentError(_generateMessage(tagNumber, value, 1095 throw new ArgumentError(_generateMessage(tagNumber, value,
1264 'out of range for uint32')); 1096 'out of range for uint32'));
1265 } 1097 }
1266 break; 1098 break;
1267 case _UINT64_BIT: 1099 case FieldType._UINT64_BIT:
1268 if (value is !Int64) { 1100 if (value is !Int64) {
1269 throw new ArgumentError( 1101 throw new ArgumentError(
1270 _generateMessage(tagNumber, value, 'not Int64')); 1102 _generateMessage(tagNumber, value, 'not Int64'));
1271 } 1103 }
1272 if (!_isUnsigned64(value)) { 1104 if (!_isUnsigned64(value)) {
1273 throw new ArgumentError(_generateMessage(tagNumber, value, 1105 throw new ArgumentError(_generateMessage(tagNumber, value,
1274 'out of range for uint64')); 1106 'out of range for uint64'));
1275 } 1107 }
1276 break; 1108 break;
1277 case _FIXED32_BIT: 1109 case FieldType._FIXED32_BIT:
1278 if (value is !int) { 1110 if (value is !int) {
1279 throw new ArgumentError( 1111 throw new ArgumentError(
1280 _generateMessage(tagNumber, value, 'not type int')); 1112 _generateMessage(tagNumber, value, 'not type int'));
1281 } 1113 }
1282 if (!_isUnsigned32(value)) { 1114 if (!_isUnsigned32(value)) {
1283 throw new ArgumentError(_generateMessage(tagNumber, value, 1115 throw new ArgumentError(_generateMessage(tagNumber, value,
1284 'out of range for fixed32')); 1116 'out of range for fixed32'));
1285 } 1117 }
1286 break; 1118 break;
1287 case _FIXED64_BIT: 1119 case FieldType._FIXED64_BIT:
1288 if (value is !Int64) { 1120 if (value is !Int64) {
1289 throw new ArgumentError( 1121 throw new ArgumentError(
1290 _generateMessage(tagNumber, value, 'not Int64')); 1122 _generateMessage(tagNumber, value, 'not Int64'));
1291 } 1123 }
1292 if (!_isUnsigned64(value)) { 1124 if (!_isUnsigned64(value)) {
1293 throw new ArgumentError(_generateMessage(tagNumber, value, 1125 throw new ArgumentError(_generateMessage(tagNumber, value,
1294 'out of range for fixed64')); 1126 'out of range for fixed64'));
1295 } 1127 }
1296 break; 1128 break;
1297 case _SFIXED32_BIT: 1129 case FieldType._SFIXED32_BIT:
1298 if (value is !int) { 1130 if (value is !int) {
1299 throw new ArgumentError( 1131 throw new ArgumentError(
1300 _generateMessage(tagNumber, value, 'not type int')); 1132 _generateMessage(tagNumber, value, 'not type int'));
1301 } 1133 }
1302 if (!_isSigned32(value)) { 1134 if (!_isSigned32(value)) {
1303 throw new ArgumentError(_generateMessage(tagNumber, value, 1135 throw new ArgumentError(_generateMessage(tagNumber, value,
1304 'out of range for sfixed32')); 1136 'out of range for sfixed32'));
1305 } 1137 }
1306 break; 1138 break;
1307 case _SFIXED64_BIT: 1139 case FieldType._SFIXED64_BIT:
1308 if (value is !Int64) { 1140 if (value is !Int64) {
1309 throw new ArgumentError( 1141 throw new ArgumentError(
1310 _generateMessage(tagNumber, value, 'not Int64')); 1142 _generateMessage(tagNumber, value, 'not Int64'));
1311 } 1143 }
1312 if (!_isSigned64(value)) { 1144 if (!_isSigned64(value)) {
1313 throw new ArgumentError(_generateMessage(tagNumber, value, 1145 throw new ArgumentError(_generateMessage(tagNumber, value,
1314 'out of range for sfixed64')); 1146 'out of range for sfixed64'));
1315 } 1147 }
1316 break; 1148 break;
1317 case _GROUP_BIT: 1149 case FieldType._GROUP_BIT:
1318 case _MESSAGE_BIT: 1150 case FieldType._MESSAGE_BIT:
1319 if (value is !GeneratedMessage) { 1151 if (value is !GeneratedMessage) {
1320 throw new ArgumentError( 1152 throw new ArgumentError(
1321 _generateMessage(tagNumber, value, 'not a GeneratedMessage')); 1153 _generateMessage(tagNumber, value, 'not a GeneratedMessage'));
1322 } 1154 }
1323 break; 1155 break;
1324 default: 1156 default:
1325 throw new ArgumentError( 1157 throw new ArgumentError(
1326 _generateMessage(tagNumber, value, 'field has unknown type ' 1158 _generateMessage(tagNumber, value, 'field has unknown type '
1327 '$fieldType')); 1159 '$fieldType'));
1328 } 1160 }
1329 } 1161 }
1330 } 1162 }
OLDNEW
« no previous file with comments | « lib/src/protobuf/field_type.dart ('k') | lib/src/protobuf/unknown_field_set.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698