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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
/* list.vala
*
* Copyright (C) 2007 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Author:
* Jürg Billeter <j@bitron.ch>
*/
/**
* An ordered collection.
*/
[GenericAccessors]
public interface Gee.List<G> : Collection<G> {
/**
* Returns a ListIterator that can be used for iteration over this list.
*
* @return a ListIterator that can be used for iteration over this list
*/
public abstract new ListIterator<G> list_iterator ();
/**
* Returns the item at the specified index in this list.
*
* @param index zero-based index of the item to be returned
*
* @return the item at the specified index in the list
*/
public abstract G get (int index);
/**
* Sets the item at the specified index in this list.
*
* @param index zero-based index of the item to be set
*/
public abstract void set (int index, G item);
/**
* Returns the index of the first occurrence of the specified item in
* this list.
*
* @return the index of the first occurrence of the specified item, or
* -1 if the item could not be found
*/
public abstract int index_of (G item);
/**
* Inserts an item into this list at the specified position.
*
* @param index zero-based index at which item is inserted
* @param item item to insert into the list
*/
public abstract void insert (int index, G item);
/**
* Removes the item at the specified index of this list.
*
* @param index zero-based index of the item to be removed
*
* @return the removed element
*/
public abstract G remove_at (int index);
/**
* Returns a slice of this list.
*
* @param start zero-based index of the slice's first element
* @param stop zero-based index of the position after the end of the slice
*
* @return A list containing a slice of this list
*/
public abstract List<G>? slice (int start, int stop);
/**
* Returns the first item of the list. Fails if the list is empty.
*
* @return first item in the list
*/
public virtual G first () {
return get (0);
}
/**
* Returns the last item of the list. Fails if the list is empty.
*
* @return last item in the list
*/
public virtual G last () {
return get (size - 1);
}
/**
* Inserts items into this list for the input collection at the
* specified position.
*
* @param index zero-based index of the items to be inserted
* @param collection collection of items to be inserted
*/
public virtual void insert_all (int index, Collection<G> collection) {
foreach (G item in collection) {
insert(index, item);
index++;
}
}
/**
* Sorts items by comparing with the specified compare function.
*
* @param compare_func compare function to use to compare items
*/
public virtual void sort (owned CompareDataFunc<G>? compare_func = null) {
if (compare_func == null) {
compare_func = Functions.get_compare_func_for (typeof (G));
}
TimSort.sort<G> (this, compare_func);
}
/**
* The read-only view of this list.
*/
public abstract new List<G> read_only_view { owned get; }
/**
* Returns an immutable empty list.
*
* @return an immutable empty list
*/
public static List<G> empty<G> () {
return new LinkedList<G> ().read_only_view;
}
}
|
