1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
import org.xiph.system.Bytes;
import flash.Vector;
class ArrayTools {
public static function
alloc<T>(size : Int, ?fill = true, ?value = null) : Array<T> {
return _alloc(size, fill, value);
}
public static inline function
_alloc<T>(size : Int, fill : Bool, value : T) : Array<T> {
var b : Array<T> = new Array<T>();
if (fill) {
var i : Int = 0;
while (i < size) {
b[i] = value;
i++;
}
} else {
b[size - 1] = value;
}
return b;
}
public static inline function
arraycopy<T>(src : Array<T>, src_pos : Int,
dst : Array<T>, dst_pos : Int, length : Int) : Void
{
var srci : Int;
var n : Int;
var dsti : Int;
if (src == dst && dst_pos > src_pos) {
srci = src_pos + length;
n = src_pos;
dsti = dst_pos + length;
while (srci > n) {
dst[--dsti] = src[--srci];
}
} else {
srci = src_pos;
n = src_pos + length;
dsti = dst_pos;
while (srci < n) {
dst[dsti++] = src[srci++];
}
}
}
public static inline function
copy<T>(src : Array<T>, src_pos : Int,
dst : Array<T>, dst_pos : Int, length : Int) : Array<T>
{
var b : Array<T>;
var src_end : Int = src_pos + length;
if (dst_pos > 0) {
b = dst.slice(0, dst_pos).concat(src.slice(src_pos, src_end));
} else {
b = src.slice(src_pos, src_end);
}
if (dst_pos + length < dst.length) {
b = b.concat(dst.slice(dst_pos + length));
}
return b;
}
/* I'm not sure why would anybody need the methods below... */
public static function
allocI(size : Int, ?fill = true, ?value = 0) : Array<Int> {
return _allocI(size, fill, value);
}
public static inline function
_allocI(size : Int, fill : Bool, value : Int) : Array<Int> {
var b : Array<Int> = new Array();
if (fill) {
var i : Int = 0;
while (i < size) {
b[i] = value;
i++;
}
} else {
b[size - 1] = value;
}
return b;
}
public static function
allocF(size : Int, ?fill = true, ?value = 0.0) : Array<Float> {
return _allocF(size, fill, value);
}
public static inline function
_allocF(size : Int, fill : Bool, value : Float) : Array<Float> {
var b : Array<Float> = new Array();
if (fill) {
var i : Int = 0;
while (i < size) {
b[i] = value;
i++;
}
} else {
b[size - 1] = value;
}
return b;
}
}
|