OLD | NEW |
1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2012, 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 patch class Int8List { | 5 patch class Int8List { |
6 /* patch */ factory Int8List(int length) { | 6 /* patch */ factory Int8List(int length) { |
7 return new _Int8Array(length); | 7 return new _Int8Array(length); |
8 } | 8 } |
9 | 9 |
10 /* patch */ factory Int8List.transferable(int length) { | 10 /* patch */ factory Int8List.transferable(int length) { |
11 return new _Int8Array.transferable(length); | 11 // return new _Int8Array.transferable(length); |
| 12 return _newTransferable(length); |
12 } | 13 } |
13 | 14 |
14 /* patch */ factory Int8List.view(ByteArray array, | 15 /* patch */ factory Int8List.view(ByteArray array, |
15 [int start = 0, int length]) { | 16 [int start = 0, int length]) { |
16 return new _Int8ArrayView(array, start, length); | 17 return new _Int8ArrayView(array, start, length); |
17 } | 18 } |
| 19 |
| 20 static _ExternalInt8Array _newTransferable(int length) |
| 21 native "Int8Array_newTransferable"; |
18 } | 22 } |
19 | 23 |
20 | 24 |
21 patch class Uint8List { | 25 patch class Uint8List { |
22 /* patch */ factory Uint8List(int length) { | 26 /* patch */ factory Uint8List(int length) { |
23 return new _Uint8Array(length); | 27 return new _Uint8Array(length); |
24 } | 28 } |
25 | 29 |
26 /* patch */ factory Uint8List.transferable(int length) { | 30 /* patch */ factory Uint8List.transferable(int length) { |
27 return new _Uint8Array.transferable(length); | 31 return _newTransferable(length); |
28 } | 32 } |
29 | 33 |
30 /* patch */ factory Uint8List.view(ByteArray array, | 34 /* patch */ factory Uint8List.view(ByteArray array, |
31 [int start = 0, int length]) { | 35 [int start = 0, int length]) { |
32 return new _Uint8ArrayView(array, start, length); | 36 return new _Uint8ArrayView(array, start, length); |
33 } | 37 } |
| 38 |
| 39 static _ExternalUint8Array _newTransferable(int length) |
| 40 native "Uint8Array_newTransferable"; |
34 } | 41 } |
35 | 42 |
36 | 43 |
37 patch class Uint8ClampedList { | 44 patch class Uint8ClampedList { |
38 /* patch */ factory Uint8ClampedList(int length) { | 45 /* patch */ factory Uint8ClampedList(int length) { |
39 return new _Uint8ClampedArray(length); | 46 return new _Uint8ClampedArray(length); |
40 } | 47 } |
41 | 48 |
42 /* patch */ factory Uint8ClampedList.transferable(int length) { | 49 /* patch */ factory Uint8ClampedList.transferable(int length) { |
43 return new _Uint8ClampedArray.transferable(length); | 50 return _newTransferable(length); |
44 } | 51 } |
45 | 52 |
46 /* patch */ factory Uint8ClampedList.view(ByteArray array, | 53 /* patch */ factory Uint8ClampedList.view(ByteArray array, |
47 [int start = 0, int length]) { | 54 [int start = 0, int length]) { |
48 return new _Uint8ClampedArrayView(array, start, length); | 55 return new _Uint8ClampedArrayView(array, start, length); |
49 } | 56 } |
| 57 |
| 58 static _ExternalUint8ClampedArray _newTransferable(int length) |
| 59 native "Uint8ClampedArray_newTransferable"; |
50 } | 60 } |
51 | 61 |
52 | 62 |
53 patch class Int16List { | 63 patch class Int16List { |
54 /* patch */ factory Int16List(int length) { | 64 /* patch */ factory Int16List(int length) { |
55 return new _Int16Array(length); | 65 return new _Int16Array(length); |
56 } | 66 } |
57 | 67 |
58 /* patch */ factory Int16List.transferable(int length) { | 68 /* patch */ factory Int16List.transferable(int length) { |
59 return new _Int16Array.transferable(length); | 69 return _newTransferable(length); |
60 } | 70 } |
61 | 71 |
62 /* patch */ factory Int16List.view(ByteArray array, | 72 /* patch */ factory Int16List.view(ByteArray array, |
63 [int start = 0, int length]) { | 73 [int start = 0, int length]) { |
64 return new _Int16ArrayView(array, start, length); | 74 return new _Int16ArrayView(array, start, length); |
65 } | 75 } |
| 76 |
| 77 static _ExternalInt16Array _newTransferable(int length) |
| 78 native "Int16Array_newTransferable"; |
66 } | 79 } |
67 | 80 |
68 | 81 |
69 patch class Uint16List { | 82 patch class Uint16List { |
70 /* patch */ factory Uint16List(int length) { | 83 /* patch */ factory Uint16List(int length) { |
71 return new _Uint16Array(length); | 84 return new _Uint16Array(length); |
72 } | 85 } |
73 | 86 |
74 /* patch */ factory Uint16List.transferable(int length) { | 87 /* patch */ factory Uint16List.transferable(int length) { |
75 return new _Uint16Array.transferable(length); | 88 return _newTransferable(length); |
76 } | 89 } |
77 | 90 |
78 /* patch */ factory Uint16List.view(ByteArray array, | 91 /* patch */ factory Uint16List.view(ByteArray array, |
79 [int start = 0, int length]) { | 92 [int start = 0, int length]) { |
80 return new _Uint16ArrayView(array, start, length); | 93 return new _Uint16ArrayView(array, start, length); |
81 } | 94 } |
| 95 |
| 96 static _ExternalUint16Array _newTransferable(int length) |
| 97 native "Uint16Array_newTransferable"; |
82 } | 98 } |
83 | 99 |
84 | 100 |
85 patch class Int32List { | 101 patch class Int32List { |
86 /* patch */ factory Int32List(int length) { | 102 /* patch */ factory Int32List(int length) { |
87 return new _Int32Array(length); | 103 return new _Int32Array(length); |
88 } | 104 } |
89 | 105 |
90 /* patch */ factory Int32List.transferable(int length) { | 106 /* patch */ factory Int32List.transferable(int length) { |
91 return new _Int32Array.transferable(length); | 107 return _newTransferable(length); |
92 } | 108 } |
93 | 109 |
94 /* patch */ factory Int32List.view(ByteArray array, | 110 /* patch */ factory Int32List.view(ByteArray array, |
95 [int start = 0, int length]) { | 111 [int start = 0, int length]) { |
96 return new _Int32ArrayView(array, start, length); | 112 return new _Int32ArrayView(array, start, length); |
97 } | 113 } |
| 114 |
| 115 static _ExternalInt32Array _newTransferable(int length) |
| 116 native "Int32Array_newTransferable"; |
98 } | 117 } |
99 | 118 |
100 | 119 |
101 patch class Uint32List { | 120 patch class Uint32List { |
102 /* patch */ factory Uint32List(int length) { | 121 /* patch */ factory Uint32List(int length) { |
103 return new _Uint32Array(length); | 122 return new _Uint32Array(length); |
104 } | 123 } |
105 | 124 |
106 /* patch */ factory Uint32List.transferable(int length) { | 125 /* patch */ factory Uint32List.transferable(int length) { |
107 return new _Uint32Array.transferable(length); | 126 return _newTransferable(length); |
108 } | 127 } |
109 | 128 |
110 /* patch */ factory Uint32List.view(ByteArray array, | 129 /* patch */ factory Uint32List.view(ByteArray array, |
111 [int start = 0, int length]) { | 130 [int start = 0, int length]) { |
112 return new _Uint32ArrayView(array, start, length); | 131 return new _Uint32ArrayView(array, start, length); |
113 } | 132 } |
| 133 |
| 134 static _ExternalUint32Array _newTransferable(int length) |
| 135 native "Uint32Array_newTransferable"; |
114 } | 136 } |
115 | 137 |
116 | 138 |
117 patch class Int64List { | 139 patch class Int64List { |
118 /* patch */ factory Int64List(int length) { | 140 /* patch */ factory Int64List(int length) { |
119 return new _Int64Array(length); | 141 return new _Int64Array(length); |
120 } | 142 } |
121 | 143 |
122 /* patch */ factory Int64List.transferable(int length) { | 144 /* patch */ factory Int64List.transferable(int length) { |
123 return new _Int64Array.transferable(length); | 145 return _newTransferable(length); |
124 } | 146 } |
125 | 147 |
126 /* patch */ factory Int64List.view(ByteArray array, | 148 /* patch */ factory Int64List.view(ByteArray array, |
127 [int start = 0, int length]) { | 149 [int start = 0, int length]) { |
128 return new _Int64ArrayView(array, start, length); | 150 return new _Int64ArrayView(array, start, length); |
129 } | 151 } |
| 152 |
| 153 static _ExternalInt64Array _newTransferable(int length) |
| 154 native "Int64Array_newTransferable"; |
130 } | 155 } |
131 | 156 |
132 | 157 |
133 patch class Uint64List { | 158 patch class Uint64List { |
134 /* patch */ factory Uint64List(int length) { | 159 /* patch */ factory Uint64List(int length) { |
135 return new _Uint64Array(length); | 160 return new _Uint64Array(length); |
136 } | 161 } |
137 | 162 |
138 /* patch */ factory Uint64List.transferable(int length) { | 163 /* patch */ factory Uint64List.transferable(int length) { |
139 return new _Uint64Array.transferable(length); | 164 return _newTransferable(length); |
140 } | 165 } |
141 | 166 |
142 /* patch */ factory Uint64List.view(ByteArray array, | 167 /* patch */ factory Uint64List.view(ByteArray array, |
143 [int start = 0, int length]) { | 168 [int start = 0, int length]) { |
144 return new _Uint64ArrayView(array, start, length); | 169 return new _Uint64ArrayView(array, start, length); |
145 } | 170 } |
| 171 |
| 172 static _ExternalUint64Array _newTransferable(int length) |
| 173 native "Uint64Array_newTransferable"; |
146 } | 174 } |
147 | 175 |
148 | 176 |
149 patch class Float32List { | 177 patch class Float32List { |
150 /* patch */ factory Float32List(int length) { | 178 /* patch */ factory Float32List(int length) { |
151 return new _Float32Array(length); | 179 return new _Float32Array(length); |
152 } | 180 } |
153 | 181 |
154 /* patch */ factory Float32List.transferable(int length) { | 182 /* patch */ factory Float32List.transferable(int length) { |
155 return new _Float32Array.transferable(length); | 183 return _newTransferable(length); |
156 } | 184 } |
157 | 185 |
158 /* patch */ factory Float32List.view(ByteArray array, | 186 /* patch */ factory Float32List.view(ByteArray array, |
159 [int start = 0, int length]) { | 187 [int start = 0, int length]) { |
160 return new _Float32ArrayView(array, start, length); | 188 return new _Float32ArrayView(array, start, length); |
161 } | 189 } |
| 190 |
| 191 static _ExternalFloat32Array _newTransferable(int length) |
| 192 native "Float32Array_newTransferable"; |
162 } | 193 } |
163 | 194 |
164 | 195 |
165 patch class Float64List { | 196 patch class Float64List { |
166 /* patch */ factory Float64List(int length) { | 197 /* patch */ factory Float64List(int length) { |
167 return new _Float64Array(length); | 198 return new _Float64Array(length); |
168 } | 199 } |
169 | 200 |
170 /* patch */ factory Float64List.transferable(int length) { | 201 /* patch */ factory Float64List.transferable(int length) { |
171 return new _Float64Array.transferable(length); | 202 return _newTransferable(length); |
172 } | 203 } |
173 | 204 |
174 /* patch */ factory Float64List.view(ByteArray array, | 205 /* patch */ factory Float64List.view(ByteArray array, |
175 [int start = 0, int length]) { | 206 [int start = 0, int length]) { |
176 return new _Float64ArrayView(array, start, length); | 207 return new _Float64ArrayView(array, start, length); |
177 } | 208 } |
| 209 |
| 210 static _ExternalFloat64Array _newTransferable(int length) |
| 211 native "Float64Array_newTransferable"; |
178 } | 212 } |
179 | 213 |
180 | 214 |
181 abstract class _ByteArrayBase { | 215 abstract class _ByteArrayBase { |
182 int lengthInBytes(); | 216 int lengthInBytes(); |
183 | 217 |
184 int bytesPerElement(); | 218 int bytesPerElement(); |
185 | 219 |
186 operator[](int index); | 220 operator[](int index); |
187 | 221 |
(...skipping 302 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
490 } | 524 } |
491 throw new ArgumentError("$object is not an integer or null"); | 525 throw new ArgumentError("$object is not an integer or null"); |
492 } | 526 } |
493 | 527 |
494 | 528 |
495 class _Int8Array extends _ByteArrayBase implements Int8List { | 529 class _Int8Array extends _ByteArrayBase implements Int8List { |
496 factory _Int8Array(int length) { | 530 factory _Int8Array(int length) { |
497 return _new(length); | 531 return _new(length); |
498 } | 532 } |
499 | 533 |
500 factory _Int8Array.transferable(int length) { | |
501 return _newTransferable(length); | |
502 } | |
503 | |
504 factory _Int8Array.view(ByteArray array, [int start = 0, int length]) { | 534 factory _Int8Array.view(ByteArray array, [int start = 0, int length]) { |
505 if (length == null) { | 535 if (length == null) { |
506 length = array.lengthInBytes(); | 536 length = array.lengthInBytes(); |
507 } | 537 } |
508 return new _Int8ArrayView(array, start, length); | 538 return new _Int8ArrayView(array, start, length); |
509 } | 539 } |
510 | 540 |
511 int operator[](int index) { | 541 int operator[](int index) { |
512 return _getIndexed(index); | 542 return _getIndexed(index); |
513 } | 543 } |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
546 return _BYTES_PER_ELEMENT; | 576 return _BYTES_PER_ELEMENT; |
547 } | 577 } |
548 | 578 |
549 int lengthInBytes() { | 579 int lengthInBytes() { |
550 return _length() * _BYTES_PER_ELEMENT; | 580 return _length() * _BYTES_PER_ELEMENT; |
551 } | 581 } |
552 | 582 |
553 static const int _BYTES_PER_ELEMENT = 1; | 583 static const int _BYTES_PER_ELEMENT = 1; |
554 | 584 |
555 static _Int8Array _new(int length) native "Int8Array_new"; | 585 static _Int8Array _new(int length) native "Int8Array_new"; |
556 static _Int8Array _newTransferable(int length) | |
557 native "Int8Array_newTransferable"; | |
558 | 586 |
559 int _getIndexed(int index) native "Int8Array_getIndexed"; | 587 int _getIndexed(int index) native "Int8Array_getIndexed"; |
560 int _setIndexed(int index, int value) native "Int8Array_setIndexed"; | 588 int _setIndexed(int index, int value) native "Int8Array_setIndexed"; |
561 } | 589 } |
562 | 590 |
563 | 591 |
564 class _Uint8Array extends _ByteArrayBase implements Uint8List { | 592 class _Uint8Array extends _ByteArrayBase implements Uint8List { |
565 factory _Uint8Array(int length) { | 593 factory _Uint8Array(int length) { |
566 return _new(length); | 594 return _new(length); |
567 } | 595 } |
568 | 596 |
569 factory _Uint8Array.transferable(int length) { | |
570 return _newTransferable(length); | |
571 } | |
572 | |
573 factory _Uint8Array.view(ByteArray array, [int start = 0, int length]) { | 597 factory _Uint8Array.view(ByteArray array, [int start = 0, int length]) { |
574 if (length == null) { | 598 if (length == null) { |
575 length = array.lengthInBytes(); | 599 length = array.lengthInBytes(); |
576 } | 600 } |
577 return new _Uint8ArrayView(array, start, length); | 601 return new _Uint8ArrayView(array, start, length); |
578 } | 602 } |
579 | 603 |
580 int operator[](int index) { | 604 int operator[](int index) { |
581 return _getIndexed(index); | 605 return _getIndexed(index); |
582 } | 606 } |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
616 return _BYTES_PER_ELEMENT; | 640 return _BYTES_PER_ELEMENT; |
617 } | 641 } |
618 | 642 |
619 int lengthInBytes() { | 643 int lengthInBytes() { |
620 return _length() * _BYTES_PER_ELEMENT; | 644 return _length() * _BYTES_PER_ELEMENT; |
621 } | 645 } |
622 | 646 |
623 static const int _BYTES_PER_ELEMENT = 1; | 647 static const int _BYTES_PER_ELEMENT = 1; |
624 | 648 |
625 static _Uint8Array _new(int length) native "Uint8Array_new"; | 649 static _Uint8Array _new(int length) native "Uint8Array_new"; |
626 static _Uint8Array _newTransferable(int length) | |
627 native "Uint8Array_newTransferable"; | |
628 | 650 |
629 int _getIndexed(int index) native "Uint8Array_getIndexed"; | 651 int _getIndexed(int index) native "Uint8Array_getIndexed"; |
630 int _setIndexed(int index, int value) native "Uint8Array_setIndexed"; | 652 int _setIndexed(int index, int value) native "Uint8Array_setIndexed"; |
631 } | 653 } |
632 | 654 |
633 | 655 |
634 class _Uint8ClampedArray extends _ByteArrayBase implements Uint8ClampedList { | 656 class _Uint8ClampedArray extends _ByteArrayBase implements Uint8ClampedList { |
635 factory _Uint8ClampedArray(int length) { | 657 factory _Uint8ClampedArray(int length) { |
636 return _new(length); | 658 return _new(length); |
637 } | 659 } |
638 | 660 |
639 factory _Uint8ClampedArray.transferable(int length) { | |
640 return _newTransferable(length); | |
641 } | |
642 | |
643 factory _Uint8ClampedArray.view(ByteArray array, | 661 factory _Uint8ClampedArray.view(ByteArray array, |
644 [int start = 0, int length]) { | 662 [int start = 0, int length]) { |
645 if (length == null) { | 663 if (length == null) { |
646 length = array.lengthInBytes(); | 664 length = array.lengthInBytes(); |
647 } | 665 } |
648 return new _Uint8ClampedArrayView(array, start, length); | 666 return new _Uint8ClampedArrayView(array, start, length); |
649 } | 667 } |
650 | 668 |
651 int operator[](int index) { | 669 int operator[](int index) { |
652 return _getIndexed(index); | 670 return _getIndexed(index); |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
687 return _BYTES_PER_ELEMENT; | 705 return _BYTES_PER_ELEMENT; |
688 } | 706 } |
689 | 707 |
690 int lengthInBytes() { | 708 int lengthInBytes() { |
691 return _length() * _BYTES_PER_ELEMENT; | 709 return _length() * _BYTES_PER_ELEMENT; |
692 } | 710 } |
693 | 711 |
694 static const int _BYTES_PER_ELEMENT = 1; | 712 static const int _BYTES_PER_ELEMENT = 1; |
695 | 713 |
696 static _Uint8ClampedArray _new(int length) native "Uint8ClampedArray_new"; | 714 static _Uint8ClampedArray _new(int length) native "Uint8ClampedArray_new"; |
697 static _Uint8ClampedArray _newTransferable(int length) | |
698 native "Uint8ClampedArray_newTransferable"; | |
699 | 715 |
700 int _getIndexed(int index) native "Uint8ClampedArray_getIndexed"; | 716 int _getIndexed(int index) native "Uint8ClampedArray_getIndexed"; |
701 int _setIndexed(int index, int value) native "Uint8ClampedArray_setIndexed"; | 717 int _setIndexed(int index, int value) native "Uint8ClampedArray_setIndexed"; |
702 } | 718 } |
703 | 719 |
704 | 720 |
705 class _Int16Array extends _ByteArrayBase implements Int16List { | 721 class _Int16Array extends _ByteArrayBase implements Int16List { |
706 factory _Int16Array(int length) { | 722 factory _Int16Array(int length) { |
707 return _new(length); | 723 return _new(length); |
708 } | 724 } |
709 | 725 |
710 factory _Int16Array.transferable(int length) { | |
711 return _newTransferable(length); | |
712 } | |
713 | |
714 factory _Int16Array.view(ByteArray array, [int start = 0, int length]) { | 726 factory _Int16Array.view(ByteArray array, [int start = 0, int length]) { |
715 if (length == null) { | 727 if (length == null) { |
716 length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; | 728 length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; |
717 } | 729 } |
718 return new _Int16ArrayView(array, start, length); | 730 return new _Int16ArrayView(array, start, length); |
719 } | 731 } |
720 | 732 |
721 int operator[](int index) { | 733 int operator[](int index) { |
722 return _getIndexed(index); | 734 return _getIndexed(index); |
723 } | 735 } |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
756 return _BYTES_PER_ELEMENT; | 768 return _BYTES_PER_ELEMENT; |
757 } | 769 } |
758 | 770 |
759 int lengthInBytes() { | 771 int lengthInBytes() { |
760 return _length() * _BYTES_PER_ELEMENT; | 772 return _length() * _BYTES_PER_ELEMENT; |
761 } | 773 } |
762 | 774 |
763 static const int _BYTES_PER_ELEMENT = 2; | 775 static const int _BYTES_PER_ELEMENT = 2; |
764 | 776 |
765 static _Int16Array _new(int length) native "Int16Array_new"; | 777 static _Int16Array _new(int length) native "Int16Array_new"; |
766 static _Int16Array _newTransferable(int length) | |
767 native "Int16Array_newTransferable"; | |
768 | 778 |
769 int _getIndexed(int index) native "Int16Array_getIndexed"; | 779 int _getIndexed(int index) native "Int16Array_getIndexed"; |
770 int _setIndexed(int index, int value) native "Int16Array_setIndexed"; | 780 int _setIndexed(int index, int value) native "Int16Array_setIndexed"; |
771 } | 781 } |
772 | 782 |
773 | 783 |
774 class _Uint16Array extends _ByteArrayBase implements Uint16List { | 784 class _Uint16Array extends _ByteArrayBase implements Uint16List { |
775 factory _Uint16Array(int length) { | 785 factory _Uint16Array(int length) { |
776 return _new(length); | 786 return _new(length); |
777 } | 787 } |
778 | 788 |
779 factory _Uint16Array.transferable(int length) { | |
780 return _newTransferable(length); | |
781 } | |
782 | |
783 factory _Uint16Array.view(ByteArray array, [int start = 0, int length]) { | 789 factory _Uint16Array.view(ByteArray array, [int start = 0, int length]) { |
784 if (length == null) { | 790 if (length == null) { |
785 length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; | 791 length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; |
786 } | 792 } |
787 return new _Uint16ArrayView(array, start, length); | 793 return new _Uint16ArrayView(array, start, length); |
788 } | 794 } |
789 | 795 |
790 int operator[](int index) { | 796 int operator[](int index) { |
791 return _getIndexed(index); | 797 return _getIndexed(index); |
792 } | 798 } |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
825 return _BYTES_PER_ELEMENT; | 831 return _BYTES_PER_ELEMENT; |
826 } | 832 } |
827 | 833 |
828 int lengthInBytes() { | 834 int lengthInBytes() { |
829 return _length() * _BYTES_PER_ELEMENT; | 835 return _length() * _BYTES_PER_ELEMENT; |
830 } | 836 } |
831 | 837 |
832 static const int _BYTES_PER_ELEMENT = 2; | 838 static const int _BYTES_PER_ELEMENT = 2; |
833 | 839 |
834 static _Uint16Array _new(int length) native "Uint16Array_new"; | 840 static _Uint16Array _new(int length) native "Uint16Array_new"; |
835 static _Uint16Array _newTransferable(int length) | |
836 native "Uint16Array_newTransferable"; | |
837 | 841 |
838 int _getIndexed(int index) native "Uint16Array_getIndexed"; | 842 int _getIndexed(int index) native "Uint16Array_getIndexed"; |
839 int _setIndexed(int index, int value) native "Uint16Array_setIndexed"; | 843 int _setIndexed(int index, int value) native "Uint16Array_setIndexed"; |
840 } | 844 } |
841 | 845 |
842 | 846 |
843 class _Int32Array extends _ByteArrayBase implements Int32List { | 847 class _Int32Array extends _ByteArrayBase implements Int32List { |
844 factory _Int32Array(int length) { | 848 factory _Int32Array(int length) { |
845 return _new(length); | 849 return _new(length); |
846 } | 850 } |
847 | 851 |
848 factory _Int32Array.transferable(int length) { | |
849 return _newTransferable(length); | |
850 } | |
851 | |
852 factory _Int32Array.view(ByteArray array, [int start = 0, int length]) { | 852 factory _Int32Array.view(ByteArray array, [int start = 0, int length]) { |
853 if (length == null) { | 853 if (length == null) { |
854 length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; | 854 length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; |
855 } | 855 } |
856 return new _Int32ArrayView(array, start, length); | 856 return new _Int32ArrayView(array, start, length); |
857 } | 857 } |
858 | 858 |
859 int operator[](int index) { | 859 int operator[](int index) { |
860 return _getIndexed(index); | 860 return _getIndexed(index); |
861 } | 861 } |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
894 return _BYTES_PER_ELEMENT; | 894 return _BYTES_PER_ELEMENT; |
895 } | 895 } |
896 | 896 |
897 int lengthInBytes() { | 897 int lengthInBytes() { |
898 return _length() * _BYTES_PER_ELEMENT; | 898 return _length() * _BYTES_PER_ELEMENT; |
899 } | 899 } |
900 | 900 |
901 static const int _BYTES_PER_ELEMENT = 4; | 901 static const int _BYTES_PER_ELEMENT = 4; |
902 | 902 |
903 static _Int32Array _new(int length) native "Int32Array_new"; | 903 static _Int32Array _new(int length) native "Int32Array_new"; |
904 static _Int32Array _newTransferable(int length) | |
905 native "Int32Array_newTransferable"; | |
906 | 904 |
907 | 905 |
908 int _getIndexed(int index) native "Int32Array_getIndexed"; | 906 int _getIndexed(int index) native "Int32Array_getIndexed"; |
909 int _setIndexed(int index, int value) native "Int32Array_setIndexed"; | 907 int _setIndexed(int index, int value) native "Int32Array_setIndexed"; |
910 } | 908 } |
911 | 909 |
912 | 910 |
913 class _Uint32Array extends _ByteArrayBase implements Uint32List { | 911 class _Uint32Array extends _ByteArrayBase implements Uint32List { |
914 factory _Uint32Array(int length) { | 912 factory _Uint32Array(int length) { |
915 return _new(length); | 913 return _new(length); |
916 } | 914 } |
917 | 915 |
918 factory _Uint32Array.transferable(int length) { | |
919 return _newTransferable(length); | |
920 } | |
921 | |
922 factory _Uint32Array.view(ByteArray array, [int start = 0, int length]) { | 916 factory _Uint32Array.view(ByteArray array, [int start = 0, int length]) { |
923 if (length == null) { | 917 if (length == null) { |
924 length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; | 918 length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; |
925 } | 919 } |
926 return new _Uint32ArrayView(array, start, length); | 920 return new _Uint32ArrayView(array, start, length); |
927 } | 921 } |
928 | 922 |
929 int operator[](int index) { | 923 int operator[](int index) { |
930 return _getIndexed(index); | 924 return _getIndexed(index); |
931 } | 925 } |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
964 return _BYTES_PER_ELEMENT; | 958 return _BYTES_PER_ELEMENT; |
965 } | 959 } |
966 | 960 |
967 int lengthInBytes() { | 961 int lengthInBytes() { |
968 return _length() * _BYTES_PER_ELEMENT; | 962 return _length() * _BYTES_PER_ELEMENT; |
969 } | 963 } |
970 | 964 |
971 static const int _BYTES_PER_ELEMENT = 4; | 965 static const int _BYTES_PER_ELEMENT = 4; |
972 | 966 |
973 static _Uint32Array _new(int length) native "Uint32Array_new"; | 967 static _Uint32Array _new(int length) native "Uint32Array_new"; |
974 static _Uint32Array _newTransferable(int length) | |
975 native "Uint32Array_newTransferable"; | |
976 | 968 |
977 int _getIndexed(int index) native "Uint32Array_getIndexed"; | 969 int _getIndexed(int index) native "Uint32Array_getIndexed"; |
978 int _setIndexed(int index, int value) native "Uint32Array_setIndexed"; | 970 int _setIndexed(int index, int value) native "Uint32Array_setIndexed"; |
979 } | 971 } |
980 | 972 |
981 | 973 |
982 class _Int64Array extends _ByteArrayBase implements Int64List { | 974 class _Int64Array extends _ByteArrayBase implements Int64List { |
983 factory _Int64Array(int length) { | 975 factory _Int64Array(int length) { |
984 return _new(length); | 976 return _new(length); |
985 } | 977 } |
986 | 978 |
987 factory _Int64Array.transferable(int length) { | |
988 return _newTransferable(length); | |
989 } | |
990 | |
991 factory _Int64Array.view(ByteArray array, [int start = 0, int length]) { | 979 factory _Int64Array.view(ByteArray array, [int start = 0, int length]) { |
992 if (length == null) { | 980 if (length == null) { |
993 length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; | 981 length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; |
994 } | 982 } |
995 return new _Int64ArrayView(array, start, length); | 983 return new _Int64ArrayView(array, start, length); |
996 } | 984 } |
997 | 985 |
998 int operator[](int index) { | 986 int operator[](int index) { |
999 return _getIndexed(index); | 987 return _getIndexed(index); |
1000 } | 988 } |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1033 return _BYTES_PER_ELEMENT; | 1021 return _BYTES_PER_ELEMENT; |
1034 } | 1022 } |
1035 | 1023 |
1036 int lengthInBytes() { | 1024 int lengthInBytes() { |
1037 return _length() * _BYTES_PER_ELEMENT; | 1025 return _length() * _BYTES_PER_ELEMENT; |
1038 } | 1026 } |
1039 | 1027 |
1040 static const int _BYTES_PER_ELEMENT = 8; | 1028 static const int _BYTES_PER_ELEMENT = 8; |
1041 | 1029 |
1042 static _Int64Array _new(int length) native "Int64Array_new"; | 1030 static _Int64Array _new(int length) native "Int64Array_new"; |
1043 static _Int64Array _newTransferable(int length) | |
1044 native "Int64Array_newTransferable"; | |
1045 | 1031 |
1046 int _getIndexed(int index) native "Int64Array_getIndexed"; | 1032 int _getIndexed(int index) native "Int64Array_getIndexed"; |
1047 int _setIndexed(int index, int value) native "Int64Array_setIndexed"; | 1033 int _setIndexed(int index, int value) native "Int64Array_setIndexed"; |
1048 } | 1034 } |
1049 | 1035 |
1050 | 1036 |
1051 class _Uint64Array extends _ByteArrayBase implements Uint64List { | 1037 class _Uint64Array extends _ByteArrayBase implements Uint64List { |
1052 factory _Uint64Array(int length) { | 1038 factory _Uint64Array(int length) { |
1053 return _new(length); | 1039 return _new(length); |
1054 } | 1040 } |
1055 | 1041 |
1056 factory _Uint64Array.transferable(int length) { | |
1057 return _newTransferable(length); | |
1058 } | |
1059 | |
1060 factory _Uint64Array.view(ByteArray array, [int start = 0, int length]) { | 1042 factory _Uint64Array.view(ByteArray array, [int start = 0, int length]) { |
1061 if (length == null) { | 1043 if (length == null) { |
1062 length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; | 1044 length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; |
1063 } | 1045 } |
1064 return new _Uint64ArrayView(array, start, length); | 1046 return new _Uint64ArrayView(array, start, length); |
1065 } | 1047 } |
1066 | 1048 |
1067 int operator[](int index) { | 1049 int operator[](int index) { |
1068 return _getIndexed(index); | 1050 return _getIndexed(index); |
1069 } | 1051 } |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1102 return _BYTES_PER_ELEMENT; | 1084 return _BYTES_PER_ELEMENT; |
1103 } | 1085 } |
1104 | 1086 |
1105 int lengthInBytes() { | 1087 int lengthInBytes() { |
1106 return _length() * _BYTES_PER_ELEMENT; | 1088 return _length() * _BYTES_PER_ELEMENT; |
1107 } | 1089 } |
1108 | 1090 |
1109 static const int _BYTES_PER_ELEMENT = 8; | 1091 static const int _BYTES_PER_ELEMENT = 8; |
1110 | 1092 |
1111 static _Uint64Array _new(int length) native "Uint64Array_new"; | 1093 static _Uint64Array _new(int length) native "Uint64Array_new"; |
1112 static _Uint64Array _newTransferable(int length) | |
1113 native "Uint64Array_newTransferable"; | |
1114 | 1094 |
1115 int _getIndexed(int index) native "Uint64Array_getIndexed"; | 1095 int _getIndexed(int index) native "Uint64Array_getIndexed"; |
1116 int _setIndexed(int index, int value) native "Uint64Array_setIndexed"; | 1096 int _setIndexed(int index, int value) native "Uint64Array_setIndexed"; |
1117 } | 1097 } |
1118 | 1098 |
1119 | 1099 |
1120 class _Float32Array extends _ByteArrayBase implements Float32List { | 1100 class _Float32Array extends _ByteArrayBase implements Float32List { |
1121 factory _Float32Array(int length) { | 1101 factory _Float32Array(int length) { |
1122 return _new(length); | 1102 return _new(length); |
1123 } | 1103 } |
1124 | 1104 |
1125 factory _Float32Array.transferable(int length) { | |
1126 return _newTransferable(length); | |
1127 } | |
1128 | |
1129 factory _Float32Array.view(ByteArray array, [int start = 0, int length]) { | 1105 factory _Float32Array.view(ByteArray array, [int start = 0, int length]) { |
1130 if (length == null) { | 1106 if (length == null) { |
1131 length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; | 1107 length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; |
1132 } | 1108 } |
1133 return new _Float32ArrayView(array, start, length); | 1109 return new _Float32ArrayView(array, start, length); |
1134 } | 1110 } |
1135 | 1111 |
1136 double operator[](int index) { | 1112 double operator[](int index) { |
1137 return _getIndexed(index); | 1113 return _getIndexed(index); |
1138 } | 1114 } |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1171 return _BYTES_PER_ELEMENT; | 1147 return _BYTES_PER_ELEMENT; |
1172 } | 1148 } |
1173 | 1149 |
1174 int lengthInBytes() { | 1150 int lengthInBytes() { |
1175 return _length() * _BYTES_PER_ELEMENT; | 1151 return _length() * _BYTES_PER_ELEMENT; |
1176 } | 1152 } |
1177 | 1153 |
1178 static const int _BYTES_PER_ELEMENT = 4; | 1154 static const int _BYTES_PER_ELEMENT = 4; |
1179 | 1155 |
1180 static _Float32Array _new(int length) native "Float32Array_new"; | 1156 static _Float32Array _new(int length) native "Float32Array_new"; |
1181 static _Float32Array _newTransferable(int length) | |
1182 native "Float32Array_newTransferable"; | |
1183 | 1157 |
1184 double _getIndexed(int index) native "Float32Array_getIndexed"; | 1158 double _getIndexed(int index) native "Float32Array_getIndexed"; |
1185 int _setIndexed(int index, double value) native "Float32Array_setIndexed"; | 1159 int _setIndexed(int index, double value) native "Float32Array_setIndexed"; |
1186 } | 1160 } |
1187 | 1161 |
1188 | 1162 |
1189 class _Float64Array extends _ByteArrayBase implements Float64List { | 1163 class _Float64Array extends _ByteArrayBase implements Float64List { |
1190 factory _Float64Array(int length) { | 1164 factory _Float64Array(int length) { |
1191 return _new(length); | 1165 return _new(length); |
1192 } | 1166 } |
1193 | 1167 |
1194 factory _Float64Array.transferable(int length) { | |
1195 return _newTransferable(length); | |
1196 } | |
1197 | |
1198 factory _Float64Array.view(ByteArray array, [int start = 0, int length]) { | 1168 factory _Float64Array.view(ByteArray array, [int start = 0, int length]) { |
1199 if (length == null) { | 1169 if (length == null) { |
1200 length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; | 1170 length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; |
1201 } | 1171 } |
1202 return new _Float64ArrayView(array, start, length); | 1172 return new _Float64ArrayView(array, start, length); |
1203 } | 1173 } |
1204 | 1174 |
1205 double operator[](int index) { | 1175 double operator[](int index) { |
1206 return _getIndexed(index); | 1176 return _getIndexed(index); |
1207 } | 1177 } |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1240 return _BYTES_PER_ELEMENT; | 1210 return _BYTES_PER_ELEMENT; |
1241 } | 1211 } |
1242 | 1212 |
1243 int lengthInBytes() { | 1213 int lengthInBytes() { |
1244 return _length() * _BYTES_PER_ELEMENT; | 1214 return _length() * _BYTES_PER_ELEMENT; |
1245 } | 1215 } |
1246 | 1216 |
1247 static const int _BYTES_PER_ELEMENT = 8; | 1217 static const int _BYTES_PER_ELEMENT = 8; |
1248 | 1218 |
1249 static _Float64Array _new(int length) native "Float64Array_new"; | 1219 static _Float64Array _new(int length) native "Float64Array_new"; |
1250 static _Float64Array _newTransferable(int length) | |
1251 native "Float64Array_newTransferable"; | |
1252 | 1220 |
1253 double _getIndexed(int index) native "Float64Array_getIndexed"; | 1221 double _getIndexed(int index) native "Float64Array_getIndexed"; |
1254 int _setIndexed(int index, double value) native "Float64Array_setIndexed"; | 1222 int _setIndexed(int index, double value) native "Float64Array_setIndexed"; |
1255 } | 1223 } |
1256 | 1224 |
1257 | 1225 |
1258 class _ExternalInt8Array extends _ByteArrayBase implements Int8List { | 1226 class _ExternalInt8Array extends _ByteArrayBase implements Int8List { |
1259 int operator[](int index) { | 1227 int operator[](int index) { |
1260 return _getIndexed(index); | 1228 return _getIndexed(index); |
1261 } | 1229 } |
(...skipping 1440 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2702 ByteArray asByteArray([int start = 0, int length]) { | 2670 ByteArray asByteArray([int start = 0, int length]) { |
2703 if (length == null) { | 2671 if (length == null) { |
2704 length = this.lengthInBytes(); | 2672 length = this.lengthInBytes(); |
2705 } | 2673 } |
2706 _rangeCheck(this.length, start, length); | 2674 _rangeCheck(this.length, start, length); |
2707 return _array.subByteArray(_offset + start, length); | 2675 return _array.subByteArray(_offset + start, length); |
2708 } | 2676 } |
2709 | 2677 |
2710 static const int _BYTES_PER_ELEMENT = 8; | 2678 static const int _BYTES_PER_ELEMENT = 8; |
2711 } | 2679 } |
OLD | NEW |