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

Side by Side Diff: sdk/lib/svg/dartium/svg_dartium.dart

Issue 12295009: Recommit changing List.skip/take/revert returns Iterable and remove mappedBy. (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Make Future.wait simpler. Created 7 years, 10 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 | Annotate | Revision Log
OLDNEW
1 library dart.dom.svg; 1 library dart.dom.svg;
2 2
3 import 'dart:async'; 3 import 'dart:async';
4 import 'dart:collection'; 4 import 'dart:collection';
5 import 'dart:html'; 5 import 'dart:html';
6 import 'dart:html_common'; 6 import 'dart:html_common';
7 import 'dart:nativewrappers'; 7 import 'dart:nativewrappers';
8 // DO NOT EDIT 8 // DO NOT EDIT
9 // Auto-generated dart:svg library. 9 // Auto-generated dart:svg library.
10 10
(...skipping 3328 matching lines...) Expand 10 before | Expand all | Expand 10 after
3339 bool contains(Length element) => IterableMixinWorkaround.contains(this, elemen t); 3339 bool contains(Length element) => IterableMixinWorkaround.contains(this, elemen t);
3340 3340
3341 void forEach(void f(Length element)) => IterableMixinWorkaround.forEach(this, f); 3341 void forEach(void f(Length element)) => IterableMixinWorkaround.forEach(this, f);
3342 3342
3343 String join([String separator]) => 3343 String join([String separator]) =>
3344 IterableMixinWorkaround.joinList(this, separator); 3344 IterableMixinWorkaround.joinList(this, separator);
3345 3345
3346 Iterable map(f(Length element)) => 3346 Iterable map(f(Length element)) =>
3347 IterableMixinWorkaround.mapList(this, f); 3347 IterableMixinWorkaround.mapList(this, f);
3348 3348
3349 List mappedBy(f(Length element)) =>
3350 IterableMixinWorkaround.mappedByList(this, f);
3351
3352 Iterable<Length> where(bool f(Length element)) => 3349 Iterable<Length> where(bool f(Length element)) =>
3353 IterableMixinWorkaround.where(this, f); 3350 IterableMixinWorkaround.where(this, f);
3354 3351
3355 Iterable expand(Iterable f(Length element)) => 3352 Iterable expand(Iterable f(Length element)) =>
3356 IterableMixinWorkaround.expand(this, f); 3353 IterableMixinWorkaround.expand(this, f);
3357 3354
3358 bool every(bool f(Length element)) => IterableMixinWorkaround.every(this, f); 3355 bool every(bool f(Length element)) => IterableMixinWorkaround.every(this, f);
3359 3356
3360 bool any(bool f(Length element)) => IterableMixinWorkaround.any(this, f); 3357 bool any(bool f(Length element)) => IterableMixinWorkaround.any(this, f);
3361 3358
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
3406 throw new UnsupportedError("Cannot add to immutable List."); 3403 throw new UnsupportedError("Cannot add to immutable List.");
3407 } 3404 }
3408 3405
3409 // From List<Length>: 3406 // From List<Length>:
3410 void set length(int value) { 3407 void set length(int value) {
3411 throw new UnsupportedError("Cannot resize immutable List."); 3408 throw new UnsupportedError("Cannot resize immutable List.");
3412 } 3409 }
3413 3410
3414 // clear() defined by IDL. 3411 // clear() defined by IDL.
3415 3412
3416 List<Length> get reversed { 3413 Iterable<Length> get reversed {
3417 return IterableMixinWorkaround.reversedList(this); 3414 return IterableMixinWorkaround.reversedList(this);
3418 } 3415 }
3419 3416
3420 void sort([int compare(Length a, Length b)]) { 3417 void sort([int compare(Length a, Length b)]) {
3421 throw new UnsupportedError("Cannot sort immutable List."); 3418 throw new UnsupportedError("Cannot sort immutable List.");
3422 } 3419 }
3423 3420
3424 int indexOf(Length element, [int start = 0]) => 3421 int indexOf(Length element, [int start = 0]) =>
3425 Lists.indexOf(this, element, start, this.length); 3422 Lists.indexOf(this, element, start, this.length);
3426 3423
(...skipping 616 matching lines...) Expand 10 before | Expand all | Expand 10 after
4043 bool contains(Number element) => IterableMixinWorkaround.contains(this, elemen t); 4040 bool contains(Number element) => IterableMixinWorkaround.contains(this, elemen t);
4044 4041
4045 void forEach(void f(Number element)) => IterableMixinWorkaround.forEach(this, f); 4042 void forEach(void f(Number element)) => IterableMixinWorkaround.forEach(this, f);
4046 4043
4047 String join([String separator]) => 4044 String join([String separator]) =>
4048 IterableMixinWorkaround.joinList(this, separator); 4045 IterableMixinWorkaround.joinList(this, separator);
4049 4046
4050 Iterable map(f(Number element)) => 4047 Iterable map(f(Number element)) =>
4051 IterableMixinWorkaround.mapList(this, f); 4048 IterableMixinWorkaround.mapList(this, f);
4052 4049
4053 List mappedBy(f(Number element)) =>
4054 IterableMixinWorkaround.mappedByList(this, f);
4055
4056 Iterable<Number> where(bool f(Number element)) => 4050 Iterable<Number> where(bool f(Number element)) =>
4057 IterableMixinWorkaround.where(this, f); 4051 IterableMixinWorkaround.where(this, f);
4058 4052
4059 Iterable expand(Iterable f(Number element)) => 4053 Iterable expand(Iterable f(Number element)) =>
4060 IterableMixinWorkaround.expand(this, f); 4054 IterableMixinWorkaround.expand(this, f);
4061 4055
4062 bool every(bool f(Number element)) => IterableMixinWorkaround.every(this, f); 4056 bool every(bool f(Number element)) => IterableMixinWorkaround.every(this, f);
4063 4057
4064 bool any(bool f(Number element)) => IterableMixinWorkaround.any(this, f); 4058 bool any(bool f(Number element)) => IterableMixinWorkaround.any(this, f);
4065 4059
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
4110 throw new UnsupportedError("Cannot add to immutable List."); 4104 throw new UnsupportedError("Cannot add to immutable List.");
4111 } 4105 }
4112 4106
4113 // From List<Number>: 4107 // From List<Number>:
4114 void set length(int value) { 4108 void set length(int value) {
4115 throw new UnsupportedError("Cannot resize immutable List."); 4109 throw new UnsupportedError("Cannot resize immutable List.");
4116 } 4110 }
4117 4111
4118 // clear() defined by IDL. 4112 // clear() defined by IDL.
4119 4113
4120 List<Number> get reversed { 4114 Iterable<Number> get reversed {
4121 return IterableMixinWorkaround.reversedList(this); 4115 return IterableMixinWorkaround.reversedList(this);
4122 } 4116 }
4123 4117
4124 void sort([int compare(Number a, Number b)]) { 4118 void sort([int compare(Number a, Number b)]) {
4125 throw new UnsupportedError("Cannot sort immutable List."); 4119 throw new UnsupportedError("Cannot sort immutable List.");
4126 } 4120 }
4127 4121
4128 int indexOf(Number element, [int start = 0]) => 4122 int indexOf(Number element, [int start = 0]) =>
4129 Lists.indexOf(this, element, start, this.length); 4123 Lists.indexOf(this, element, start, this.length);
4130 4124
(...skipping 1092 matching lines...) Expand 10 before | Expand all | Expand 10 after
5223 bool contains(PathSeg element) => IterableMixinWorkaround.contains(this, eleme nt); 5217 bool contains(PathSeg element) => IterableMixinWorkaround.contains(this, eleme nt);
5224 5218
5225 void forEach(void f(PathSeg element)) => IterableMixinWorkaround.forEach(this, f); 5219 void forEach(void f(PathSeg element)) => IterableMixinWorkaround.forEach(this, f);
5226 5220
5227 String join([String separator]) => 5221 String join([String separator]) =>
5228 IterableMixinWorkaround.joinList(this, separator); 5222 IterableMixinWorkaround.joinList(this, separator);
5229 5223
5230 Iterable map(f(PathSeg element)) => 5224 Iterable map(f(PathSeg element)) =>
5231 IterableMixinWorkaround.mapList(this, f); 5225 IterableMixinWorkaround.mapList(this, f);
5232 5226
5233 List mappedBy(f(PathSeg element)) =>
5234 IterableMixinWorkaround.mappedByList(this, f);
5235
5236 Iterable<PathSeg> where(bool f(PathSeg element)) => 5227 Iterable<PathSeg> where(bool f(PathSeg element)) =>
5237 IterableMixinWorkaround.where(this, f); 5228 IterableMixinWorkaround.where(this, f);
5238 5229
5239 Iterable expand(Iterable f(PathSeg element)) => 5230 Iterable expand(Iterable f(PathSeg element)) =>
5240 IterableMixinWorkaround.expand(this, f); 5231 IterableMixinWorkaround.expand(this, f);
5241 5232
5242 bool every(bool f(PathSeg element)) => IterableMixinWorkaround.every(this, f); 5233 bool every(bool f(PathSeg element)) => IterableMixinWorkaround.every(this, f);
5243 5234
5244 bool any(bool f(PathSeg element)) => IterableMixinWorkaround.any(this, f); 5235 bool any(bool f(PathSeg element)) => IterableMixinWorkaround.any(this, f);
5245 5236
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
5290 throw new UnsupportedError("Cannot add to immutable List."); 5281 throw new UnsupportedError("Cannot add to immutable List.");
5291 } 5282 }
5292 5283
5293 // From List<PathSeg>: 5284 // From List<PathSeg>:
5294 void set length(int value) { 5285 void set length(int value) {
5295 throw new UnsupportedError("Cannot resize immutable List."); 5286 throw new UnsupportedError("Cannot resize immutable List.");
5296 } 5287 }
5297 5288
5298 // clear() defined by IDL. 5289 // clear() defined by IDL.
5299 5290
5300 List<PathSeg> get reversed { 5291 Iterable<PathSeg> get reversed {
5301 return IterableMixinWorkaround.reversedList(this); 5292 return IterableMixinWorkaround.reversedList(this);
5302 } 5293 }
5303 5294
5304 void sort([int compare(PathSeg a, PathSeg b)]) { 5295 void sort([int compare(PathSeg a, PathSeg b)]) {
5305 throw new UnsupportedError("Cannot sort immutable List."); 5296 throw new UnsupportedError("Cannot sort immutable List.");
5306 } 5297 }
5307 5298
5308 int indexOf(PathSeg element, [int start = 0]) => 5299 int indexOf(PathSeg element, [int start = 0]) =>
5309 Lists.indexOf(this, element, start, this.length); 5300 Lists.indexOf(this, element, start, this.length);
5310 5301
(...skipping 897 matching lines...) Expand 10 before | Expand all | Expand 10 after
6208 bool contains(String element) => IterableMixinWorkaround.contains(this, elemen t); 6199 bool contains(String element) => IterableMixinWorkaround.contains(this, elemen t);
6209 6200
6210 void forEach(void f(String element)) => IterableMixinWorkaround.forEach(this, f); 6201 void forEach(void f(String element)) => IterableMixinWorkaround.forEach(this, f);
6211 6202
6212 String join([String separator]) => 6203 String join([String separator]) =>
6213 IterableMixinWorkaround.joinList(this, separator); 6204 IterableMixinWorkaround.joinList(this, separator);
6214 6205
6215 Iterable map(f(String element)) => 6206 Iterable map(f(String element)) =>
6216 IterableMixinWorkaround.mapList(this, f); 6207 IterableMixinWorkaround.mapList(this, f);
6217 6208
6218 List mappedBy(f(String element)) =>
6219 IterableMixinWorkaround.mappedByList(this, f);
6220
6221 Iterable<String> where(bool f(String element)) => 6209 Iterable<String> where(bool f(String element)) =>
6222 IterableMixinWorkaround.where(this, f); 6210 IterableMixinWorkaround.where(this, f);
6223 6211
6224 Iterable expand(Iterable f(String element)) => 6212 Iterable expand(Iterable f(String element)) =>
6225 IterableMixinWorkaround.expand(this, f); 6213 IterableMixinWorkaround.expand(this, f);
6226 6214
6227 bool every(bool f(String element)) => IterableMixinWorkaround.every(this, f); 6215 bool every(bool f(String element)) => IterableMixinWorkaround.every(this, f);
6228 6216
6229 bool any(bool f(String element)) => IterableMixinWorkaround.any(this, f); 6217 bool any(bool f(String element)) => IterableMixinWorkaround.any(this, f);
6230 6218
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
6275 throw new UnsupportedError("Cannot add to immutable List."); 6263 throw new UnsupportedError("Cannot add to immutable List.");
6276 } 6264 }
6277 6265
6278 // From List<String>: 6266 // From List<String>:
6279 void set length(int value) { 6267 void set length(int value) {
6280 throw new UnsupportedError("Cannot resize immutable List."); 6268 throw new UnsupportedError("Cannot resize immutable List.");
6281 } 6269 }
6282 6270
6283 // clear() defined by IDL. 6271 // clear() defined by IDL.
6284 6272
6285 List<String> get reversed { 6273 Iterable<String> get reversed {
6286 return IterableMixinWorkaround.reversedList(this); 6274 return IterableMixinWorkaround.reversedList(this);
6287 } 6275 }
6288 6276
6289 void sort([int compare(String a, String b)]) { 6277 void sort([int compare(String a, String b)]) {
6290 throw new UnsupportedError("Cannot sort immutable List."); 6278 throw new UnsupportedError("Cannot sort immutable List.");
6291 } 6279 }
6292 6280
6293 int indexOf(String element, [int start = 0]) => 6281 int indexOf(String element, [int start = 0]) =>
6294 Lists.indexOf(this, element, start, this.length); 6282 Lists.indexOf(this, element, start, this.length);
6295 6283
(...skipping 1167 matching lines...) Expand 10 before | Expand all | Expand 10 after
7463 bool contains(Transform element) => IterableMixinWorkaround.contains(this, ele ment); 7451 bool contains(Transform element) => IterableMixinWorkaround.contains(this, ele ment);
7464 7452
7465 void forEach(void f(Transform element)) => IterableMixinWorkaround.forEach(thi s, f); 7453 void forEach(void f(Transform element)) => IterableMixinWorkaround.forEach(thi s, f);
7466 7454
7467 String join([String separator]) => 7455 String join([String separator]) =>
7468 IterableMixinWorkaround.joinList(this, separator); 7456 IterableMixinWorkaround.joinList(this, separator);
7469 7457
7470 Iterable map(f(Transform element)) => 7458 Iterable map(f(Transform element)) =>
7471 IterableMixinWorkaround.mapList(this, f); 7459 IterableMixinWorkaround.mapList(this, f);
7472 7460
7473 List mappedBy(f(Transform element)) =>
7474 IterableMixinWorkaround.mappedByList(this, f);
7475
7476 Iterable<Transform> where(bool f(Transform element)) => 7461 Iterable<Transform> where(bool f(Transform element)) =>
7477 IterableMixinWorkaround.where(this, f); 7462 IterableMixinWorkaround.where(this, f);
7478 7463
7479 Iterable expand(Iterable f(Transform element)) => 7464 Iterable expand(Iterable f(Transform element)) =>
7480 IterableMixinWorkaround.expand(this, f); 7465 IterableMixinWorkaround.expand(this, f);
7481 7466
7482 bool every(bool f(Transform element)) => IterableMixinWorkaround.every(this, f ); 7467 bool every(bool f(Transform element)) => IterableMixinWorkaround.every(this, f );
7483 7468
7484 bool any(bool f(Transform element)) => IterableMixinWorkaround.any(this, f); 7469 bool any(bool f(Transform element)) => IterableMixinWorkaround.any(this, f);
7485 7470
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
7530 throw new UnsupportedError("Cannot add to immutable List."); 7515 throw new UnsupportedError("Cannot add to immutable List.");
7531 } 7516 }
7532 7517
7533 // From List<Transform>: 7518 // From List<Transform>:
7534 void set length(int value) { 7519 void set length(int value) {
7535 throw new UnsupportedError("Cannot resize immutable List."); 7520 throw new UnsupportedError("Cannot resize immutable List.");
7536 } 7521 }
7537 7522
7538 // clear() defined by IDL. 7523 // clear() defined by IDL.
7539 7524
7540 List<Transform> get reversed { 7525 Iterable<Transform> get reversed {
7541 return IterableMixinWorkaround.reversedList(this); 7526 return IterableMixinWorkaround.reversedList(this);
7542 } 7527 }
7543 7528
7544 void sort([int compare(Transform a, Transform b)]) { 7529 void sort([int compare(Transform a, Transform b)]) {
7545 throw new UnsupportedError("Cannot sort immutable List."); 7530 throw new UnsupportedError("Cannot sort immutable List.");
7546 } 7531 }
7547 7532
7548 int indexOf(Transform element, [int start = 0]) => 7533 int indexOf(Transform element, [int start = 0]) =>
7549 Lists.indexOf(this, element, start, this.length); 7534 Lists.indexOf(this, element, start, this.length);
7550 7535
(...skipping 486 matching lines...) Expand 10 before | Expand all | Expand 10 after
8037 bool contains(ElementInstance element) => IterableMixinWorkaround.contains(thi s, element); 8022 bool contains(ElementInstance element) => IterableMixinWorkaround.contains(thi s, element);
8038 8023
8039 void forEach(void f(ElementInstance element)) => IterableMixinWorkaround.forEa ch(this, f); 8024 void forEach(void f(ElementInstance element)) => IterableMixinWorkaround.forEa ch(this, f);
8040 8025
8041 String join([String separator]) => 8026 String join([String separator]) =>
8042 IterableMixinWorkaround.joinList(this, separator); 8027 IterableMixinWorkaround.joinList(this, separator);
8043 8028
8044 Iterable map(f(ElementInstance element)) => 8029 Iterable map(f(ElementInstance element)) =>
8045 IterableMixinWorkaround.mapList(this, f); 8030 IterableMixinWorkaround.mapList(this, f);
8046 8031
8047 List mappedBy(f(ElementInstance element)) =>
8048 IterableMixinWorkaround.mappedByList(this, f);
8049
8050 Iterable<ElementInstance> where(bool f(ElementInstance element)) => 8032 Iterable<ElementInstance> where(bool f(ElementInstance element)) =>
8051 IterableMixinWorkaround.where(this, f); 8033 IterableMixinWorkaround.where(this, f);
8052 8034
8053 Iterable expand(Iterable f(ElementInstance element)) => 8035 Iterable expand(Iterable f(ElementInstance element)) =>
8054 IterableMixinWorkaround.expand(this, f); 8036 IterableMixinWorkaround.expand(this, f);
8055 8037
8056 bool every(bool f(ElementInstance element)) => IterableMixinWorkaround.every(t his, f); 8038 bool every(bool f(ElementInstance element)) => IterableMixinWorkaround.every(t his, f);
8057 8039
8058 bool any(bool f(ElementInstance element)) => IterableMixinWorkaround.any(this, f); 8040 bool any(bool f(ElementInstance element)) => IterableMixinWorkaround.any(this, f);
8059 8041
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after
8106 8088
8107 // From List<ElementInstance>: 8089 // From List<ElementInstance>:
8108 void set length(int value) { 8090 void set length(int value) {
8109 throw new UnsupportedError("Cannot resize immutable List."); 8091 throw new UnsupportedError("Cannot resize immutable List.");
8110 } 8092 }
8111 8093
8112 void clear() { 8094 void clear() {
8113 throw new UnsupportedError("Cannot clear immutable List."); 8095 throw new UnsupportedError("Cannot clear immutable List.");
8114 } 8096 }
8115 8097
8116 List<ElementInstance> get reversed { 8098 Iterable<ElementInstance> get reversed {
8117 return IterableMixinWorkaround.reversedList(this); 8099 return IterableMixinWorkaround.reversedList(this);
8118 } 8100 }
8119 8101
8120 void sort([int compare(ElementInstance a, ElementInstance b)]) { 8102 void sort([int compare(ElementInstance a, ElementInstance b)]) {
8121 throw new UnsupportedError("Cannot sort immutable List."); 8103 throw new UnsupportedError("Cannot sort immutable List.");
8122 } 8104 }
8123 8105
8124 int indexOf(ElementInstance element, [int start = 0]) => 8106 int indexOf(ElementInstance element, [int start = 0]) =>
8125 Lists.indexOf(this, element, start, this.length); 8107 Lists.indexOf(this, element, start, this.length);
8126 8108
(...skipping 562 matching lines...) Expand 10 before | Expand all | Expand 10 after
8689 @DocsEditable 8671 @DocsEditable
8690 @DomName('SVGVKernElement') 8672 @DomName('SVGVKernElement')
8691 class _SVGVKernElement extends SvgElement { 8673 class _SVGVKernElement extends SvgElement {
8692 _SVGVKernElement.internal() : super.internal(); 8674 _SVGVKernElement.internal() : super.internal();
8693 8675
8694 @DomName('SVGVKernElement.SVGVKernElement') 8676 @DomName('SVGVKernElement.SVGVKernElement')
8695 @DocsEditable 8677 @DocsEditable
8696 factory _SVGVKernElement() => _SvgElementFactoryProvider.createSvgElement_tag( "vkern"); 8678 factory _SVGVKernElement() => _SvgElementFactoryProvider.createSvgElement_tag( "vkern");
8697 8679
8698 } 8680 }
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698