lib/java/collections.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #     http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 # Basic Java collections
  16 #
  17 # ~~~
  18 # var coll = new JavaArray(2)
  19 #
  20 # assert coll[0].is_java_null
  21 # coll[0] = "zero".to_java_string
  22 # coll[1] = "one".to_java_string
  23 #
  24 # assert coll.length == 2
  25 # assert coll.first.to_s == "zero"
  26 # assert coll[1].to_s == "one"
  27 # assert [for e in coll do e.to_s] == ["zero", "one"]
  28 # ~~~
  29 module collections
  30
  31 import java
  32
  33 # Java primitive array
  34 #
  35 # These have fixed size so they offer the same services as `SequenceRead` and
  36 # `[]=`, but would not support `Sequence::add`.
  37 extern class AbstractJavaArray[E: Object]
  38         super SequenceRead[E]
  39         super JavaObject
  40
  41         # Set the `value` at `key`
  42         fun []=(key: Int, value: E) is abstract
  43
  44         redef fun iterator do return new JavaArrayIterator[E](self)
  45
  46         redef fun reverse_iterator do return new JavaArrayReverseIterator[E](self)
  47 end
  48
  49 # Java primitive array `int[]`
  50 extern class JavaIntArray in "Java" `{ int[] `}
  51         super AbstractJavaArray[Int]
  52
  53         # Get a new array of the given `size`
  54         new (size: Int) in "Java" `{ return new int[(int)size]; `}
  55
  56         redef fun [](i) in "Java" `{ return self[(int)i]; `}
  57
  58         redef fun []=(i, e) in "Java" `{ self[(int)i] = (int)e; `}
  59
  60         redef fun length in "Java" `{ return self.length; `}
  61 end
  62
  63 # Java primitive array `short[]`
  64 extern class JavaShortArray in "Java" `{ short[] `}
  65         super AbstractJavaArray[Int]
  66
  67         # Get a new array of the given `size`
  68         new (size: Int) in "Java" `{ return new short[(int)size]; `}
  69
  70         redef fun [](i) in "Java" `{ return (short)self[(int)i]; `}
  71
  72         redef fun []=(i, e) in "Java" `{ self[(int)i] = (short)e; `}
  73
  74         redef fun length in "Java" `{ return self.length; `}
  75 end
  76
  77 # Java primitive array `long[]`
  78 extern class JavaLongArray in "Java" `{ long[] `}
  79         super AbstractJavaArray[Int]
  80
  81         # Get a new array of the given `size`
  82         new (size: Int) in "Java" `{ return new long[(int)size]; `}
  83
  84         redef fun [](i) in "Java" `{ return self[(int)i]; `}
  85
  86         redef fun []=(i, e) in "Java" `{ self[(int)i] = (long)e; `}
  87
  88         redef fun length in "Java" `{ return self.length; `}
  89 end
  90
  91 # Java primitive array `float[]`
  92 #
  93 # Note that Nit `Float` is the size of a double, so storing them in a
  94 # `JavaFloatArray` may lead to a loss of precision.
  95 extern class JavaFloatArray in "Java" `{ float[] `}
  96         super AbstractJavaArray[Float]
  97
  98         # Get a new array of the given `size`
  99         new(size: Int) in "Java" `{ return new float[(int)size]; `}
 100
 101         redef fun [](i) in "Java" `{ return (double)self[(int)i]; `}
 102
 103         redef fun []=(i, e) in "Java" `{ self[(int)i] = (float)e; `}
 104
 105         redef fun length in "Java" `{ return self.length; `}
 106 end
 107
 108 # Java primitive array `double[]`
 109 extern class JavaDoubleArray in "Java" `{ double[] `}
 110         super AbstractJavaArray[Float]
 111
 112         # Get a new array of the given `size`
 113         new(size: Int) in "Java" `{ return new double[(int)size]; `}
 114
 115         redef fun [](i) in "Java" `{ return self[(int)i]; `}
 116
 117         redef fun []=(i, e) in "Java" `{ self[(int)i] = (float)e; `}
 118
 119         redef fun length in "Java" `{ return self.length; `}
 120 end
 121
 122 # Java primitive array `Object[]`
 123 extern class JavaArray in "Java" `{ java.lang.Object[] `}
 124         super AbstractJavaArray[JavaObject]
 125
 126         # Get a new array of the given `size`
 127         new(size: Int) in "Java" `{ return new Object[(int)size]; `}
 128
 129         redef fun [](i) in "Java" `{ return self[(int)i]; `}
 130
 131         redef fun []=(i, e) in "Java" `{ self[(int)i] = e; `}
 132
 133         redef fun length in "Java" `{ return self.length; `}
 134 end
 135
 136 # Java primitive array `boolean[]`
 137 extern class JavaBoolArray in "Java" `{ boolean[] `}
 138         super AbstractJavaArray[Bool]
 139
 140         # Get a new array of the given `size`
 141         new (size: Int) in "Java" `{ return new boolean[(int)size]; `}
 142
 143         redef fun [](i) in "Java" `{ return self[(int)i]; `}
 144
 145         redef fun []=(i, e) in "Java" `{self[(int)i] = (boolean)e; `}
 146
 147         redef fun length in "Java" `{ return self.length; `}
 148 end
 149
 150 # Java primitive array `byte[]`
 151 extern class JavaByteArray in "Java" `{ byte[] `}
 152         super AbstractJavaArray[Int]
 153
 154         # Get a new array of the given `size`
 155         new (size: Int) in "Java" `{ return new byte[(int)size]; `}
 156
 157         redef fun [](i) in "Java" `{ return (byte)self[(int)i]; `}
 158
 159         redef fun []=(i, e) in "Java" `{ self[(int)i] = (byte)e; `}
 160
 161         redef fun length in "Java" `{ return self.length; `}
 162 end
 163
 164 # Java primitive array `char[]`
 165 extern class JavaCharArray in "Java" `{ char[] `}
 166         super AbstractJavaArray[Char]
 167
 168         # Get a new array of the given `size`
 169         new (size: Int) in "Java" `{ return new char[(int)size]; `}
 170
 171         redef fun [](i) in "Java" `{ return (char)self[(int)i]; `}
 172
 173         redef fun []=(i, e) in "Java" `{ self[(int)i] = (char)e; `}
 174
 175         redef fun length in "Java" `{ return self.length; `}
 176 end
 177
 178 # An `Iterator` on Java primitive arrays
 179 private class JavaArrayIterator[E: Object]
 180         super IndexedIterator[E]
 181
 182         var array: AbstractJavaArray[E]
 183
 184         redef fun item do return array[index]
 185
 186         redef fun is_ok do return index < array.length
 187
 188         redef fun next do index += 1
 189
 190         redef var index = 0
 191 end
 192
 193 # A reverse `Iterator` on Java primitive arrays
 194 private class JavaArrayReverseIterator[E: Object]
 195         super IndexedIterator[E]
 196
 197         var array: AbstractJavaArray[E]
 198
 199         redef fun item do return array[index]
 200
 201         redef fun is_ok do return index >= 0
 202
 203         redef fun next do index -= 1
 204
 205         redef var index = array.length - 1
 206 end