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

Side by Side Diff: sdk/lib/svg/dart2js/svg_dart2js.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:_js_helper' show Creates, Returns, JavaScriptIndexingBehavior, JSNa me; 7 import 'dart:_js_helper' show Creates, Returns, JavaScriptIndexingBehavior, JSNa me;
8 import 'dart:_foreign_helper' show JS; 8 import 'dart:_foreign_helper' show JS;
9 // DO NOT EDIT 9 // DO NOT EDIT
10 // Auto-generated dart:svg library. 10 // Auto-generated dart:svg library.
(...skipping 3064 matching lines...) Expand 10 before | Expand all | Expand 10 after
3075 bool contains(Length element) => IterableMixinWorkaround.contains(this, elemen t); 3075 bool contains(Length element) => IterableMixinWorkaround.contains(this, elemen t);
3076 3076
3077 void forEach(void f(Length element)) => IterableMixinWorkaround.forEach(this, f); 3077 void forEach(void f(Length element)) => IterableMixinWorkaround.forEach(this, f);
3078 3078
3079 String join([String separator]) => 3079 String join([String separator]) =>
3080 IterableMixinWorkaround.joinList(this, separator); 3080 IterableMixinWorkaround.joinList(this, separator);
3081 3081
3082 Iterable map(f(Length element)) => 3082 Iterable map(f(Length element)) =>
3083 IterableMixinWorkaround.mapList(this, f); 3083 IterableMixinWorkaround.mapList(this, f);
3084 3084
3085 List mappedBy(f(Length element)) =>
3086 IterableMixinWorkaround.mappedByList(this, f);
3087
3088 Iterable<Length> where(bool f(Length element)) => 3085 Iterable<Length> where(bool f(Length element)) =>
3089 IterableMixinWorkaround.where(this, f); 3086 IterableMixinWorkaround.where(this, f);
3090 3087
3091 Iterable expand(Iterable f(Length element)) => 3088 Iterable expand(Iterable f(Length element)) =>
3092 IterableMixinWorkaround.expand(this, f); 3089 IterableMixinWorkaround.expand(this, f);
3093 3090
3094 bool every(bool f(Length element)) => IterableMixinWorkaround.every(this, f); 3091 bool every(bool f(Length element)) => IterableMixinWorkaround.every(this, f);
3095 3092
3096 bool any(bool f(Length element)) => IterableMixinWorkaround.any(this, f); 3093 bool any(bool f(Length element)) => IterableMixinWorkaround.any(this, f);
3097 3094
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
3142 throw new UnsupportedError("Cannot add to immutable List."); 3139 throw new UnsupportedError("Cannot add to immutable List.");
3143 } 3140 }
3144 3141
3145 // From List<Length>: 3142 // From List<Length>:
3146 void set length(int value) { 3143 void set length(int value) {
3147 throw new UnsupportedError("Cannot resize immutable List."); 3144 throw new UnsupportedError("Cannot resize immutable List.");
3148 } 3145 }
3149 3146
3150 // clear() defined by IDL. 3147 // clear() defined by IDL.
3151 3148
3152 List<Length> get reversed { 3149 Iterable<Length> get reversed {
3153 return IterableMixinWorkaround.reversedList(this); 3150 return IterableMixinWorkaround.reversedList(this);
3154 } 3151 }
3155 3152
3156 void sort([int compare(Length a, Length b)]) { 3153 void sort([int compare(Length a, Length b)]) {
3157 throw new UnsupportedError("Cannot sort immutable List."); 3154 throw new UnsupportedError("Cannot sort immutable List.");
3158 } 3155 }
3159 3156
3160 int indexOf(Length element, [int start = 0]) => 3157 int indexOf(Length element, [int start = 0]) =>
3161 Lists.indexOf(this, element, start, this.length); 3158 Lists.indexOf(this, element, start, this.length);
3162 3159
(...skipping 539 matching lines...) Expand 10 before | Expand all | Expand 10 after
3702 bool contains(Number element) => IterableMixinWorkaround.contains(this, elemen t); 3699 bool contains(Number element) => IterableMixinWorkaround.contains(this, elemen t);
3703 3700
3704 void forEach(void f(Number element)) => IterableMixinWorkaround.forEach(this, f); 3701 void forEach(void f(Number element)) => IterableMixinWorkaround.forEach(this, f);
3705 3702
3706 String join([String separator]) => 3703 String join([String separator]) =>
3707 IterableMixinWorkaround.joinList(this, separator); 3704 IterableMixinWorkaround.joinList(this, separator);
3708 3705
3709 Iterable map(f(Number element)) => 3706 Iterable map(f(Number element)) =>
3710 IterableMixinWorkaround.mapList(this, f); 3707 IterableMixinWorkaround.mapList(this, f);
3711 3708
3712 List mappedBy(f(Number element)) =>
3713 IterableMixinWorkaround.mappedByList(this, f);
3714
3715 Iterable<Number> where(bool f(Number element)) => 3709 Iterable<Number> where(bool f(Number element)) =>
3716 IterableMixinWorkaround.where(this, f); 3710 IterableMixinWorkaround.where(this, f);
3717 3711
3718 Iterable expand(Iterable f(Number element)) => 3712 Iterable expand(Iterable f(Number element)) =>
3719 IterableMixinWorkaround.expand(this, f); 3713 IterableMixinWorkaround.expand(this, f);
3720 3714
3721 bool every(bool f(Number element)) => IterableMixinWorkaround.every(this, f); 3715 bool every(bool f(Number element)) => IterableMixinWorkaround.every(this, f);
3722 3716
3723 bool any(bool f(Number element)) => IterableMixinWorkaround.any(this, f); 3717 bool any(bool f(Number element)) => IterableMixinWorkaround.any(this, f);
3724 3718
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
3769 throw new UnsupportedError("Cannot add to immutable List."); 3763 throw new UnsupportedError("Cannot add to immutable List.");
3770 } 3764 }
3771 3765
3772 // From List<Number>: 3766 // From List<Number>:
3773 void set length(int value) { 3767 void set length(int value) {
3774 throw new UnsupportedError("Cannot resize immutable List."); 3768 throw new UnsupportedError("Cannot resize immutable List.");
3775 } 3769 }
3776 3770
3777 // clear() defined by IDL. 3771 // clear() defined by IDL.
3778 3772
3779 List<Number> get reversed { 3773 Iterable<Number> get reversed {
3780 return IterableMixinWorkaround.reversedList(this); 3774 return IterableMixinWorkaround.reversedList(this);
3781 } 3775 }
3782 3776
3783 void sort([int compare(Number a, Number b)]) { 3777 void sort([int compare(Number a, Number b)]) {
3784 throw new UnsupportedError("Cannot sort immutable List."); 3778 throw new UnsupportedError("Cannot sort immutable List.");
3785 } 3779 }
3786 3780
3787 int indexOf(Number element, [int start = 0]) => 3781 int indexOf(Number element, [int start = 0]) =>
3788 Lists.indexOf(this, element, start, this.length); 3782 Lists.indexOf(this, element, start, this.length);
3789 3783
(...skipping 815 matching lines...) Expand 10 before | Expand all | Expand 10 after
4605 bool contains(PathSeg element) => IterableMixinWorkaround.contains(this, eleme nt); 4599 bool contains(PathSeg element) => IterableMixinWorkaround.contains(this, eleme nt);
4606 4600
4607 void forEach(void f(PathSeg element)) => IterableMixinWorkaround.forEach(this, f); 4601 void forEach(void f(PathSeg element)) => IterableMixinWorkaround.forEach(this, f);
4608 4602
4609 String join([String separator]) => 4603 String join([String separator]) =>
4610 IterableMixinWorkaround.joinList(this, separator); 4604 IterableMixinWorkaround.joinList(this, separator);
4611 4605
4612 Iterable map(f(PathSeg element)) => 4606 Iterable map(f(PathSeg element)) =>
4613 IterableMixinWorkaround.mapList(this, f); 4607 IterableMixinWorkaround.mapList(this, f);
4614 4608
4615 List mappedBy(f(PathSeg element)) =>
4616 IterableMixinWorkaround.mappedByList(this, f);
4617
4618 Iterable<PathSeg> where(bool f(PathSeg element)) => 4609 Iterable<PathSeg> where(bool f(PathSeg element)) =>
4619 IterableMixinWorkaround.where(this, f); 4610 IterableMixinWorkaround.where(this, f);
4620 4611
4621 Iterable expand(Iterable f(PathSeg element)) => 4612 Iterable expand(Iterable f(PathSeg element)) =>
4622 IterableMixinWorkaround.expand(this, f); 4613 IterableMixinWorkaround.expand(this, f);
4623 4614
4624 bool every(bool f(PathSeg element)) => IterableMixinWorkaround.every(this, f); 4615 bool every(bool f(PathSeg element)) => IterableMixinWorkaround.every(this, f);
4625 4616
4626 bool any(bool f(PathSeg element)) => IterableMixinWorkaround.any(this, f); 4617 bool any(bool f(PathSeg element)) => IterableMixinWorkaround.any(this, f);
4627 4618
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
4672 throw new UnsupportedError("Cannot add to immutable List."); 4663 throw new UnsupportedError("Cannot add to immutable List.");
4673 } 4664 }
4674 4665
4675 // From List<PathSeg>: 4666 // From List<PathSeg>:
4676 void set length(int value) { 4667 void set length(int value) {
4677 throw new UnsupportedError("Cannot resize immutable List."); 4668 throw new UnsupportedError("Cannot resize immutable List.");
4678 } 4669 }
4679 4670
4680 // clear() defined by IDL. 4671 // clear() defined by IDL.
4681 4672
4682 List<PathSeg> get reversed { 4673 Iterable<PathSeg> get reversed {
4683 return IterableMixinWorkaround.reversedList(this); 4674 return IterableMixinWorkaround.reversedList(this);
4684 } 4675 }
4685 4676
4686 void sort([int compare(PathSeg a, PathSeg b)]) { 4677 void sort([int compare(PathSeg a, PathSeg b)]) {
4687 throw new UnsupportedError("Cannot sort immutable List."); 4678 throw new UnsupportedError("Cannot sort immutable List.");
4688 } 4679 }
4689 4680
4690 int indexOf(PathSeg element, [int start = 0]) => 4681 int indexOf(PathSeg element, [int start = 0]) =>
4691 Lists.indexOf(this, element, start, this.length); 4682 Lists.indexOf(this, element, start, this.length);
4692 4683
(...skipping 799 matching lines...) Expand 10 before | Expand all | Expand 10 after
5492 bool contains(String element) => IterableMixinWorkaround.contains(this, elemen t); 5483 bool contains(String element) => IterableMixinWorkaround.contains(this, elemen t);
5493 5484
5494 void forEach(void f(String element)) => IterableMixinWorkaround.forEach(this, f); 5485 void forEach(void f(String element)) => IterableMixinWorkaround.forEach(this, f);
5495 5486
5496 String join([String separator]) => 5487 String join([String separator]) =>
5497 IterableMixinWorkaround.joinList(this, separator); 5488 IterableMixinWorkaround.joinList(this, separator);
5498 5489
5499 Iterable map(f(String element)) => 5490 Iterable map(f(String element)) =>
5500 IterableMixinWorkaround.mapList(this, f); 5491 IterableMixinWorkaround.mapList(this, f);
5501 5492
5502 List mappedBy(f(String element)) =>
5503 IterableMixinWorkaround.mappedByList(this, f);
5504
5505 Iterable<String> where(bool f(String element)) => 5493 Iterable<String> where(bool f(String element)) =>
5506 IterableMixinWorkaround.where(this, f); 5494 IterableMixinWorkaround.where(this, f);
5507 5495
5508 Iterable expand(Iterable f(String element)) => 5496 Iterable expand(Iterable f(String element)) =>
5509 IterableMixinWorkaround.expand(this, f); 5497 IterableMixinWorkaround.expand(this, f);
5510 5498
5511 bool every(bool f(String element)) => IterableMixinWorkaround.every(this, f); 5499 bool every(bool f(String element)) => IterableMixinWorkaround.every(this, f);
5512 5500
5513 bool any(bool f(String element)) => IterableMixinWorkaround.any(this, f); 5501 bool any(bool f(String element)) => IterableMixinWorkaround.any(this, f);
5514 5502
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
5559 throw new UnsupportedError("Cannot add to immutable List."); 5547 throw new UnsupportedError("Cannot add to immutable List.");
5560 } 5548 }
5561 5549
5562 // From List<String>: 5550 // From List<String>:
5563 void set length(int value) { 5551 void set length(int value) {
5564 throw new UnsupportedError("Cannot resize immutable List."); 5552 throw new UnsupportedError("Cannot resize immutable List.");
5565 } 5553 }
5566 5554
5567 // clear() defined by IDL. 5555 // clear() defined by IDL.
5568 5556
5569 List<String> get reversed { 5557 Iterable<String> get reversed {
5570 return IterableMixinWorkaround.reversedList(this); 5558 return IterableMixinWorkaround.reversedList(this);
5571 } 5559 }
5572 5560
5573 void sort([int compare(String a, String b)]) { 5561 void sort([int compare(String a, String b)]) {
5574 throw new UnsupportedError("Cannot sort immutable List."); 5562 throw new UnsupportedError("Cannot sort immutable List.");
5575 } 5563 }
5576 5564
5577 int indexOf(String element, [int start = 0]) => 5565 int indexOf(String element, [int start = 0]) =>
5578 Lists.indexOf(this, element, start, this.length); 5566 Lists.indexOf(this, element, start, this.length);
5579 5567
(...skipping 1078 matching lines...) Expand 10 before | Expand all | Expand 10 after
6658 bool contains(Transform element) => IterableMixinWorkaround.contains(this, ele ment); 6646 bool contains(Transform element) => IterableMixinWorkaround.contains(this, ele ment);
6659 6647
6660 void forEach(void f(Transform element)) => IterableMixinWorkaround.forEach(thi s, f); 6648 void forEach(void f(Transform element)) => IterableMixinWorkaround.forEach(thi s, f);
6661 6649
6662 String join([String separator]) => 6650 String join([String separator]) =>
6663 IterableMixinWorkaround.joinList(this, separator); 6651 IterableMixinWorkaround.joinList(this, separator);
6664 6652
6665 Iterable map(f(Transform element)) => 6653 Iterable map(f(Transform element)) =>
6666 IterableMixinWorkaround.mapList(this, f); 6654 IterableMixinWorkaround.mapList(this, f);
6667 6655
6668 List mappedBy(f(Transform element)) =>
6669 IterableMixinWorkaround.mappedByList(this, f);
6670
6671 Iterable<Transform> where(bool f(Transform element)) => 6656 Iterable<Transform> where(bool f(Transform element)) =>
6672 IterableMixinWorkaround.where(this, f); 6657 IterableMixinWorkaround.where(this, f);
6673 6658
6674 Iterable expand(Iterable f(Transform element)) => 6659 Iterable expand(Iterable f(Transform element)) =>
6675 IterableMixinWorkaround.expand(this, f); 6660 IterableMixinWorkaround.expand(this, f);
6676 6661
6677 bool every(bool f(Transform element)) => IterableMixinWorkaround.every(this, f ); 6662 bool every(bool f(Transform element)) => IterableMixinWorkaround.every(this, f );
6678 6663
6679 bool any(bool f(Transform element)) => IterableMixinWorkaround.any(this, f); 6664 bool any(bool f(Transform element)) => IterableMixinWorkaround.any(this, f);
6680 6665
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
6725 throw new UnsupportedError("Cannot add to immutable List."); 6710 throw new UnsupportedError("Cannot add to immutable List.");
6726 } 6711 }
6727 6712
6728 // From List<Transform>: 6713 // From List<Transform>:
6729 void set length(int value) { 6714 void set length(int value) {
6730 throw new UnsupportedError("Cannot resize immutable List."); 6715 throw new UnsupportedError("Cannot resize immutable List.");
6731 } 6716 }
6732 6717
6733 // clear() defined by IDL. 6718 // clear() defined by IDL.
6734 6719
6735 List<Transform> get reversed { 6720 Iterable<Transform> get reversed {
6736 return IterableMixinWorkaround.reversedList(this); 6721 return IterableMixinWorkaround.reversedList(this);
6737 } 6722 }
6738 6723
6739 void sort([int compare(Transform a, Transform b)]) { 6724 void sort([int compare(Transform a, Transform b)]) {
6740 throw new UnsupportedError("Cannot sort immutable List."); 6725 throw new UnsupportedError("Cannot sort immutable List.");
6741 } 6726 }
6742 6727
6743 int indexOf(Transform element, [int start = 0]) => 6728 int indexOf(Transform element, [int start = 0]) =>
6744 Lists.indexOf(this, element, start, this.length); 6729 Lists.indexOf(this, element, start, this.length);
6745 6730
(...skipping 432 matching lines...) Expand 10 before | Expand all | Expand 10 after
7178 bool contains(ElementInstance element) => IterableMixinWorkaround.contains(thi s, element); 7163 bool contains(ElementInstance element) => IterableMixinWorkaround.contains(thi s, element);
7179 7164
7180 void forEach(void f(ElementInstance element)) => IterableMixinWorkaround.forEa ch(this, f); 7165 void forEach(void f(ElementInstance element)) => IterableMixinWorkaround.forEa ch(this, f);
7181 7166
7182 String join([String separator]) => 7167 String join([String separator]) =>
7183 IterableMixinWorkaround.joinList(this, separator); 7168 IterableMixinWorkaround.joinList(this, separator);
7184 7169
7185 Iterable map(f(ElementInstance element)) => 7170 Iterable map(f(ElementInstance element)) =>
7186 IterableMixinWorkaround.mapList(this, f); 7171 IterableMixinWorkaround.mapList(this, f);
7187 7172
7188 List mappedBy(f(ElementInstance element)) =>
7189 IterableMixinWorkaround.mappedByList(this, f);
7190
7191 Iterable<ElementInstance> where(bool f(ElementInstance element)) => 7173 Iterable<ElementInstance> where(bool f(ElementInstance element)) =>
7192 IterableMixinWorkaround.where(this, f); 7174 IterableMixinWorkaround.where(this, f);
7193 7175
7194 Iterable expand(Iterable f(ElementInstance element)) => 7176 Iterable expand(Iterable f(ElementInstance element)) =>
7195 IterableMixinWorkaround.expand(this, f); 7177 IterableMixinWorkaround.expand(this, f);
7196 7178
7197 bool every(bool f(ElementInstance element)) => IterableMixinWorkaround.every(t his, f); 7179 bool every(bool f(ElementInstance element)) => IterableMixinWorkaround.every(t his, f);
7198 7180
7199 bool any(bool f(ElementInstance element)) => IterableMixinWorkaround.any(this, f); 7181 bool any(bool f(ElementInstance element)) => IterableMixinWorkaround.any(this, f);
7200 7182
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after
7247 7229
7248 // From List<ElementInstance>: 7230 // From List<ElementInstance>:
7249 void set length(int value) { 7231 void set length(int value) {
7250 throw new UnsupportedError("Cannot resize immutable List."); 7232 throw new UnsupportedError("Cannot resize immutable List.");
7251 } 7233 }
7252 7234
7253 void clear() { 7235 void clear() {
7254 throw new UnsupportedError("Cannot clear immutable List."); 7236 throw new UnsupportedError("Cannot clear immutable List.");
7255 } 7237 }
7256 7238
7257 List<ElementInstance> get reversed { 7239 Iterable<ElementInstance> get reversed {
7258 return IterableMixinWorkaround.reversedList(this); 7240 return IterableMixinWorkaround.reversedList(this);
7259 } 7241 }
7260 7242
7261 void sort([int compare(ElementInstance a, ElementInstance b)]) { 7243 void sort([int compare(ElementInstance a, ElementInstance b)]) {
7262 throw new UnsupportedError("Cannot sort immutable List."); 7244 throw new UnsupportedError("Cannot sort immutable List.");
7263 } 7245 }
7264 7246
7265 int indexOf(ElementInstance element, [int start = 0]) => 7247 int indexOf(ElementInstance element, [int start = 0]) =>
7266 Lists.indexOf(this, element, start, this.length); 7248 Lists.indexOf(this, element, start, this.length);
7267 7249
(...skipping 477 matching lines...) Expand 10 before | Expand all | Expand 10 after
7745 7727
7746 7728
7747 @DocsEditable 7729 @DocsEditable
7748 @DomName('SVGVKernElement') 7730 @DomName('SVGVKernElement')
7749 class _SVGVKernElement extends SvgElement native "*SVGVKernElement" { 7731 class _SVGVKernElement extends SvgElement native "*SVGVKernElement" {
7750 7732
7751 @DomName('SVGVKernElement.SVGVKernElement') 7733 @DomName('SVGVKernElement.SVGVKernElement')
7752 @DocsEditable 7734 @DocsEditable
7753 factory _SVGVKernElement() => _SvgElementFactoryProvider.createSvgElement_tag( "vkern"); 7735 factory _SVGVKernElement() => _SvgElementFactoryProvider.createSvgElement_tag( "vkern");
7754 } 7736 }
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698