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

Side by Side Diff: runtime/lib/typeddata.dart

Issue 12443004: Fix typeddata. Was still using Arrays. (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Created 7 years, 9 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
« no previous file with comments | « no previous file | no next file » | 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) 2013, the Dart project authors. Please see the AUTHORS file 1 // Copyright (c) 2013, 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 // TODO(asiva): Remove this import of dart:scalarlist when we are ready to 5 // TODO(asiva): Remove this import of dart:scalarlist when we are ready to
6 // drop scalarlist and move this implementation as the default. 6 // drop scalarlist and move this implementation as the default.
7 import "dart:scalarlist" as sl; 7 import "dart:scalarlist" as sl;
8 8
9 // patch classes for Int8List ..... Float64List and ByteData implementations. 9 // patch classes for Int8List ..... Float64List and ByteData implementations.
10 10
(...skipping 338 matching lines...) Expand 10 before | Expand all | Expand 10 after
349 void addAll(Iterable value) { 349 void addAll(Iterable value) {
350 throw new UnsupportedError( 350 throw new UnsupportedError(
351 "Cannot add to a non-extendable array"); 351 "Cannot add to a non-extendable array");
352 } 352 }
353 353
354 void sort([int compare(var a, var b)]) { 354 void sort([int compare(var a, var b)]) {
355 return IterableMixinWorkaround.sortList(this, compare); 355 return IterableMixinWorkaround.sortList(this, compare);
356 } 356 }
357 357
358 int indexOf(element, [int start = 0]) { 358 int indexOf(element, [int start = 0]) {
359 return Arrays.indexOf(this, element, start, this.length); 359 return IterableMixinWorkaround.indexOfList(this, element, start);
360 } 360 }
361 361
362 int lastIndexOf(element, [int start = null]) { 362 int lastIndexOf(element, [int start = null]) {
363 if (start == null) start = length - 1; 363 return IterableMixinWorkaround.lastIndexOfList(this, element, start);
364 return Arrays.lastIndexOf(this, element, start);
365 } 364 }
366 365
367 void clear() { 366 void clear() {
368 throw new UnsupportedError( 367 throw new UnsupportedError(
369 "Cannot remove from a non-extendable array"); 368 "Cannot remove from a non-extendable array");
370 } 369 }
371 370
372 int removeLast() { 371 int removeLast() {
373 throw new UnsupportedError( 372 throw new UnsupportedError(
374 "Cannot remove from a non-extendable array"); 373 "Cannot remove from a non-extendable array");
(...skipping 139 matching lines...) Expand 10 before | Expand all | Expand 10 after
514 /** 513 /**
515 if (from is _Int8Array) { 514 if (from is _Int8Array) {
516 _setRange(start * Int8List.BYTES_PER_ELEMENT, 515 _setRange(start * Int8List.BYTES_PER_ELEMENT,
517 length * Int8List.BYTES_PER_ELEMENT, 516 length * Int8List.BYTES_PER_ELEMENT,
518 from, 517 from,
519 startFrom * Int8List.BYTES_PER_ELEMENT); 518 startFrom * Int8List.BYTES_PER_ELEMENT);
520 } else { 519 } else {
521 Arrays.copy(from, startFrom, this, start, length); 520 Arrays.copy(from, startFrom, this, start, length);
522 } 521 }
523 */ 522 */
524 Arrays.copy(from, startFrom, this, start, length); 523 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
525 } 524 }
526 525
527 526
528 // Method(s) implementing Object interface. 527 // Method(s) implementing Object interface.
529 528
530 String toString() { 529 String toString() {
531 return Collections.collectionToString(this); 530 return Collections.collectionToString(this);
532 } 531 }
533 532
534 533
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after
590 if (from is _Uint8Array || from is _ExternalUint8Array || 589 if (from is _Uint8Array || from is _ExternalUint8Array ||
591 from is _Uint8ClampedArray || from is _ExternalUint8ClampedArray) { 590 from is _Uint8ClampedArray || from is _ExternalUint8ClampedArray) {
592 _setRange(start * Uint8List.BYTES_PER_ELEMENT, 591 _setRange(start * Uint8List.BYTES_PER_ELEMENT,
593 length * Uint8List.BYTES_PER_ELEMENT, 592 length * Uint8List.BYTES_PER_ELEMENT,
594 from, 593 from,
595 startFrom * Uint8List.BYTES_PER_ELEMENT); 594 startFrom * Uint8List.BYTES_PER_ELEMENT);
596 } else { 595 } else {
597 Arrays.copy(from, startFrom, this, start, length); 596 Arrays.copy(from, startFrom, this, start, length);
598 } 597 }
599 */ 598 */
600 Arrays.copy(from, startFrom, this, start, length); 599 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
601 } 600 }
602 601
603 // Methods implementing Object interface. 602 // Methods implementing Object interface.
604 String toString() { 603 String toString() {
605 return Collections.collectionToString(this); 604 return Collections.collectionToString(this);
606 } 605 }
607 606
608 // Methods implementing TypedData interface. 607 // Methods implementing TypedData interface.
609 int get elementSizeInBytes { 608 int get elementSizeInBytes {
610 return Uint8List.BYTES_PER_ELEMENT; 609 return Uint8List.BYTES_PER_ELEMENT;
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after
661 if (from is _Uint8Array || from is _ExternalUint8Array || 660 if (from is _Uint8Array || from is _ExternalUint8Array ||
662 from is _Uint8ClampedArray || from is _ExternalUint8ClampedArray) { 661 from is _Uint8ClampedArray || from is _ExternalUint8ClampedArray) {
663 _setRange(start * Uint8List.BYTES_PER_ELEMENT, 662 _setRange(start * Uint8List.BYTES_PER_ELEMENT,
664 length * Uint8List.BYTES_PER_ELEMENT, 663 length * Uint8List.BYTES_PER_ELEMENT,
665 from, 664 from,
666 startFrom * Uint8List.BYTES_PER_ELEMENT); 665 startFrom * Uint8List.BYTES_PER_ELEMENT);
667 } else { 666 } else {
668 Arrays.copy(from, startFrom, this, start, length); 667 Arrays.copy(from, startFrom, this, start, length);
669 } 668 }
670 */ 669 */
671 Arrays.copy(from, startFrom, this, start, length); 670 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
672 } 671 }
673 672
674 // Methods implementing Object interface. 673 // Methods implementing Object interface.
675 String toString() { 674 String toString() {
676 return Collections.collectionToString(this); 675 return Collections.collectionToString(this);
677 } 676 }
678 677
679 // Methods implementing TypedData interface. 678 // Methods implementing TypedData interface.
680 int get elementSizeInBytes { 679 int get elementSizeInBytes {
681 return Uint8List.BYTES_PER_ELEMENT; 680 return Uint8List.BYTES_PER_ELEMENT;
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after
734 /** 733 /**
735 if (from is _Int16Array) { 734 if (from is _Int16Array) {
736 _setRange(start * Int16List.BYTES_PER_ELEMENT, 735 _setRange(start * Int16List.BYTES_PER_ELEMENT,
737 length * Int16List.BYTES_PER_ELEMENT, 736 length * Int16List.BYTES_PER_ELEMENT,
738 from, 737 from,
739 startFrom * Int16List.BYTES_PER_ELEMENT); 738 startFrom * Int16List.BYTES_PER_ELEMENT);
740 } else { 739 } else {
741 Arrays.copy(from, startFrom, this, start, length); 740 Arrays.copy(from, startFrom, this, start, length);
742 } 741 }
743 */ 742 */
744 Arrays.copy(from, startFrom, this, start, length); 743 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
745 } 744 }
746 745
747 746
748 // Method(s) implementing Object interface. 747 // Method(s) implementing Object interface.
749 748
750 String toString() { 749 String toString() {
751 return Collections.collectionToString(this); 750 return Collections.collectionToString(this);
752 } 751 }
753 752
754 753
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after
812 /** 811 /**
813 if (from is _Uint16Array) { 812 if (from is _Uint16Array) {
814 _setRange(start * Uint16List.BYTES_PER_ELEMENT, 813 _setRange(start * Uint16List.BYTES_PER_ELEMENT,
815 length * Uint16List.BYTES_PER_ELEMENT, 814 length * Uint16List.BYTES_PER_ELEMENT,
816 from, 815 from,
817 startFrom * Uint16List.BYTES_PER_ELEMENT); 816 startFrom * Uint16List.BYTES_PER_ELEMENT);
818 } else { 817 } else {
819 Arrays.copy(from, startFrom, this, start, length); 818 Arrays.copy(from, startFrom, this, start, length);
820 } 819 }
821 */ 820 */
822 Arrays.copy(from, startFrom, this, start, length); 821 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
823 } 822 }
824 823
825 824
826 // Method(s) implementing the Object interface. 825 // Method(s) implementing the Object interface.
827 826
828 String toString() { 827 String toString() {
829 return Collections.collectionToString(this); 828 return Collections.collectionToString(this);
830 } 829 }
831 830
832 831
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after
890 /** 889 /**
891 if (from is _Int32Array) { 890 if (from is _Int32Array) {
892 _setRange(start * Int32List.BYTES_PER_ELEMENT, 891 _setRange(start * Int32List.BYTES_PER_ELEMENT,
893 length * Int32List.BYTES_PER_ELEMENT, 892 length * Int32List.BYTES_PER_ELEMENT,
894 from, 893 from,
895 startFrom * Int32List.BYTES_PER_ELEMENT); 894 startFrom * Int32List.BYTES_PER_ELEMENT);
896 } else { 895 } else {
897 Arrays.copy(from, startFrom, this, start, length); 896 Arrays.copy(from, startFrom, this, start, length);
898 } 897 }
899 */ 898 */
900 Arrays.copy(from, startFrom, this, start, length); 899 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
901 } 900 }
902 901
903 902
904 // Method(s) implementing Object interface. 903 // Method(s) implementing Object interface.
905 904
906 String toString() { 905 String toString() {
907 return Collections.collectionToString(this); 906 return Collections.collectionToString(this);
908 } 907 }
909 908
910 909
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after
968 /** 967 /**
969 if (from is _Uint32Array) { 968 if (from is _Uint32Array) {
970 _setRange(start * Uint32List.BYTES_PER_ELEMENT, 969 _setRange(start * Uint32List.BYTES_PER_ELEMENT,
971 length * Uint32List.BYTES_PER_ELEMENT, 970 length * Uint32List.BYTES_PER_ELEMENT,
972 from, 971 from,
973 startFrom * Uint32List.BYTES_PER_ELEMENT); 972 startFrom * Uint32List.BYTES_PER_ELEMENT);
974 } else { 973 } else {
975 Arrays.copy(from, startFrom, this, start, length); 974 Arrays.copy(from, startFrom, this, start, length);
976 } 975 }
977 */ 976 */
978 Arrays.copy(from, startFrom, this, start, length); 977 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
979 } 978 }
980 979
981 980
982 // Method(s) implementing the Object interface. 981 // Method(s) implementing the Object interface.
983 982
984 String toString() { 983 String toString() {
985 return Collections.collectionToString(this); 984 return Collections.collectionToString(this);
986 } 985 }
987 986
988 987
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after
1046 /** 1045 /**
1047 if (from is _Int64Array) { 1046 if (from is _Int64Array) {
1048 _setRange(start * Int64List.BYTES_PER_ELEMENT, 1047 _setRange(start * Int64List.BYTES_PER_ELEMENT,
1049 length * Int64List.BYTES_PER_ELEMENT, 1048 length * Int64List.BYTES_PER_ELEMENT,
1050 from, 1049 from,
1051 startFrom * Int64List.BYTES_PER_ELEMENT); 1050 startFrom * Int64List.BYTES_PER_ELEMENT);
1052 } else { 1051 } else {
1053 Arrays.copy(from, startFrom, this, start, length); 1052 Arrays.copy(from, startFrom, this, start, length);
1054 } 1053 }
1055 */ 1054 */
1056 Arrays.copy(from, startFrom, this, start, length); 1055 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
1057 } 1056 }
1058 1057
1059 1058
1060 // Method(s) implementing the Object interface. 1059 // Method(s) implementing the Object interface.
1061 1060
1062 String toString() { 1061 String toString() {
1063 return Collections.collectionToString(this); 1062 return Collections.collectionToString(this);
1064 } 1063 }
1065 1064
1066 1065
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after
1124 /** 1123 /**
1125 if (from is _Uint64Array) { 1124 if (from is _Uint64Array) {
1126 _setRange(start * Uint64List.BYTES_PER_ELEMENT, 1125 _setRange(start * Uint64List.BYTES_PER_ELEMENT,
1127 length * Uint64List.BYTES_PER_ELEMENT, 1126 length * Uint64List.BYTES_PER_ELEMENT,
1128 from, 1127 from,
1129 startFrom * Uint64List.BYTES_PER_ELEMENT); 1128 startFrom * Uint64List.BYTES_PER_ELEMENT);
1130 } else { 1129 } else {
1131 Arrays.copy(from, startFrom, this, start, length); 1130 Arrays.copy(from, startFrom, this, start, length);
1132 } 1131 }
1133 */ 1132 */
1134 Arrays.copy(from, startFrom, this, start, length); 1133 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
1135 } 1134 }
1136 1135
1137 1136
1138 // Method(s) implementing the Object interface. 1137 // Method(s) implementing the Object interface.
1139 1138
1140 String toString() { 1139 String toString() {
1141 return Collections.collectionToString(this); 1140 return Collections.collectionToString(this);
1142 } 1141 }
1143 1142
1144 1143
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after
1202 /** 1201 /**
1203 if (from is _Float32Array) { 1202 if (from is _Float32Array) {
1204 _setRange(start * Float32List.BYTES_PER_ELEMENT, 1203 _setRange(start * Float32List.BYTES_PER_ELEMENT,
1205 length * Float32List.BYTES_PER_ELEMENT, 1204 length * Float32List.BYTES_PER_ELEMENT,
1206 from, 1205 from,
1207 startFrom * Float32List.BYTES_PER_ELEMENT); 1206 startFrom * Float32List.BYTES_PER_ELEMENT);
1208 } else { 1207 } else {
1209 Arrays.copy(from, startFrom, this, start, length); 1208 Arrays.copy(from, startFrom, this, start, length);
1210 } 1209 }
1211 */ 1210 */
1212 Arrays.copy(from, startFrom, this, start, length); 1211 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
1213 } 1212 }
1214 1213
1215 1214
1216 // Method(s) implementing the Object interface. 1215 // Method(s) implementing the Object interface.
1217 1216
1218 String toString() { 1217 String toString() {
1219 return Collections.collectionToString(this); 1218 return Collections.collectionToString(this);
1220 } 1219 }
1221 1220
1222 1221
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after
1280 /** 1279 /**
1281 if (from is _Float64Array) { 1280 if (from is _Float64Array) {
1282 _setRange(start * Float64List.BYTES_PER_ELEMENT, 1281 _setRange(start * Float64List.BYTES_PER_ELEMENT,
1283 length * Float64List.BYTES_PER_ELEMENT, 1282 length * Float64List.BYTES_PER_ELEMENT,
1284 from, 1283 from,
1285 startFrom * Float64List.BYTES_PER_ELEMENT); 1284 startFrom * Float64List.BYTES_PER_ELEMENT);
1286 } else { 1285 } else {
1287 Arrays.copy(from, startFrom, this, start, length); 1286 Arrays.copy(from, startFrom, this, start, length);
1288 } 1287 }
1289 */ 1288 */
1290 Arrays.copy(from, startFrom, this, start, length); 1289 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
1291 } 1290 }
1292 1291
1293 1292
1294 // Method(s) implementing the Object interface. 1293 // Method(s) implementing the Object interface.
1295 1294
1296 String toString() { 1295 String toString() {
1297 return Collections.collectionToString(this); 1296 return Collections.collectionToString(this);
1298 } 1297 }
1299 1298
1300 1299
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after
1348 /** 1347 /**
1349 if (from is _ExternalInt8Array) { 1348 if (from is _ExternalInt8Array) {
1350 _setRange(start * Int8List.BYTES_PER_ELEMENT, 1349 _setRange(start * Int8List.BYTES_PER_ELEMENT,
1351 length * Int8List.BYTES_PER_ELEMENT, 1350 length * Int8List.BYTES_PER_ELEMENT,
1352 from, 1351 from,
1353 startFrom * Int8List.BYTES_PER_ELEMENT); 1352 startFrom * Int8List.BYTES_PER_ELEMENT);
1354 } else { 1353 } else {
1355 Arrays.copy(from, startFrom, this, start, length); 1354 Arrays.copy(from, startFrom, this, start, length);
1356 } 1355 }
1357 */ 1356 */
1358 Arrays.copy(from, startFrom, this, start, length); 1357 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
1359 } 1358 }
1360 1359
1361 1360
1362 // Method(s) implementing the Object interface. 1361 // Method(s) implementing the Object interface.
1363 1362
1364 String toString() { 1363 String toString() {
1365 return Collections.collectionToString(this); 1364 return Collections.collectionToString(this);
1366 } 1365 }
1367 1366
1368 1367
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after
1417 /** 1416 /**
1418 if (from is _ExternalUint8Array || from is _Uint8Array) { 1417 if (from is _ExternalUint8Array || from is _Uint8Array) {
1419 _setRange(start * Uint8List.BYTES_PER_ELEMENT, 1418 _setRange(start * Uint8List.BYTES_PER_ELEMENT,
1420 length * Uint8List.BYTES_PER_ELEMENT, 1419 length * Uint8List.BYTES_PER_ELEMENT,
1421 from, 1420 from,
1422 startFrom * Uint8List.BYTES_PER_ELEMENT); 1421 startFrom * Uint8List.BYTES_PER_ELEMENT);
1423 } else { 1422 } else {
1424 Arrays.copy(from, startFrom, this, start, length); 1423 Arrays.copy(from, startFrom, this, start, length);
1425 } 1424 }
1426 */ 1425 */
1427 Arrays.copy(from, startFrom, this, start, length); 1426 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
1428 } 1427 }
1429 1428
1430 1429
1431 // Method(s) implementing the Object interface. 1430 // Method(s) implementing the Object interface.
1432 1431
1433 String toString() { 1432 String toString() {
1434 return Collections.collectionToString(this); 1433 return Collections.collectionToString(this);
1435 } 1434 }
1436 1435
1437 1436
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after
1486 /** 1485 /**
1487 if (from is _ExternalUint8ClampedArray || from is _Uint8ClampedArray) { 1486 if (from is _ExternalUint8ClampedArray || from is _Uint8ClampedArray) {
1488 _setRange(start * Uint8List.BYTES_PER_ELEMENT, 1487 _setRange(start * Uint8List.BYTES_PER_ELEMENT,
1489 length * Uint8List.BYTES_PER_ELEMENT, 1488 length * Uint8List.BYTES_PER_ELEMENT,
1490 from, 1489 from,
1491 startFrom * Uint8List.BYTES_PER_ELEMENT); 1490 startFrom * Uint8List.BYTES_PER_ELEMENT);
1492 } else { 1491 } else {
1493 Arrays.copy(from, startFrom, this, start, length); 1492 Arrays.copy(from, startFrom, this, start, length);
1494 } 1493 }
1495 */ 1494 */
1496 Arrays.copy(from, startFrom, this, start, length); 1495 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
1497 } 1496 }
1498 1497
1499 1498
1500 // Method(s) implementing the Object interface. 1499 // Method(s) implementing the Object interface.
1501 1500
1502 String toString() { 1501 String toString() {
1503 return Collections.collectionToString(this); 1502 return Collections.collectionToString(this);
1504 } 1503 }
1505 1504
1506 1505
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after
1555 /** 1554 /**
1556 if (from is _ExternalInt16Array) { 1555 if (from is _ExternalInt16Array) {
1557 _setRange(start * Int16List.BYTES_PER_ELEMENT, 1556 _setRange(start * Int16List.BYTES_PER_ELEMENT,
1558 length * Int16List.BYTES_PER_ELEMENT, 1557 length * Int16List.BYTES_PER_ELEMENT,
1559 from, 1558 from,
1560 startFrom * Int16List.BYTES_PER_ELEMENT); 1559 startFrom * Int16List.BYTES_PER_ELEMENT);
1561 } else { 1560 } else {
1562 Arrays.copy(from, startFrom, this, start, length); 1561 Arrays.copy(from, startFrom, this, start, length);
1563 } 1562 }
1564 */ 1563 */
1565 Arrays.copy(from, startFrom, this, start, length); 1564 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
1566 } 1565 }
1567 1566
1568 1567
1569 // Method(s) implementing the Object interface. 1568 // Method(s) implementing the Object interface.
1570 1569
1571 String toString() { 1570 String toString() {
1572 return Collections.collectionToString(this); 1571 return Collections.collectionToString(this);
1573 } 1572 }
1574 1573
1575 1574
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after
1624 /** 1623 /**
1625 if (from is _ExternalUint16Array) { 1624 if (from is _ExternalUint16Array) {
1626 _setRange(start * Uint16List.BYTES_PER_ELEMENT, 1625 _setRange(start * Uint16List.BYTES_PER_ELEMENT,
1627 length * Uint16List.BYTES_PER_ELEMENT, 1626 length * Uint16List.BYTES_PER_ELEMENT,
1628 from, 1627 from,
1629 startFrom * Uint16List.BYTES_PER_ELEMENT); 1628 startFrom * Uint16List.BYTES_PER_ELEMENT);
1630 } else { 1629 } else {
1631 Arrays.copy(from, startFrom, this, start, length); 1630 Arrays.copy(from, startFrom, this, start, length);
1632 } 1631 }
1633 */ 1632 */
1634 Arrays.copy(from, startFrom, this, start, length); 1633 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
1635 } 1634 }
1636 1635
1637 1636
1638 // Method(s) implementing the Object interface. 1637 // Method(s) implementing the Object interface.
1639 1638
1640 String toString() { 1639 String toString() {
1641 return Collections.collectionToString(this); 1640 return Collections.collectionToString(this);
1642 } 1641 }
1643 1642
1644 1643
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after
1693 /** 1692 /**
1694 if (from is _ExternalInt32Array) { 1693 if (from is _ExternalInt32Array) {
1695 _setRange(start * Int32List.BYTES_PER_ELEMENT, 1694 _setRange(start * Int32List.BYTES_PER_ELEMENT,
1696 length * Int32List.BYTES_PER_ELEMENT, 1695 length * Int32List.BYTES_PER_ELEMENT,
1697 from, 1696 from,
1698 startFrom * Int32List.BYTES_PER_ELEMENT); 1697 startFrom * Int32List.BYTES_PER_ELEMENT);
1699 } else { 1698 } else {
1700 Arrays.copy(from, startFrom, this, start, length); 1699 Arrays.copy(from, startFrom, this, start, length);
1701 } 1700 }
1702 */ 1701 */
1703 Arrays.copy(from, startFrom, this, start, length); 1702 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
1704 } 1703 }
1705 1704
1706 1705
1707 // Method(s) implementing the Object interface. 1706 // Method(s) implementing the Object interface.
1708 1707
1709 String toString() { 1708 String toString() {
1710 return Collections.collectionToString(this); 1709 return Collections.collectionToString(this);
1711 } 1710 }
1712 1711
1713 1712
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after
1762 /** 1761 /**
1763 if (from is _ExternalUint32Array) { 1762 if (from is _ExternalUint32Array) {
1764 _setRange(start * Uint32List.BYTES_PER_ELEMENT, 1763 _setRange(start * Uint32List.BYTES_PER_ELEMENT,
1765 length * Uint32List.BYTES_PER_ELEMENT, 1764 length * Uint32List.BYTES_PER_ELEMENT,
1766 from, 1765 from,
1767 startFrom * Uint32List.BYTES_PER_ELEMENT); 1766 startFrom * Uint32List.BYTES_PER_ELEMENT);
1768 } else { 1767 } else {
1769 Arrays.copy(from, startFrom, this, start, length); 1768 Arrays.copy(from, startFrom, this, start, length);
1770 } 1769 }
1771 */ 1770 */
1772 Arrays.copy(from, startFrom, this, start, length); 1771 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
1773 } 1772 }
1774 1773
1775 1774
1776 // Method(s) implementing the Object interface. 1775 // Method(s) implementing the Object interface.
1777 1776
1778 String toString() { 1777 String toString() {
1779 return Collections.collectionToString(this); 1778 return Collections.collectionToString(this);
1780 } 1779 }
1781 1780
1782 1781
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after
1831 /** 1830 /**
1832 if (from is _ExternalInt64Array) { 1831 if (from is _ExternalInt64Array) {
1833 _setRange(start * Int64List.BYTES_PER_ELEMENT, 1832 _setRange(start * Int64List.BYTES_PER_ELEMENT,
1834 length * Int64List.BYTES_PER_ELEMENT, 1833 length * Int64List.BYTES_PER_ELEMENT,
1835 from, 1834 from,
1836 startFrom * Int64List.BYTES_PER_ELEMENT); 1835 startFrom * Int64List.BYTES_PER_ELEMENT);
1837 } else { 1836 } else {
1838 Arrays.copy(from, startFrom, this, start, length); 1837 Arrays.copy(from, startFrom, this, start, length);
1839 } 1838 }
1840 */ 1839 */
1841 Arrays.copy(from, startFrom, this, start, length); 1840 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
1842 } 1841 }
1843 1842
1844 1843
1845 // Method(s) implementing the Object interface. 1844 // Method(s) implementing the Object interface.
1846 1845
1847 String toString() { 1846 String toString() {
1848 return Collections.collectionToString(this); 1847 return Collections.collectionToString(this);
1849 } 1848 }
1850 1849
1851 1850
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after
1900 /** 1899 /**
1901 if (from is _ExternalUint64Array) { 1900 if (from is _ExternalUint64Array) {
1902 _setRange(start * Uint64List.BYTES_PER_ELEMENT, 1901 _setRange(start * Uint64List.BYTES_PER_ELEMENT,
1903 length * Uint64List.BYTES_PER_ELEMENT, 1902 length * Uint64List.BYTES_PER_ELEMENT,
1904 from, 1903 from,
1905 startFrom * Uint64List.BYTES_PER_ELEMENT); 1904 startFrom * Uint64List.BYTES_PER_ELEMENT);
1906 } else { 1905 } else {
1907 Arrays.copy(from, startFrom, this, start, length); 1906 Arrays.copy(from, startFrom, this, start, length);
1908 } 1907 }
1909 */ 1908 */
1910 Arrays.copy(from, startFrom, this, start, length); 1909 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
1911 } 1910 }
1912 1911
1913 1912
1914 // Method(s) implementing the Object interface. 1913 // Method(s) implementing the Object interface.
1915 1914
1916 String toString() { 1915 String toString() {
1917 return Collections.collectionToString(this); 1916 return Collections.collectionToString(this);
1918 } 1917 }
1919 1918
1920 1919
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after
1969 /** 1968 /**
1970 if (from is _ExternalFloat32Array) { 1969 if (from is _ExternalFloat32Array) {
1971 _setRange(start * Float32List.BYTES_PER_ELEMENT, 1970 _setRange(start * Float32List.BYTES_PER_ELEMENT,
1972 length * Float32List.BYTES_PER_ELEMENT, 1971 length * Float32List.BYTES_PER_ELEMENT,
1973 from, 1972 from,
1974 startFrom * Float32List.BYTES_PER_ELEMENT); 1973 startFrom * Float32List.BYTES_PER_ELEMENT);
1975 } else { 1974 } else {
1976 Arrays.copy(from, startFrom, this, start, length); 1975 Arrays.copy(from, startFrom, this, start, length);
1977 } 1976 }
1978 */ 1977 */
1979 Arrays.copy(from, startFrom, this, start, length); 1978 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
1980 } 1979 }
1981 1980
1982 1981
1983 // Method(s) implementing the Object interface. 1982 // Method(s) implementing the Object interface.
1984 1983
1985 String toString() { 1984 String toString() {
1986 return Collections.collectionToString(this); 1985 return Collections.collectionToString(this);
1987 } 1986 }
1988 1987
1989 1988
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after
2038 /** 2037 /**
2039 if (from is _ExternalFloat64Array) { 2038 if (from is _ExternalFloat64Array) {
2040 _setRange(start * Float64List.BYTES_PER_ELEMENT, 2039 _setRange(start * Float64List.BYTES_PER_ELEMENT,
2041 length * Float64List.BYTES_PER_ELEMENT, 2040 length * Float64List.BYTES_PER_ELEMENT,
2042 from, 2041 from,
2043 startFrom * Float64List.BYTES_PER_ELEMENT); 2042 startFrom * Float64List.BYTES_PER_ELEMENT);
2044 } else { 2043 } else {
2045 Arrays.copy(from, startFrom, this, start, length); 2044 Arrays.copy(from, startFrom, this, start, length);
2046 } 2045 }
2047 */ 2046 */
2048 Arrays.copy(from, startFrom, this, start, length); 2047 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
2049 } 2048 }
2050 2049
2051 2050
2052 // Method(s) implementing the Object interface. 2051 // Method(s) implementing the Object interface.
2053 2052
2054 String toString() { 2053 String toString() {
2055 return Collections.collectionToString(this); 2054 return Collections.collectionToString(this);
2056 } 2055 }
2057 2056
2058 2057
(...skipping 104 matching lines...) Expand 10 before | Expand all | Expand 10 after
2163 } 2162 }
2164 2163
2165 List<int> getRange(int start, int length) { 2164 List<int> getRange(int start, int length) {
2166 _rangeCheck(this.length, start, length); 2165 _rangeCheck(this.length, start, length);
2167 List<int> result = new Int8List(length); 2166 List<int> result = new Int8List(length);
2168 result.setRange(0, length, this, start); 2167 result.setRange(0, length, this, start);
2169 return result; 2168 return result;
2170 } 2169 }
2171 2170
2172 void setRange(int start, int length, List<int> from, [int startFrom = 0]) { 2171 void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
2173 Arrays.copy(from, startFrom, this, start, length); 2172 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
2174 } 2173 }
2175 2174
2176 2175
2177 // Method(s) implementing Object interface. 2176 // Method(s) implementing Object interface.
2178 2177
2179 String toString() { 2178 String toString() {
2180 return Collections.collectionToString(this); 2179 return Collections.collectionToString(this);
2181 } 2180 }
2182 2181
2183 2182
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
2227 } 2226 }
2228 2227
2229 List<int> getRange(int start, int length) { 2228 List<int> getRange(int start, int length) {
2230 _rangeCheck(this.length, start, length); 2229 _rangeCheck(this.length, start, length);
2231 List<int> result = new Uint8List(length); 2230 List<int> result = new Uint8List(length);
2232 result.setRange(0, length, this, start); 2231 result.setRange(0, length, this, start);
2233 return result; 2232 return result;
2234 } 2233 }
2235 2234
2236 void setRange(int start, int length, List<int> from, [int startFrom = 0]) { 2235 void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
2237 Arrays.copy(from, startFrom, this, start, length); 2236 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
2238 } 2237 }
2239 2238
2240 2239
2241 // Method(s) implementing Object interface. 2240 // Method(s) implementing Object interface.
2242 2241
2243 String toString() { 2242 String toString() {
2244 return Collections.collectionToString(this); 2243 return Collections.collectionToString(this);
2245 } 2244 }
2246 2245
2247 2246
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
2292 } 2291 }
2293 2292
2294 List<int> getRange(int start, int length) { 2293 List<int> getRange(int start, int length) {
2295 _rangeCheck(this.length, start, length); 2294 _rangeCheck(this.length, start, length);
2296 List<int> result = new Uint8List(length); 2295 List<int> result = new Uint8List(length);
2297 result.setRange(0, length, this, start); 2296 result.setRange(0, length, this, start);
2298 return result; 2297 return result;
2299 } 2298 }
2300 2299
2301 void setRange(int start, int length, List<int> from, [int startFrom = 0]) { 2300 void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
2302 Arrays.copy(from, startFrom, this, start, length); 2301 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
2303 } 2302 }
2304 2303
2305 2304
2306 // Method(s) implementing Object interface. 2305 // Method(s) implementing Object interface.
2307 2306
2308 String toString() { 2307 String toString() {
2309 return Collections.collectionToString(this); 2308 return Collections.collectionToString(this);
2310 } 2309 }
2311 2310
2312 2311
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
2356 } 2355 }
2357 2356
2358 List<int> getRange(int start, int length) { 2357 List<int> getRange(int start, int length) {
2359 _rangeCheck(this.length, start, length); 2358 _rangeCheck(this.length, start, length);
2360 List<int> result = new Int16List(length); 2359 List<int> result = new Int16List(length);
2361 result.setRange(0, length, this, start); 2360 result.setRange(0, length, this, start);
2362 return result; 2361 return result;
2363 } 2362 }
2364 2363
2365 void setRange(int start, int length, List<int> from, [int startFrom = 0]) { 2364 void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
2366 Arrays.copy(from, startFrom, this, start, length); 2365 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
2367 } 2366 }
2368 2367
2369 2368
2370 // Method(s) implementing Object interface. 2369 // Method(s) implementing Object interface.
2371 2370
2372 String toString() { 2371 String toString() {
2373 return Collections.collectionToString(this); 2372 return Collections.collectionToString(this);
2374 } 2373 }
2375 2374
2376 2375
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
2420 } 2419 }
2421 2420
2422 List<int> getRange(int start, int length) { 2421 List<int> getRange(int start, int length) {
2423 _rangeCheck(this.length, start, length); 2422 _rangeCheck(this.length, start, length);
2424 List<int> result = new Uint16List(length); 2423 List<int> result = new Uint16List(length);
2425 result.setRange(0, length, this, start); 2424 result.setRange(0, length, this, start);
2426 return result; 2425 return result;
2427 } 2426 }
2428 2427
2429 void setRange(int start, int length, List<int> from, [int startFrom = 0]) { 2428 void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
2430 Arrays.copy(from, startFrom, this, start, length); 2429 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
2431 } 2430 }
2432 2431
2433 2432
2434 // Method(s) implementing Object interface. 2433 // Method(s) implementing Object interface.
2435 2434
2436 String toString() { 2435 String toString() {
2437 return Collections.collectionToString(this); 2436 return Collections.collectionToString(this);
2438 } 2437 }
2439 2438
2440 2439
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
2484 } 2483 }
2485 2484
2486 List<int> getRange(int start, int length) { 2485 List<int> getRange(int start, int length) {
2487 _rangeCheck(this.length, start, length); 2486 _rangeCheck(this.length, start, length);
2488 List<int> result = new Int32List(length); 2487 List<int> result = new Int32List(length);
2489 result.setRange(0, length, this, start); 2488 result.setRange(0, length, this, start);
2490 return result; 2489 return result;
2491 } 2490 }
2492 2491
2493 void setRange(int start, int length, List<int> from, [int startFrom = 0]) { 2492 void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
2494 Arrays.copy(from, startFrom, this, start, length); 2493 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
2495 } 2494 }
2496 2495
2497 2496
2498 // Method(s) implementing Object interface. 2497 // Method(s) implementing Object interface.
2499 2498
2500 String toString() { 2499 String toString() {
2501 return Collections.collectionToString(this); 2500 return Collections.collectionToString(this);
2502 } 2501 }
2503 2502
2504 2503
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
2548 } 2547 }
2549 2548
2550 List<int> getRange(int start, int length) { 2549 List<int> getRange(int start, int length) {
2551 _rangeCheck(this.length, start, length); 2550 _rangeCheck(this.length, start, length);
2552 List<int> result = new Uint32List(length); 2551 List<int> result = new Uint32List(length);
2553 result.setRange(0, length, this, start); 2552 result.setRange(0, length, this, start);
2554 return result; 2553 return result;
2555 } 2554 }
2556 2555
2557 void setRange(int start, int length, List<int> from, [int startFrom = 0]) { 2556 void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
2558 Arrays.copy(from, startFrom, this, start, length); 2557 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
2559 } 2558 }
2560 2559
2561 2560
2562 // Method(s) implementing Object interface. 2561 // Method(s) implementing Object interface.
2563 2562
2564 String toString() { 2563 String toString() {
2565 return Collections.collectionToString(this); 2564 return Collections.collectionToString(this);
2566 } 2565 }
2567 2566
2568 2567
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
2612 } 2611 }
2613 2612
2614 List<int> getRange(int start, int length) { 2613 List<int> getRange(int start, int length) {
2615 _rangeCheck(this.length, start, length); 2614 _rangeCheck(this.length, start, length);
2616 List<int> result = new Int64List(length); 2615 List<int> result = new Int64List(length);
2617 result.setRange(0, length, this, start); 2616 result.setRange(0, length, this, start);
2618 return result; 2617 return result;
2619 } 2618 }
2620 2619
2621 void setRange(int start, int length, List<int> from, [int startFrom = 0]) { 2620 void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
2622 Arrays.copy(from, startFrom, this, start, length); 2621 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
2623 } 2622 }
2624 2623
2625 2624
2626 // Method(s) implementing Object interface. 2625 // Method(s) implementing Object interface.
2627 2626
2628 String toString() { 2627 String toString() {
2629 return Collections.collectionToString(this); 2628 return Collections.collectionToString(this);
2630 } 2629 }
2631 2630
2632 2631
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
2676 } 2675 }
2677 2676
2678 List<int> getRange(int start, int length) { 2677 List<int> getRange(int start, int length) {
2679 _rangeCheck(this.length, start, length); 2678 _rangeCheck(this.length, start, length);
2680 List<int> result = new Uint64List(length); 2679 List<int> result = new Uint64List(length);
2681 result.setRange(0, length, this, start); 2680 result.setRange(0, length, this, start);
2682 return result; 2681 return result;
2683 } 2682 }
2684 2683
2685 void setRange(int start, int length, List<int> from, [int startFrom = 0]) { 2684 void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
2686 Arrays.copy(from, startFrom, this, start, length); 2685 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
2687 } 2686 }
2688 2687
2689 2688
2690 // Method(s) implementing Object interface. 2689 // Method(s) implementing Object interface.
2691 2690
2692 String toString() { 2691 String toString() {
2693 return Collections.collectionToString(this); 2692 return Collections.collectionToString(this);
2694 } 2693 }
2695 2694
2696 2695
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
2740 } 2739 }
2741 2740
2742 List<double> getRange(int start, int length) { 2741 List<double> getRange(int start, int length) {
2743 _rangeCheck(this.length, start, length); 2742 _rangeCheck(this.length, start, length);
2744 List<double> result = new Float32List(length); 2743 List<double> result = new Float32List(length);
2745 result.setRange(0, length, this, start); 2744 result.setRange(0, length, this, start);
2746 return result; 2745 return result;
2747 } 2746 }
2748 2747
2749 void setRange(int start, int length, List<double> from, [int startFrom = 0]) { 2748 void setRange(int start, int length, List<double> from, [int startFrom = 0]) {
2750 Arrays.copy(from, startFrom, this, start, length); 2749 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
2751 } 2750 }
2752 2751
2753 2752
2754 // Method(s) implementing Object interface. 2753 // Method(s) implementing Object interface.
2755 2754
2756 String toString() { 2755 String toString() {
2757 return Collections.collectionToString(this); 2756 return Collections.collectionToString(this);
2758 } 2757 }
2759 2758
2760 2759
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
2804 } 2803 }
2805 2804
2806 List<double> getRange(int start, int length) { 2805 List<double> getRange(int start, int length) {
2807 _rangeCheck(this.length, start, length); 2806 _rangeCheck(this.length, start, length);
2808 List<double> result = new Float64List(length); 2807 List<double> result = new Float64List(length);
2809 result.setRange(0, length, this, start); 2808 result.setRange(0, length, this, start);
2810 return result; 2809 return result;
2811 } 2810 }
2812 2811
2813 void setRange(int start, int length, List<double> from, [int startFrom = 0]) { 2812 void setRange(int start, int length, List<double> from, [int startFrom = 0]) {
2814 Arrays.copy(from, startFrom, this, start, length); 2813 IterableMixinWorkaround.setRangeList(this, start, length, from, startFrom);
2815 } 2814 }
2816 2815
2817 2816
2818 // Method(s) implementing Object interface. 2817 // Method(s) implementing Object interface.
2819 2818
2820 String toString() { 2819 String toString() {
2821 return Collections.collectionToString(this); 2820 return Collections.collectionToString(this);
2822 } 2821 }
2823 2822
2824 2823
(...skipping 172 matching lines...) Expand 10 before | Expand all | Expand 10 after
2997 throw new RangeError.value(start + length); 2996 throw new RangeError.value(start + length);
2998 } 2997 }
2999 } 2998 }
3000 2999
3001 3000
3002 int _defaultIfNull(object, value) { 3001 int _defaultIfNull(object, value) {
3003 if (object == null) { 3002 if (object == null) {
3004 return value; 3003 return value;
3005 } 3004 }
3006 } 3005 }
OLDNEW
« no previous file with comments | « no previous file | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698