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

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

Issue 12086062: Rename mappedBy to map. (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: 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 svg; 1 library 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 3945 matching lines...) Expand 10 before | Expand all | Expand 10 after
3956 return IterableMixinWorkaround.reduce(this, initialValue, combine); 3956 return IterableMixinWorkaround.reduce(this, initialValue, combine);
3957 } 3957 }
3958 3958
3959 bool contains(Length element) => IterableMixinWorkaround.contains(this, elemen t); 3959 bool contains(Length element) => IterableMixinWorkaround.contains(this, elemen t);
3960 3960
3961 void forEach(void f(Length element)) => IterableMixinWorkaround.forEach(this, f); 3961 void forEach(void f(Length element)) => IterableMixinWorkaround.forEach(this, f);
3962 3962
3963 String join([String separator]) => 3963 String join([String separator]) =>
3964 IterableMixinWorkaround.joinList(this, separator); 3964 IterableMixinWorkaround.joinList(this, separator);
3965 3965
3966 List mappedBy(f(Length element)) => IterableMixinWorkaround.mappedByList(this, f); 3966 Iterable map(f(Length element)) =>
3967 IterableMixinWorkaround.mappedByList(this, f);
3968
3969 Iterable mappedBy(f(Length element)) => map(f);
3967 3970
3968 Iterable<Length> where(bool f(Length element)) => 3971 Iterable<Length> where(bool f(Length element)) =>
3969 IterableMixinWorkaround.where(this, f); 3972 IterableMixinWorkaround.where(this, f);
3970 3973
3971 bool every(bool f(Length element)) => IterableMixinWorkaround.every(this, f); 3974 bool every(bool f(Length element)) => IterableMixinWorkaround.every(this, f);
3972 3975
3973 bool any(bool f(Length element)) => IterableMixinWorkaround.any(this, f); 3976 bool any(bool f(Length element)) => IterableMixinWorkaround.any(this, f);
3974 3977
3975 List<Length> toList() => new List<Length>.from(this); 3978 List<Length> toList() => new List<Length>.from(this);
3976 Set<Length> toSet() => new Set<Length>.from(this); 3979 Set<Length> toSet() => new Set<Length>.from(this);
3977 3980
3978 bool get isEmpty => this.length == 0; 3981 bool get isEmpty => this.length == 0;
3979 3982
3980 List<Length> take(int n) => IterableMixinWorkaround.takeList(this, n); 3983 Iterable<Length> take(int n) => IterableMixinWorkaround.takeList(this, n);
3981 3984
3982 Iterable<Length> takeWhile(bool test(Length value)) { 3985 Iterable<Length> takeWhile(bool test(Length value)) {
3983 return IterableMixinWorkaround.takeWhile(this, test); 3986 return IterableMixinWorkaround.takeWhile(this, test);
3984 } 3987 }
3985 3988
3986 List<Length> skip(int n) => IterableMixinWorkaround.skipList(this, n); 3989 Iterable<Length> skip(int n) => IterableMixinWorkaround.skipList(this, n);
3987 3990
3988 Iterable<Length> skipWhile(bool test(Length value)) { 3991 Iterable<Length> skipWhile(bool test(Length value)) {
3989 return IterableMixinWorkaround.skipWhile(this, test); 3992 return IterableMixinWorkaround.skipWhile(this, test);
3990 } 3993 }
3991 3994
3992 Length firstMatching(bool test(Length value), { Length orElse() }) { 3995 Length firstMatching(bool test(Length value), { Length orElse() }) {
3993 return IterableMixinWorkaround.firstMatching(this, test, orElse); 3996 return IterableMixinWorkaround.firstMatching(this, test, orElse);
3994 } 3997 }
3995 3998
3996 Length lastMatching(bool test(Length value), {Length orElse()}) { 3999 Length lastMatching(bool test(Length value), {Length orElse()}) {
(...skipping 725 matching lines...) Expand 10 before | Expand all | Expand 10 after
4722 return IterableMixinWorkaround.reduce(this, initialValue, combine); 4725 return IterableMixinWorkaround.reduce(this, initialValue, combine);
4723 } 4726 }
4724 4727
4725 bool contains(Number element) => IterableMixinWorkaround.contains(this, elemen t); 4728 bool contains(Number element) => IterableMixinWorkaround.contains(this, elemen t);
4726 4729
4727 void forEach(void f(Number element)) => IterableMixinWorkaround.forEach(this, f); 4730 void forEach(void f(Number element)) => IterableMixinWorkaround.forEach(this, f);
4728 4731
4729 String join([String separator]) => 4732 String join([String separator]) =>
4730 IterableMixinWorkaround.joinList(this, separator); 4733 IterableMixinWorkaround.joinList(this, separator);
4731 4734
4732 List mappedBy(f(Number element)) => IterableMixinWorkaround.mappedByList(this, f); 4735 Iterable map(f(Number element)) =>
4736 IterableMixinWorkaround.mappedByList(this, f);
4737
4738 Iterable mappedBy(f(Number element)) => map(f);
4733 4739
4734 Iterable<Number> where(bool f(Number element)) => 4740 Iterable<Number> where(bool f(Number element)) =>
4735 IterableMixinWorkaround.where(this, f); 4741 IterableMixinWorkaround.where(this, f);
4736 4742
4737 bool every(bool f(Number element)) => IterableMixinWorkaround.every(this, f); 4743 bool every(bool f(Number element)) => IterableMixinWorkaround.every(this, f);
4738 4744
4739 bool any(bool f(Number element)) => IterableMixinWorkaround.any(this, f); 4745 bool any(bool f(Number element)) => IterableMixinWorkaround.any(this, f);
4740 4746
4741 List<Number> toList() => new List<Number>.from(this); 4747 List<Number> toList() => new List<Number>.from(this);
4742 Set<Number> toSet() => new Set<Number>.from(this); 4748 Set<Number> toSet() => new Set<Number>.from(this);
4743 4749
4744 bool get isEmpty => this.length == 0; 4750 bool get isEmpty => this.length == 0;
4745 4751
4746 List<Number> take(int n) => IterableMixinWorkaround.takeList(this, n); 4752 Iterable<Number> take(int n) => IterableMixinWorkaround.takeList(this, n);
4747 4753
4748 Iterable<Number> takeWhile(bool test(Number value)) { 4754 Iterable<Number> takeWhile(bool test(Number value)) {
4749 return IterableMixinWorkaround.takeWhile(this, test); 4755 return IterableMixinWorkaround.takeWhile(this, test);
4750 } 4756 }
4751 4757
4752 List<Number> skip(int n) => IterableMixinWorkaround.skipList(this, n); 4758 Iterable<Number> skip(int n) => IterableMixinWorkaround.skipList(this, n);
4753 4759
4754 Iterable<Number> skipWhile(bool test(Number value)) { 4760 Iterable<Number> skipWhile(bool test(Number value)) {
4755 return IterableMixinWorkaround.skipWhile(this, test); 4761 return IterableMixinWorkaround.skipWhile(this, test);
4756 } 4762 }
4757 4763
4758 Number firstMatching(bool test(Number value), { Number orElse() }) { 4764 Number firstMatching(bool test(Number value), { Number orElse() }) {
4759 return IterableMixinWorkaround.firstMatching(this, test, orElse); 4765 return IterableMixinWorkaround.firstMatching(this, test, orElse);
4760 } 4766 }
4761 4767
4762 Number lastMatching(bool test(Number value), {Number orElse()}) { 4768 Number lastMatching(bool test(Number value), {Number orElse()}) {
(...skipping 1143 matching lines...) Expand 10 before | Expand all | Expand 10 after
5906 return IterableMixinWorkaround.reduce(this, initialValue, combine); 5912 return IterableMixinWorkaround.reduce(this, initialValue, combine);
5907 } 5913 }
5908 5914
5909 bool contains(PathSeg element) => IterableMixinWorkaround.contains(this, eleme nt); 5915 bool contains(PathSeg element) => IterableMixinWorkaround.contains(this, eleme nt);
5910 5916
5911 void forEach(void f(PathSeg element)) => IterableMixinWorkaround.forEach(this, f); 5917 void forEach(void f(PathSeg element)) => IterableMixinWorkaround.forEach(this, f);
5912 5918
5913 String join([String separator]) => 5919 String join([String separator]) =>
5914 IterableMixinWorkaround.joinList(this, separator); 5920 IterableMixinWorkaround.joinList(this, separator);
5915 5921
5916 List mappedBy(f(PathSeg element)) => IterableMixinWorkaround.mappedByList(this , f); 5922 Iterable map(f(PathSeg element)) =>
5923 IterableMixinWorkaround.mappedByList(this, f);
5924
5925 Iterable mappedBy(f(PathSeg element)) => map(f);
5917 5926
5918 Iterable<PathSeg> where(bool f(PathSeg element)) => 5927 Iterable<PathSeg> where(bool f(PathSeg element)) =>
5919 IterableMixinWorkaround.where(this, f); 5928 IterableMixinWorkaround.where(this, f);
5920 5929
5921 bool every(bool f(PathSeg element)) => IterableMixinWorkaround.every(this, f); 5930 bool every(bool f(PathSeg element)) => IterableMixinWorkaround.every(this, f);
5922 5931
5923 bool any(bool f(PathSeg element)) => IterableMixinWorkaround.any(this, f); 5932 bool any(bool f(PathSeg element)) => IterableMixinWorkaround.any(this, f);
5924 5933
5925 List<PathSeg> toList() => new List<PathSeg>.from(this); 5934 List<PathSeg> toList() => new List<PathSeg>.from(this);
5926 Set<PathSeg> toSet() => new Set<PathSeg>.from(this); 5935 Set<PathSeg> toSet() => new Set<PathSeg>.from(this);
5927 5936
5928 bool get isEmpty => this.length == 0; 5937 bool get isEmpty => this.length == 0;
5929 5938
5930 List<PathSeg> take(int n) => IterableMixinWorkaround.takeList(this, n); 5939 Iterable<PathSeg> take(int n) => IterableMixinWorkaround.takeList(this, n);
5931 5940
5932 Iterable<PathSeg> takeWhile(bool test(PathSeg value)) { 5941 Iterable<PathSeg> takeWhile(bool test(PathSeg value)) {
5933 return IterableMixinWorkaround.takeWhile(this, test); 5942 return IterableMixinWorkaround.takeWhile(this, test);
5934 } 5943 }
5935 5944
5936 List<PathSeg> skip(int n) => IterableMixinWorkaround.skipList(this, n); 5945 Iterable<PathSeg> skip(int n) => IterableMixinWorkaround.skipList(this, n);
5937 5946
5938 Iterable<PathSeg> skipWhile(bool test(PathSeg value)) { 5947 Iterable<PathSeg> skipWhile(bool test(PathSeg value)) {
5939 return IterableMixinWorkaround.skipWhile(this, test); 5948 return IterableMixinWorkaround.skipWhile(this, test);
5940 } 5949 }
5941 5950
5942 PathSeg firstMatching(bool test(PathSeg value), { PathSeg orElse() }) { 5951 PathSeg firstMatching(bool test(PathSeg value), { PathSeg orElse() }) {
5943 return IterableMixinWorkaround.firstMatching(this, test, orElse); 5952 return IterableMixinWorkaround.firstMatching(this, test, orElse);
5944 } 5953 }
5945 5954
5946 PathSeg lastMatching(bool test(PathSeg value), {PathSeg orElse()}) { 5955 PathSeg lastMatching(bool test(PathSeg value), {PathSeg orElse()}) {
(...skipping 983 matching lines...) Expand 10 before | Expand all | Expand 10 after
6930 return IterableMixinWorkaround.reduce(this, initialValue, combine); 6939 return IterableMixinWorkaround.reduce(this, initialValue, combine);
6931 } 6940 }
6932 6941
6933 bool contains(String element) => IterableMixinWorkaround.contains(this, elemen t); 6942 bool contains(String element) => IterableMixinWorkaround.contains(this, elemen t);
6934 6943
6935 void forEach(void f(String element)) => IterableMixinWorkaround.forEach(this, f); 6944 void forEach(void f(String element)) => IterableMixinWorkaround.forEach(this, f);
6936 6945
6937 String join([String separator]) => 6946 String join([String separator]) =>
6938 IterableMixinWorkaround.joinList(this, separator); 6947 IterableMixinWorkaround.joinList(this, separator);
6939 6948
6940 List mappedBy(f(String element)) => IterableMixinWorkaround.mappedByList(this, f); 6949 Iterable map(f(String element)) =>
6950 IterableMixinWorkaround.mappedByList(this, f);
6951
6952 Iterable mappedBy(f(String element)) => map(f);
6941 6953
6942 Iterable<String> where(bool f(String element)) => 6954 Iterable<String> where(bool f(String element)) =>
6943 IterableMixinWorkaround.where(this, f); 6955 IterableMixinWorkaround.where(this, f);
6944 6956
6945 bool every(bool f(String element)) => IterableMixinWorkaround.every(this, f); 6957 bool every(bool f(String element)) => IterableMixinWorkaround.every(this, f);
6946 6958
6947 bool any(bool f(String element)) => IterableMixinWorkaround.any(this, f); 6959 bool any(bool f(String element)) => IterableMixinWorkaround.any(this, f);
6948 6960
6949 List<String> toList() => new List<String>.from(this); 6961 List<String> toList() => new List<String>.from(this);
6950 Set<String> toSet() => new Set<String>.from(this); 6962 Set<String> toSet() => new Set<String>.from(this);
6951 6963
6952 bool get isEmpty => this.length == 0; 6964 bool get isEmpty => this.length == 0;
6953 6965
6954 List<String> take(int n) => IterableMixinWorkaround.takeList(this, n); 6966 Iterable<String> take(int n) => IterableMixinWorkaround.takeList(this, n);
6955 6967
6956 Iterable<String> takeWhile(bool test(String value)) { 6968 Iterable<String> takeWhile(bool test(String value)) {
6957 return IterableMixinWorkaround.takeWhile(this, test); 6969 return IterableMixinWorkaround.takeWhile(this, test);
6958 } 6970 }
6959 6971
6960 List<String> skip(int n) => IterableMixinWorkaround.skipList(this, n); 6972 Iterable<String> skip(int n) => IterableMixinWorkaround.skipList(this, n);
6961 6973
6962 Iterable<String> skipWhile(bool test(String value)) { 6974 Iterable<String> skipWhile(bool test(String value)) {
6963 return IterableMixinWorkaround.skipWhile(this, test); 6975 return IterableMixinWorkaround.skipWhile(this, test);
6964 } 6976 }
6965 6977
6966 String firstMatching(bool test(String value), { String orElse() }) { 6978 String firstMatching(bool test(String value), { String orElse() }) {
6967 return IterableMixinWorkaround.firstMatching(this, test, orElse); 6979 return IterableMixinWorkaround.firstMatching(this, test, orElse);
6968 } 6980 }
6969 6981
6970 String lastMatching(bool test(String value), {String orElse()}) { 6982 String lastMatching(bool test(String value), {String orElse()}) {
(...skipping 1278 matching lines...) Expand 10 before | Expand all | Expand 10 after
8249 return IterableMixinWorkaround.reduce(this, initialValue, combine); 8261 return IterableMixinWorkaround.reduce(this, initialValue, combine);
8250 } 8262 }
8251 8263
8252 bool contains(Transform element) => IterableMixinWorkaround.contains(this, ele ment); 8264 bool contains(Transform element) => IterableMixinWorkaround.contains(this, ele ment);
8253 8265
8254 void forEach(void f(Transform element)) => IterableMixinWorkaround.forEach(thi s, f); 8266 void forEach(void f(Transform element)) => IterableMixinWorkaround.forEach(thi s, f);
8255 8267
8256 String join([String separator]) => 8268 String join([String separator]) =>
8257 IterableMixinWorkaround.joinList(this, separator); 8269 IterableMixinWorkaround.joinList(this, separator);
8258 8270
8259 List mappedBy(f(Transform element)) => IterableMixinWorkaround.mappedByList(th is, f); 8271 Iterable map(f(Transform element)) =>
8272 IterableMixinWorkaround.mappedByList(this, f);
8273
8274 Iterable mappedBy(f(Transform element)) => map(f);
8260 8275
8261 Iterable<Transform> where(bool f(Transform element)) => 8276 Iterable<Transform> where(bool f(Transform element)) =>
8262 IterableMixinWorkaround.where(this, f); 8277 IterableMixinWorkaround.where(this, f);
8263 8278
8264 bool every(bool f(Transform element)) => IterableMixinWorkaround.every(this, f ); 8279 bool every(bool f(Transform element)) => IterableMixinWorkaround.every(this, f );
8265 8280
8266 bool any(bool f(Transform element)) => IterableMixinWorkaround.any(this, f); 8281 bool any(bool f(Transform element)) => IterableMixinWorkaround.any(this, f);
8267 8282
8268 List<Transform> toList() => new List<Transform>.from(this); 8283 List<Transform> toList() => new List<Transform>.from(this);
8269 Set<Transform> toSet() => new Set<Transform>.from(this); 8284 Set<Transform> toSet() => new Set<Transform>.from(this);
8270 8285
8271 bool get isEmpty => this.length == 0; 8286 bool get isEmpty => this.length == 0;
8272 8287
8273 List<Transform> take(int n) => IterableMixinWorkaround.takeList(this, n); 8288 Iterable<Transform> take(int n) => IterableMixinWorkaround.takeList(this, n);
8274 8289
8275 Iterable<Transform> takeWhile(bool test(Transform value)) { 8290 Iterable<Transform> takeWhile(bool test(Transform value)) {
8276 return IterableMixinWorkaround.takeWhile(this, test); 8291 return IterableMixinWorkaround.takeWhile(this, test);
8277 } 8292 }
8278 8293
8279 List<Transform> skip(int n) => IterableMixinWorkaround.skipList(this, n); 8294 Iterable<Transform> skip(int n) => IterableMixinWorkaround.skipList(this, n);
8280 8295
8281 Iterable<Transform> skipWhile(bool test(Transform value)) { 8296 Iterable<Transform> skipWhile(bool test(Transform value)) {
8282 return IterableMixinWorkaround.skipWhile(this, test); 8297 return IterableMixinWorkaround.skipWhile(this, test);
8283 } 8298 }
8284 8299
8285 Transform firstMatching(bool test(Transform value), { Transform orElse() }) { 8300 Transform firstMatching(bool test(Transform value), { Transform orElse() }) {
8286 return IterableMixinWorkaround.firstMatching(this, test, orElse); 8301 return IterableMixinWorkaround.firstMatching(this, test, orElse);
8287 } 8302 }
8288 8303
8289 Transform lastMatching(bool test(Transform value), {Transform orElse()}) { 8304 Transform lastMatching(bool test(Transform value), {Transform orElse()}) {
(...skipping 552 matching lines...) Expand 10 before | Expand all | Expand 10 after
8842 return IterableMixinWorkaround.reduce(this, initialValue, combine); 8857 return IterableMixinWorkaround.reduce(this, initialValue, combine);
8843 } 8858 }
8844 8859
8845 bool contains(ElementInstance element) => IterableMixinWorkaround.contains(thi s, element); 8860 bool contains(ElementInstance element) => IterableMixinWorkaround.contains(thi s, element);
8846 8861
8847 void forEach(void f(ElementInstance element)) => IterableMixinWorkaround.forEa ch(this, f); 8862 void forEach(void f(ElementInstance element)) => IterableMixinWorkaround.forEa ch(this, f);
8848 8863
8849 String join([String separator]) => 8864 String join([String separator]) =>
8850 IterableMixinWorkaround.joinList(this, separator); 8865 IterableMixinWorkaround.joinList(this, separator);
8851 8866
8852 List mappedBy(f(ElementInstance element)) => IterableMixinWorkaround.mappedByL ist(this, f); 8867 Iterable map(f(ElementInstance element)) =>
8868 IterableMixinWorkaround.mappedByList(this, f);
8869
8870 Iterable mappedBy(f(ElementInstance element)) => map(f);
8853 8871
8854 Iterable<ElementInstance> where(bool f(ElementInstance element)) => 8872 Iterable<ElementInstance> where(bool f(ElementInstance element)) =>
8855 IterableMixinWorkaround.where(this, f); 8873 IterableMixinWorkaround.where(this, f);
8856 8874
8857 bool every(bool f(ElementInstance element)) => IterableMixinWorkaround.every(t his, f); 8875 bool every(bool f(ElementInstance element)) => IterableMixinWorkaround.every(t his, f);
8858 8876
8859 bool any(bool f(ElementInstance element)) => IterableMixinWorkaround.any(this, f); 8877 bool any(bool f(ElementInstance element)) => IterableMixinWorkaround.any(this, f);
8860 8878
8861 List<ElementInstance> toList() => new List<ElementInstance>.from(this); 8879 List<ElementInstance> toList() => new List<ElementInstance>.from(this);
8862 Set<ElementInstance> toSet() => new Set<ElementInstance>.from(this); 8880 Set<ElementInstance> toSet() => new Set<ElementInstance>.from(this);
8863 8881
8864 bool get isEmpty => this.length == 0; 8882 bool get isEmpty => this.length == 0;
8865 8883
8866 List<ElementInstance> take(int n) => IterableMixinWorkaround.takeList(this, n) ; 8884 Iterable<ElementInstance> take(int n) => IterableMixinWorkaround.takeList(this , n);
8867 8885
8868 Iterable<ElementInstance> takeWhile(bool test(ElementInstance value)) { 8886 Iterable<ElementInstance> takeWhile(bool test(ElementInstance value)) {
8869 return IterableMixinWorkaround.takeWhile(this, test); 8887 return IterableMixinWorkaround.takeWhile(this, test);
8870 } 8888 }
8871 8889
8872 List<ElementInstance> skip(int n) => IterableMixinWorkaround.skipList(this, n) ; 8890 Iterable<ElementInstance> skip(int n) => IterableMixinWorkaround.skipList(this , n);
8873 8891
8874 Iterable<ElementInstance> skipWhile(bool test(ElementInstance value)) { 8892 Iterable<ElementInstance> skipWhile(bool test(ElementInstance value)) {
8875 return IterableMixinWorkaround.skipWhile(this, test); 8893 return IterableMixinWorkaround.skipWhile(this, test);
8876 } 8894 }
8877 8895
8878 ElementInstance firstMatching(bool test(ElementInstance value), { ElementInsta nce orElse() }) { 8896 ElementInstance firstMatching(bool test(ElementInstance value), { ElementInsta nce orElse() }) {
8879 return IterableMixinWorkaround.firstMatching(this, test, orElse); 8897 return IterableMixinWorkaround.firstMatching(this, test, orElse);
8880 } 8898 }
8881 8899
8882 ElementInstance lastMatching(bool test(ElementInstance value), {ElementInstanc e orElse()}) { 8900 ElementInstance lastMatching(bool test(ElementInstance value), {ElementInstanc e orElse()}) {
(...skipping 112 matching lines...) Expand 10 before | Expand all | Expand 10 after
8995 List<ElementInstance> getRange(int start, int rangeLength) => 9013 List<ElementInstance> getRange(int start, int rangeLength) =>
8996 Lists.getRange(this, start, rangeLength, <ElementInstance>[]); 9014 Lists.getRange(this, start, rangeLength, <ElementInstance>[]);
8997 9015
8998 // -- end List<ElementInstance> mixins. 9016 // -- end List<ElementInstance> mixins.
8999 9017
9000 @DomName('SVGElementInstanceList.item') 9018 @DomName('SVGElementInstanceList.item')
9001 @DocsEditable 9019 @DocsEditable
9002 ElementInstance item(int index) native "SVGElementInstanceList_item_Callback"; 9020 ElementInstance item(int index) native "SVGElementInstanceList_item_Callback";
9003 9021
9004 } 9022 }
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698