Arrays have a literal representation.
var a = [12, 32, 8]
# is equivalent with:
var b = new Array[Int]
b.push(12)
b.push(32)
b.push(8)
assert a == b
core :: Array :: defaultinit
core :: Array :: filled_with
Create an array ofcount
elements
core :: Array :: with_capacity
Create an empty array with a given capacity.core :: Array :: with_native
Create a array filled with a given native array.pthreads :: concurrent_collections $ Array :: CONCURRENT
Type of the concurrent variant of this collectionandroid :: bundle $ Array :: add_to_bundle
Called by[]=
to dynamically choose the appropriate method according
pthreads :: redef_collections $ Array :: insert_all
Insert all elements at a given position, following elements are shifted.pthreads :: concurrent_collections $ Array :: to_concurrent
Wrapsself
in a thread-safe collection
array_debug :: array_debug $ Array :: to_s
User readable representation ofself
.
core :: Collection :: CONCURRENT
Type of the concurrent variant of this collectionserialization :: Serializable :: accept_json_serializer
Refinable service to customize the serialization of this class to JSONserialization :: Serializable :: accept_msgpack_attribute_counter
Hook to customize the behavior of theAttributeCounter
serialization :: Serializable :: accept_msgpack_serializer
Hook to customize the serialization of this class to MessagePackserialization :: Serializable :: add_to_bundle
Called by[]=
to dynamically choose the appropriate method according
core :: Object :: class_factory
Implementation used byget_class
to create the specific class.
core :: Collection :: combinations
Allr
-length combinations on self (in same order) without repeated elements.
core :: Collection :: combinations_with_replacement
Allr
-length combination on self (in same order) with repeated elements.
core :: AbstractArrayRead :: copy_to
Copy a portion ofself
to an other array.
serialization :: Serializable :: core_serialize_to
Actual serialization ofself
to serializer
core :: Array :: defaultinit
core :: AbstractArray :: defaultinit
core :: Sequence :: defaultinit
core :: SimpleCollection :: defaultinit
core :: Object :: defaultinit
core :: Cloneable :: defaultinit
core :: AbstractArrayRead :: defaultinit
core :: SequenceRead :: defaultinit
core :: Collection :: defaultinit
core :: AbstractArray :: enlarge
Force the capacity to be at leastcap
.
core :: Array :: filled_with
Create an array ofcount
elements
serialization :: Serializable :: from_deserializer
Create an instance of this class from thedeserializer
core :: SequenceRead :: get_or_default
Try to get an element, returndefault
if the index
is invalid.
core :: SequenceRead :: get_or_null
Try to get an element, returnnull
if the index
is invalid.
core :: Collection :: has_all
Does the collection contain at least each element ofother
?
core :: Collection :: has_any
Does the collection contain at least one element ofother
?
core :: Collection :: has_exactly
Does the collection contain exactly all the elements ofother
?
core :: SequenceRead :: index_of_from
The index of the first occurrence ofitem
, starting from pos.
core :: Sequence :: insert_all
Insert all elements at a given position, following elements are shifted.core :: Object :: is_same_instance
Return true ifself
and other
are the same instance (i.e. same identity).
core :: Object :: is_same_serialized
Isself
the same as other
in a serialization context?
core :: Object :: is_same_type
Return true ifself
and other
have the same dynamic type.
core :: SequenceRead :: iterator_from
Gets a new Iterator starting at positionpos
core :: SequenceRead :: last_index_of
The index of the last occurrence ofitem
.
core :: SequenceRead :: last_index_of_from
The index of the last occurrence ofitem
starting from pos
and decrementing.
core :: AbstractArrayRead :: length=
core :: SequenceRead :: modulo_index
Returns the real index for a modulo index.serialization :: Serializable :: msgpack_extra_array_items
Hook to request a larger than usual metadata arraycore :: Object :: output_class_name
Display class name on stdout (debug only).core :: Collection :: permutations
Allr
-length permutations on self (all possible ordering) without repeated elements.
core :: Collection :: product
Cartesian product, overr
times self
.
core :: RemovableCollection :: remove
Remove an occurrence ofitem
core :: RemovableCollection :: remove_all
Remove all occurrences ofitem
core :: SequenceRead :: reverse_iterator
Gets an iterator starting at the end and going backwardscore :: SequenceRead :: reverse_iterator_from
Gets an iterator on the chars of self starting frompos
serialization :: Serializable :: serialize_msgpack
Serializeself
to MessagePack bytes
serialization :: Serializable :: serialize_to
Serializeself
to serializer
serialization :: Serializable :: serialize_to_json
Serializeself
to JSON
core :: Collection :: to_concurrent
Wrapsself
in a thread-safe collection
core :: Collection :: to_counter
Create and fill up a counter with the elements of `self.core :: Collection :: to_curlslist
Convert Collection[String] to CURLSListserialization :: Serializable :: to_pretty_json
Serializeself
to plain pretty JSON
core :: Collection :: to_shuffle
Return a new array made of elements in a random order.core :: Array :: with_capacity
Create an empty array with a given capacity.core :: Array :: with_native
Create a array filled with a given native array.Serializer::serialize
# Resizable one dimension array of objects.
#
# Arrays have a literal representation.
#
# var a = [12, 32, 8]
# # is equivalent with:
# var b = new Array[Int]
# b.push(12)
# b.push(32)
# b.push(8)
# assert a == b
class Array[E]
super AbstractArray[E]
super Cloneable
redef fun [](index)
do
assert index: index >= 0 and index < _length
return _items.as(not null)[index]
end
redef fun []=(index, item)
do
assert index: index >= 0 and index < _length + 1
if _capacity <= index then
enlarge(index + 1)
end
if _length <= index then
_length = index + 1
end
_items.as(not null)[index] = item
end
redef fun add(item)
do
var l = _length
if _capacity <= l then
enlarge(l + 1)
end
_length = l + 1
_items.as(not null)[l] = item
end
# Slight optimization for arrays
redef fun add_all(items)
do
var l = _length
var nl = l + items.length
if _capacity < nl then
enlarge nl
end
if items isa Array[E] then
var k = 0
while l < nl do
_items.as(not null)[l] = items._items.as(not null)[k]
l += 1
k += 1
end
else
for item in items do
_items.as(not null)[l] = item
l += 1
end
end
_length = nl
end
redef fun copy_to(start, len, dest, new_start)
do
# Fast code when source and destination are two arrays
if not dest isa Array[E] then
super
return
end
# Enlarge dest if required
var dest_len = new_start + len
if dest_len > dest.length then
dest.enlarge(dest_len)
dest.length = dest_len
end
# Get underlying native arrays
var items = self.items
if items == null then return
var dest_items = dest.items
assert dest_items != null
# Native copy
items.memmove(start, len, dest_items, new_start)
end
redef fun enlarge(cap)
do
var c = _capacity
if cap <= c then return
while c <= cap do c = c * 2 + 2
var a = new NativeArray[E](c)
if _capacity > 0 then _items.as(not null).copy_to(a, _length)
_items = a
_capacity = c
end
# Create an empty array.
init
do
_capacity = 0
_length = 0
end
# Create an array from a collection.
init from(items: Collection[E]) do
with_capacity(items.length)
self.add_all(items)
end
# Create an array with some `objects`.
init with_items(objects: E...)
do
_items = objects._items
_capacity = objects._capacity
_length = objects.length
end
# Create an empty array with a given capacity.
init with_capacity(cap: Int)
do
assert positive: cap >= 0
_items = new NativeArray[E](cap)
_capacity = cap
_length = 0
end
# Create an array of `count` elements
init filled_with(value: E, count: Int)
do
assert positive: count >= 0
_items = new NativeArray[E](count)
_capacity = count
_length = count
var i = 0
while i < count do
self[i] = value
i += 1
end
end
# Create a array filled with a given native array.
init with_native(nat: NativeArray[E], size: Int)
do
assert positive: size >= 0
_items = nat
_capacity = size
_length = size
end
# The internal storage.
private var items: nullable NativeArray[E] = null
# The size of `_items`.
private var capacity: Int = 0
redef fun ==(o)
do
if not o isa Array[nullable Object] then return super
# Efficient implementation
var l = length
if l != o.length then return false
if l == 0 then return true
var i = 0
var it = _items.as(not null)
var oit = o._items.as(not null)
while i < l do
if it[i] != oit[i] then return false
i += 1
end
return true
end
# Shallow clone of `self`
#
# ~~~
# var a = [1,2,3]
# var b = a.clone
# assert a == b
# a.add 4
# assert a != b
# b.add 4
# assert a == b
# ~~~
#
# Note that the clone is shallow and elements are shared between `self` and the result.
#
# ~~~
# var aa = [a]
# var bb = aa.clone
# assert aa == bb
# aa.first.add 5
# assert aa == bb
# ~~~
redef fun clone do return to_a
# Concatenation of arrays.
#
# Returns a new array built by concatenating `self` and `other` together.
#
# var a1 = [1,2,3]
# var a2 = [4,5,6]
# var a3 = a1 + a2
# assert a3 == [1,2,3,4,5,6]
#
# Because a new array is always created, future modification on `self` and `other`
# does not impact the previously computed result.
#
# a1.add(30)
# a2.add(60)
# assert a3 == [1,2,3,4,5,6] # unchanged
# assert a1 + a2 == [1,2,3,30,4,5,6,60]
fun +(other: Array[E]): Array[E]
do
var res = new Array[E].with_capacity(length + other.length)
res.append(self)
res.append(other)
return res
end
# Repetition of arrays.
#
# returns a new array built by concatenating `self` `repeat` times.
#
# var a = [1,2,3]
# assert (a * 0).is_empty
# assert a * 1 == [1,2,3]
# assert a * 2 == [1,2,3,1,2,3]
# assert (a * 10).length == 30
fun *(repeat: Int): Array[E]
do
assert repeat >= 0
var res = new Array[E].with_capacity(length * repeat)
while repeat > 0 do
res.add_all(self)
repeat -= 1
end
return res
end
end
lib/core/collection/array.nit:306,1--554,3
redef class Array[E]
# Fast implementation
redef fun plain_to_s
do
var l = _length
if l == 0 then return ""
var its = _items.as(not null)
var first = its[0]
if l == 1 then if first == null then return "" else return first.to_s
var na = new NativeArray[String](l)
var i = 0
var sl = 0
var mypos = 0
while i < l do
var itsi = its[i]
if itsi == null then
i += 1
continue
end
var tmp = itsi.to_s
sl += tmp.byte_length
na[mypos] = tmp
i += 1
mypos += 1
end
var ns = new CString(sl + 1)
ns[sl] = 0
i = 0
var off = 0
while i < mypos do
var tmp = na[i]
if tmp isa FlatString then
var tpl = tmp._byte_length
tmp._items.copy_to(ns, tpl, tmp._first_byte, off)
off += tpl
else
for j in tmp.substrings do
var s = j.as(FlatString)
var slen = s._byte_length
s._items.copy_to(ns, slen, s._first_byte, off)
off += slen
end
end
i += 1
end
return new FlatString.with_infos(ns, sl, 0)
end
end
lib/core/text/flat.nit:1483,1--1531,3
redef class Array[E]
# Sort an array through a `for` abuse.
# The user uses the provided query (item) to implements its own comparison
#
# var a = [1, 3, 2]
# for q in a.sort_fa do q.res = q.a <=> q.b
# assert a == [1, 2, 3]
#
# Implements a sort by permutation.
fun sort_fa: ForAbuser[CompareQuery[E]]
do
return new SortAbuser[E](self)
end
end
lib/for_abuse/for_abuse.nit:137,1--150,3
# Thread-safe refinements of most of the known methods (except `enlarge`)
redef class Array
var mutex = new Mutex
redef fun add(e)
do
mutex.lock
super
mutex.unlock
end
redef fun []=(index, e)
do
mutex.lock
super
mutex.unlock
end
redef fun [](index)
do
mutex.lock
var r = super
mutex.unlock
return r
end
redef fun remove_at(index)
do
mutex.lock
super
mutex.unlock
end
redef fun shift
do
mutex.lock
var r = super
mutex.unlock
return r
end
redef fun unshift(e)
do
mutex.lock
super
mutex.unlock
end
redef fun insert_all(from, pos)
do
mutex.lock
super
mutex.unlock
end
redef fun swap_at(a, b)
do
mutex.lock
super
mutex.unlock
end
redef fun ==(o)
do
mutex.lock
var r = super
mutex.unlock
return r
end
redef fun enlarge(cap)
do
mutex.lock
super
mutex.unlock
end
end
lib/pthreads/redef_collections.nit:36,1--112,3
redef class Array
# Sorts an array with a function.
#
# ~~~~nitish
# class Person
# var name: String
# end
#
# def get_name(p: Person) do return p.name
#
# var ps = [new Person("Turing"), new Person("Curry"), new Person("Alfredo")]
# ps.sort_with(&get_name)
# assert ps[0].name == "Alfredo"
# assert ps[1].name == "Curry"
# assert ps[2].name == "Turing"
# ~~~~
fun sort_with(f: Fun1[E, Comparable])
do
var cmp = new ComparatorWith[E](f)
if length > 1 then
cmp.quick_sort(self, 0, length - 1)
end
end
end
lib/functional/iter_extras.nit:23,1--47,3
redef class Array[E]
redef type CONCURRENT: ConcurrentArray[E]
redef fun to_concurrent do return new ConcurrentArray[E].wrap(self)
end
lib/pthreads/concurrent_collections.nit:56,1--60,3
redef class Array[E]
redef fun add_to_bundle(bundle, key)
do
if self isa Array[Bool] then
bundle.put_boolean_array(key, self)
else if self isa Array[Int] then
bundle.put_long_array(key, self)
else if self isa Array[Float] then
bundle.put_double_array(key, self)
else if self isa Array[Char] then
bundle.put_char_array(key, self)
else if self isa Array[String] then
sys.jni_env.push_local_frame(self.length)
var java_string_array = new Array[JavaString]
for element in self do
java_string_array.push(element.to_s.to_java_string)
end
bundle.put_string_array(key, java_string_array)
else if self isa Array[Serializable] then
sys.jni_env.push_local_frame(self.length)
var java_string_array = new Array[JavaString]
for element in self do
var serialized_string = new StringWriter
var serializer = new JsonSerializer(serialized_string)
serializer.serialize(element)
java_string_array.add(serialized_string.to_s.to_java_string)
end
bundle.put_string_array(key, java_string_array)
end
end
end
lib/android/bundle/bundle.nit:721,1--755,3