]>
Commit | Line | Data |
---|---|---|
1e194575 AC |
1 | ------------------------------------------------------------------------------ |
2 | -- -- | |
3 | -- GNAT LIBRARY COMPONENTS -- | |
4 | -- -- | |
5 | -- A D A . C O N T A I N E R S . B O U N D E D _ V E C T O R S -- | |
6 | -- -- | |
7 | -- S p e c -- | |
8 | -- -- | |
4b490c1e | 9 | -- Copyright (C) 2004-2020, Free Software Foundation, Inc. -- |
1e194575 AC |
10 | -- -- |
11 | -- This specification is derived from the Ada Reference Manual for use with -- | |
12 | -- GNAT. The copyright notice above, and the license provisions that follow -- | |
13 | -- apply solely to the contents of the part following the private keyword. -- | |
14 | -- -- | |
15 | -- GNAT is free software; you can redistribute it and/or modify it under -- | |
16 | -- terms of the GNU General Public License as published by the Free Soft- -- | |
17 | -- ware Foundation; either version 3, or (at your option) any later ver- -- | |
18 | -- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- | |
19 | -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- | |
20 | -- or FITNESS FOR A PARTICULAR PURPOSE. -- | |
21 | -- -- | |
22 | -- As a special exception under Section 7 of GPL version 3, you are granted -- | |
23 | -- additional permissions described in the GCC Runtime Library Exception, -- | |
24 | -- version 3.1, as published by the Free Software Foundation. -- | |
25 | -- -- | |
26 | -- You should have received a copy of the GNU General Public License and -- | |
27 | -- a copy of the GCC Runtime Library Exception along with this program; -- | |
28 | -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- | |
29 | -- <http://www.gnu.org/licenses/>. -- | |
30 | -- -- | |
31 | -- This unit was originally developed by Matthew J Heaney. -- | |
32 | ------------------------------------------------------------------------------ | |
33 | ||
a6dd3a54 | 34 | with Ada.Iterator_Interfaces; |
1e194575 | 35 | |
1f8f3e6e | 36 | with Ada.Containers.Helpers; |
3c24c853 | 37 | private with Ada.Streams; |
e2441021 | 38 | private with Ada.Finalization; |
3c24c853 | 39 | |
1e194575 AC |
40 | generic |
41 | type Index_Type is range <>; | |
42 | type Element_Type is private; | |
43 | ||
44 | with function "=" (Left, Right : Element_Type) return Boolean is <>; | |
45 | ||
46 | package Ada.Containers.Bounded_Vectors is | |
6031f544 | 47 | pragma Annotate (CodePeer, Skip_Analysis); |
1e194575 AC |
48 | pragma Pure; |
49 | pragma Remote_Types; | |
50 | ||
51 | subtype Extended_Index is Index_Type'Base | |
52 | range Index_Type'First - 1 .. | |
53 | Index_Type'Min (Index_Type'Base'Last - 1, Index_Type'Last) + 1; | |
54 | ||
55 | No_Index : constant Extended_Index := Extended_Index'First; | |
56 | ||
d85fd922 | 57 | type Vector (Capacity : Count_Type) is tagged private with |
a6dd3a54 ES |
58 | Constant_Indexing => Constant_Reference, |
59 | Variable_Indexing => Reference, | |
60 | Default_Iterator => Iterate, | |
61 | Iterator_Element => Element_Type; | |
62 | ||
1e194575 AC |
63 | pragma Preelaborable_Initialization (Vector); |
64 | ||
65 | type Cursor is private; | |
66 | pragma Preelaborable_Initialization (Cursor); | |
67 | ||
68 | Empty_Vector : constant Vector; | |
69 | ||
70 | No_Element : constant Cursor; | |
3c24c853 | 71 | |
a6dd3a54 ES |
72 | function Has_Element (Position : Cursor) return Boolean; |
73 | ||
74 | package Vector_Iterator_Interfaces is new | |
75 | Ada.Iterator_Interfaces (Cursor, Has_Element); | |
1e194575 AC |
76 | |
77 | overriding function "=" (Left, Right : Vector) return Boolean; | |
78 | ||
79 | function To_Vector (Length : Count_Type) return Vector; | |
80 | ||
81 | function To_Vector | |
82 | (New_Item : Element_Type; | |
83 | Length : Count_Type) return Vector; | |
84 | ||
85 | function "&" (Left, Right : Vector) return Vector; | |
86 | ||
87 | function "&" (Left : Vector; Right : Element_Type) return Vector; | |
88 | ||
89 | function "&" (Left : Element_Type; Right : Vector) return Vector; | |
90 | ||
91 | function "&" (Left, Right : Element_Type) return Vector; | |
92 | ||
93 | function Capacity (Container : Vector) return Count_Type; | |
94 | ||
95 | procedure Reserve_Capacity | |
96 | (Container : in out Vector; | |
97 | Capacity : Count_Type); | |
98 | ||
99 | function Length (Container : Vector) return Count_Type; | |
100 | ||
101 | procedure Set_Length | |
102 | (Container : in out Vector; | |
103 | Length : Count_Type); | |
104 | ||
105 | function Is_Empty (Container : Vector) return Boolean; | |
106 | ||
107 | procedure Clear (Container : in out Vector); | |
108 | ||
109 | function To_Cursor | |
110 | (Container : Vector; | |
111 | Index : Extended_Index) return Cursor; | |
112 | ||
113 | function To_Index (Position : Cursor) return Extended_Index; | |
114 | ||
115 | function Element | |
116 | (Container : Vector; | |
117 | Index : Index_Type) return Element_Type; | |
118 | ||
119 | function Element (Position : Cursor) return Element_Type; | |
120 | ||
121 | procedure Replace_Element | |
122 | (Container : in out Vector; | |
123 | Index : Index_Type; | |
124 | New_Item : Element_Type); | |
125 | ||
126 | procedure Replace_Element | |
127 | (Container : in out Vector; | |
128 | Position : Cursor; | |
129 | New_Item : Element_Type); | |
130 | ||
131 | procedure Query_Element | |
132 | (Container : Vector; | |
133 | Index : Index_Type; | |
134 | Process : not null access procedure (Element : Element_Type)); | |
135 | ||
136 | procedure Query_Element | |
137 | (Position : Cursor; | |
138 | Process : not null access procedure (Element : Element_Type)); | |
139 | ||
140 | procedure Update_Element | |
141 | (Container : in out Vector; | |
142 | Index : Index_Type; | |
143 | Process : not null access procedure (Element : in out Element_Type)); | |
144 | ||
145 | procedure Update_Element | |
146 | (Container : in out Vector; | |
147 | Position : Cursor; | |
148 | Process : not null access procedure (Element : in out Element_Type)); | |
149 | ||
c9423ca3 AC |
150 | type Constant_Reference_Type |
151 | (Element : not null access constant Element_Type) is | |
152 | private | |
153 | with | |
154 | Implicit_Dereference => Element; | |
155 | ||
c9423ca3 AC |
156 | type Reference_Type (Element : not null access Element_Type) is private |
157 | with | |
158 | Implicit_Dereference => Element; | |
159 | ||
c9423ca3 AC |
160 | function Constant_Reference |
161 | (Container : aliased Vector; | |
162 | Position : Cursor) return Constant_Reference_Type; | |
163 | ||
164 | function Reference | |
165 | (Container : aliased in out Vector; | |
166 | Position : Cursor) return Reference_Type; | |
167 | ||
168 | function Constant_Reference | |
169 | (Container : aliased Vector; | |
170 | Index : Index_Type) return Constant_Reference_Type; | |
171 | ||
172 | function Reference | |
173 | (Container : aliased in out Vector; | |
174 | Index : Index_Type) return Reference_Type; | |
175 | ||
1e194575 AC |
176 | procedure Assign (Target : in out Vector; Source : Vector); |
177 | ||
178 | function Copy (Source : Vector; Capacity : Count_Type := 0) return Vector; | |
179 | ||
180 | procedure Move (Target : in out Vector; Source : in out Vector); | |
181 | ||
182 | procedure Insert | |
183 | (Container : in out Vector; | |
184 | Before : Extended_Index; | |
185 | New_Item : Vector); | |
186 | ||
187 | procedure Insert | |
188 | (Container : in out Vector; | |
189 | Before : Cursor; | |
190 | New_Item : Vector); | |
191 | ||
192 | procedure Insert | |
193 | (Container : in out Vector; | |
194 | Before : Cursor; | |
195 | New_Item : Vector; | |
196 | Position : out Cursor); | |
197 | ||
198 | procedure Insert | |
199 | (Container : in out Vector; | |
200 | Before : Extended_Index; | |
201 | New_Item : Element_Type; | |
202 | Count : Count_Type := 1); | |
203 | ||
204 | procedure Insert | |
205 | (Container : in out Vector; | |
206 | Before : Cursor; | |
207 | New_Item : Element_Type; | |
208 | Count : Count_Type := 1); | |
209 | ||
210 | procedure Insert | |
211 | (Container : in out Vector; | |
212 | Before : Cursor; | |
213 | New_Item : Element_Type; | |
214 | Position : out Cursor; | |
215 | Count : Count_Type := 1); | |
216 | ||
217 | procedure Insert | |
218 | (Container : in out Vector; | |
219 | Before : Extended_Index; | |
220 | Count : Count_Type := 1); | |
221 | ||
222 | procedure Insert | |
223 | (Container : in out Vector; | |
224 | Before : Cursor; | |
225 | Position : out Cursor; | |
226 | Count : Count_Type := 1); | |
227 | ||
228 | procedure Prepend | |
229 | (Container : in out Vector; | |
230 | New_Item : Vector); | |
231 | ||
232 | procedure Prepend | |
233 | (Container : in out Vector; | |
234 | New_Item : Element_Type; | |
235 | Count : Count_Type := 1); | |
236 | ||
237 | procedure Append | |
238 | (Container : in out Vector; | |
239 | New_Item : Vector); | |
240 | ||
241 | procedure Append | |
242 | (Container : in out Vector; | |
243 | New_Item : Element_Type; | |
244 | Count : Count_Type := 1); | |
245 | ||
246 | procedure Insert_Space | |
247 | (Container : in out Vector; | |
248 | Before : Extended_Index; | |
249 | Count : Count_Type := 1); | |
250 | ||
251 | procedure Insert_Space | |
252 | (Container : in out Vector; | |
253 | Before : Cursor; | |
254 | Position : out Cursor; | |
255 | Count : Count_Type := 1); | |
256 | ||
257 | procedure Delete | |
258 | (Container : in out Vector; | |
259 | Index : Extended_Index; | |
260 | Count : Count_Type := 1); | |
261 | ||
262 | procedure Delete | |
263 | (Container : in out Vector; | |
264 | Position : in out Cursor; | |
265 | Count : Count_Type := 1); | |
266 | ||
267 | procedure Delete_First | |
268 | (Container : in out Vector; | |
269 | Count : Count_Type := 1); | |
270 | ||
271 | procedure Delete_Last | |
272 | (Container : in out Vector; | |
273 | Count : Count_Type := 1); | |
274 | ||
275 | procedure Reverse_Elements (Container : in out Vector); | |
276 | ||
277 | procedure Swap (Container : in out Vector; I, J : Index_Type); | |
278 | ||
279 | procedure Swap (Container : in out Vector; I, J : Cursor); | |
280 | ||
281 | function First_Index (Container : Vector) return Index_Type; | |
282 | ||
283 | function First (Container : Vector) return Cursor; | |
284 | ||
285 | function First_Element (Container : Vector) return Element_Type; | |
286 | ||
287 | function Last_Index (Container : Vector) return Extended_Index; | |
288 | ||
289 | function Last (Container : Vector) return Cursor; | |
290 | ||
291 | function Last_Element (Container : Vector) return Element_Type; | |
292 | ||
293 | function Next (Position : Cursor) return Cursor; | |
294 | ||
295 | procedure Next (Position : in out Cursor); | |
296 | ||
297 | function Previous (Position : Cursor) return Cursor; | |
298 | ||
299 | procedure Previous (Position : in out Cursor); | |
300 | ||
301 | function Find_Index | |
302 | (Container : Vector; | |
303 | Item : Element_Type; | |
304 | Index : Index_Type := Index_Type'First) return Extended_Index; | |
305 | ||
306 | function Find | |
307 | (Container : Vector; | |
308 | Item : Element_Type; | |
309 | Position : Cursor := No_Element) return Cursor; | |
310 | ||
311 | function Reverse_Find_Index | |
312 | (Container : Vector; | |
313 | Item : Element_Type; | |
314 | Index : Index_Type := Index_Type'Last) return Extended_Index; | |
315 | ||
316 | function Reverse_Find | |
317 | (Container : Vector; | |
318 | Item : Element_Type; | |
319 | Position : Cursor := No_Element) return Cursor; | |
320 | ||
321 | function Contains | |
322 | (Container : Vector; | |
323 | Item : Element_Type) return Boolean; | |
324 | ||
1e194575 AC |
325 | procedure Iterate |
326 | (Container : Vector; | |
327 | Process : not null access procedure (Position : Cursor)); | |
328 | ||
329 | procedure Reverse_Iterate | |
330 | (Container : Vector; | |
331 | Process : not null access procedure (Position : Cursor)); | |
332 | ||
d85fd922 AC |
333 | function Iterate |
334 | (Container : Vector) | |
a6dd3a54 ES |
335 | return Vector_Iterator_Interfaces.Reversible_Iterator'Class; |
336 | ||
d85fd922 AC |
337 | function Iterate |
338 | (Container : Vector; | |
339 | Start : Cursor) | |
a6dd3a54 ES |
340 | return Vector_Iterator_Interfaces.Reversible_Iterator'class; |
341 | ||
1e194575 AC |
342 | generic |
343 | with function "<" (Left, Right : Element_Type) return Boolean is <>; | |
344 | package Generic_Sorting is | |
345 | ||
346 | function Is_Sorted (Container : Vector) return Boolean; | |
347 | ||
348 | procedure Sort (Container : in out Vector); | |
349 | ||
350 | procedure Merge (Target : in out Vector; Source : in out Vector); | |
351 | ||
352 | end Generic_Sorting; | |
353 | ||
354 | private | |
355 | ||
356 | pragma Inline (First_Index); | |
357 | pragma Inline (Last_Index); | |
358 | pragma Inline (Element); | |
359 | pragma Inline (First_Element); | |
360 | pragma Inline (Last_Element); | |
361 | pragma Inline (Query_Element); | |
362 | pragma Inline (Update_Element); | |
363 | pragma Inline (Replace_Element); | |
364 | pragma Inline (Is_Empty); | |
365 | pragma Inline (Contains); | |
366 | pragma Inline (Next); | |
367 | pragma Inline (Previous); | |
368 | ||
14f73211 BD |
369 | use Ada.Containers.Helpers; |
370 | package Implementation is new Generic_Implementation; | |
371 | use Implementation; | |
372 | ||
3c24c853 | 373 | use Ada.Streams; |
e2441021 | 374 | use Ada.Finalization; |
3c24c853 | 375 | |
a6dd3a54 | 376 | type Elements_Array is array (Count_Type range <>) of aliased Element_Type; |
1e194575 AC |
377 | function "=" (L, R : Elements_Array) return Boolean is abstract; |
378 | ||
379 | type Vector (Capacity : Count_Type) is tagged record | |
0580d807 | 380 | Elements : Elements_Array (1 .. Capacity) := (others => <>); |
1e194575 | 381 | Last : Extended_Index := No_Index; |
14f73211 | 382 | TC : aliased Tamper_Counts; |
1e194575 AC |
383 | end record; |
384 | ||
1e194575 AC |
385 | procedure Write |
386 | (Stream : not null access Root_Stream_Type'Class; | |
387 | Container : Vector); | |
388 | ||
389 | for Vector'Write use Write; | |
390 | ||
391 | procedure Read | |
392 | (Stream : not null access Root_Stream_Type'Class; | |
393 | Container : out Vector); | |
394 | ||
395 | for Vector'Read use Read; | |
396 | ||
397 | type Vector_Access is access all Vector; | |
398 | for Vector_Access'Storage_Size use 0; | |
399 | ||
400 | type Cursor is record | |
401 | Container : Vector_Access; | |
402 | Index : Index_Type := Index_Type'First; | |
403 | end record; | |
404 | ||
405 | procedure Write | |
406 | (Stream : not null access Root_Stream_Type'Class; | |
407 | Position : Cursor); | |
408 | ||
409 | for Cursor'Write use Write; | |
410 | ||
411 | procedure Read | |
412 | (Stream : not null access Root_Stream_Type'Class; | |
413 | Position : out Cursor); | |
414 | ||
415 | for Cursor'Read use Read; | |
416 | ||
14f73211 BD |
417 | subtype Reference_Control_Type is Implementation.Reference_Control_Type; |
418 | -- It is necessary to rename this here, so that the compiler can find it | |
3bd783ec | 419 | |
a6dd3a54 | 420 | type Constant_Reference_Type |
db222ead AC |
421 | (Element : not null access constant Element_Type) is |
422 | record | |
423 | Control : Reference_Control_Type := | |
424 | raise Program_Error with "uninitialized reference"; | |
425 | -- The RM says, "The default initialization of an object of | |
426 | -- type Constant_Reference_Type or Reference_Type propagates | |
427 | -- Program_Error." | |
428 | end record; | |
a6dd3a54 | 429 | |
3c24c853 MH |
430 | procedure Read |
431 | (Stream : not null access Root_Stream_Type'Class; | |
432 | Item : out Constant_Reference_Type); | |
433 | ||
434 | for Constant_Reference_Type'Read use Read; | |
435 | ||
436 | procedure Write | |
437 | (Stream : not null access Root_Stream_Type'Class; | |
438 | Item : Constant_Reference_Type); | |
439 | ||
440 | for Constant_Reference_Type'Write use Write; | |
441 | ||
3bd783ec | 442 | type Reference_Type (Element : not null access Element_Type) is record |
db222ead AC |
443 | Control : Reference_Control_Type := |
444 | raise Program_Error with "uninitialized reference"; | |
445 | -- The RM says, "The default initialization of an object of | |
446 | -- type Constant_Reference_Type or Reference_Type propagates | |
447 | -- Program_Error." | |
3bd783ec | 448 | end record; |
a6dd3a54 | 449 | |
3c24c853 MH |
450 | procedure Read |
451 | (Stream : not null access Root_Stream_Type'Class; | |
452 | Item : out Reference_Type); | |
453 | ||
454 | for Reference_Type'Read use Read; | |
455 | ||
456 | procedure Write | |
457 | (Stream : not null access Root_Stream_Type'Class; | |
458 | Item : Reference_Type); | |
459 | ||
460 | for Reference_Type'Write use Write; | |
461 | ||
14f73211 BD |
462 | -- Three operations are used to optimize in the expansion of "for ... of" |
463 | -- loops: the Next(Cursor) procedure in the visible part, and the following | |
464 | -- Pseudo_Reference and Get_Element_Access functions. See Exp_Ch5 for | |
465 | -- details. | |
466 | ||
467 | function Pseudo_Reference | |
468 | (Container : aliased Vector'Class) return Reference_Control_Type; | |
469 | pragma Inline (Pseudo_Reference); | |
470 | -- Creates an object of type Reference_Control_Type pointing to the | |
471 | -- container, and increments the Lock. Finalization of this object will | |
472 | -- decrement the Lock. | |
473 | ||
474 | type Element_Access is access all Element_Type with | |
475 | Storage_Size => 0; | |
476 | ||
477 | function Get_Element_Access | |
478 | (Position : Cursor) return not null Element_Access; | |
479 | -- Returns a pointer to the element designated by Position. | |
480 | ||
1e194575 AC |
481 | Empty_Vector : constant Vector := (Capacity => 0, others => <>); |
482 | ||
483 | No_Element : constant Cursor := Cursor'(null, Index_Type'First); | |
484 | ||
e2441021 AC |
485 | type Iterator is new Limited_Controlled and |
486 | Vector_Iterator_Interfaces.Reversible_Iterator with | |
487 | record | |
488 | Container : Vector_Access; | |
489 | Index : Index_Type'Base; | |
14f73211 BD |
490 | end record |
491 | with Disable_Controlled => not T_Check; | |
e2441021 AC |
492 | |
493 | overriding procedure Finalize (Object : in out Iterator); | |
494 | ||
495 | overriding function First (Object : Iterator) return Cursor; | |
496 | overriding function Last (Object : Iterator) return Cursor; | |
497 | ||
498 | overriding function Next | |
499 | (Object : Iterator; | |
500 | Position : Cursor) return Cursor; | |
501 | ||
502 | overriding function Previous | |
503 | (Object : Iterator; | |
504 | Position : Cursor) return Cursor; | |
505 | ||
1e194575 | 506 | end Ada.Containers.Bounded_Vectors; |