OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [ada/] [a-cobove.ads] - Blame information for rev 706

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 706 jeremybenn
------------------------------------------------------------------------------
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
--                                                                          --
9
--          Copyright (C) 2004-2012, Free Software Foundation, Inc.         --
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
 
34
with Ada.Iterator_Interfaces;
35
 
36
private with Ada.Streams;
37
 
38
generic
39
   type Index_Type is range <>;
40
   type Element_Type is private;
41
 
42
   with function "=" (Left, Right : Element_Type) return Boolean is <>;
43
 
44
package Ada.Containers.Bounded_Vectors is
45
   pragma Pure;
46
   pragma Remote_Types;
47
 
48
   subtype Extended_Index is Index_Type'Base
49
     range Index_Type'First - 1 ..
50
           Index_Type'Min (Index_Type'Base'Last - 1, Index_Type'Last) + 1;
51
 
52
   No_Index : constant Extended_Index := Extended_Index'First;
53
 
54
   type Vector (Capacity : Count_Type) is tagged private with
55
      Constant_Indexing => Constant_Reference,
56
      Variable_Indexing => Reference,
57
      Default_Iterator  => Iterate,
58
      Iterator_Element  => Element_Type;
59
 
60
   pragma Preelaborable_Initialization (Vector);
61
 
62
   type Cursor is private;
63
   pragma Preelaborable_Initialization (Cursor);
64
 
65
   Empty_Vector : constant Vector;
66
 
67
   No_Element : constant Cursor;
68
 
69
   function Has_Element (Position : Cursor) return Boolean;
70
 
71
   package Vector_Iterator_Interfaces is new
72
      Ada.Iterator_Interfaces (Cursor, Has_Element);
73
 
74
   overriding function "=" (Left, Right : Vector) return Boolean;
75
 
76
   function To_Vector (Length : Count_Type) return Vector;
77
 
78
   function To_Vector
79
     (New_Item : Element_Type;
80
      Length   : Count_Type) return Vector;
81
 
82
   function "&" (Left, Right : Vector) return Vector;
83
 
84
   function "&" (Left : Vector; Right : Element_Type) return Vector;
85
 
86
   function "&" (Left : Element_Type; Right : Vector) return Vector;
87
 
88
   function "&" (Left, Right : Element_Type) return Vector;
89
 
90
   function Capacity (Container : Vector) return Count_Type;
91
 
92
   procedure Reserve_Capacity
93
     (Container : in out Vector;
94
      Capacity  : Count_Type);
95
 
96
   function Length (Container : Vector) return Count_Type;
97
 
98
   procedure Set_Length
99
     (Container : in out Vector;
100
      Length    : Count_Type);
101
 
102
   function Is_Empty (Container : Vector) return Boolean;
103
 
104
   procedure Clear (Container : in out Vector);
105
 
106
   function To_Cursor
107
     (Container : Vector;
108
      Index     : Extended_Index) return Cursor;
109
 
110
   function To_Index (Position : Cursor) return Extended_Index;
111
 
112
   function Element
113
     (Container : Vector;
114
      Index     : Index_Type) return Element_Type;
115
 
116
   function Element (Position : Cursor) return Element_Type;
117
 
118
   procedure Replace_Element
119
     (Container : in out Vector;
120
      Index     : Index_Type;
121
      New_Item  : Element_Type);
122
 
123
   procedure Replace_Element
124
     (Container : in out Vector;
125
      Position  : Cursor;
126
      New_Item  : Element_Type);
127
 
128
   procedure Query_Element
129
     (Container : Vector;
130
      Index     : Index_Type;
131
      Process   : not null access procedure (Element : Element_Type));
132
 
133
   procedure Query_Element
134
     (Position : Cursor;
135
      Process  : not null access procedure (Element : Element_Type));
136
 
137
   procedure Update_Element
138
     (Container : in out Vector;
139
      Index     : Index_Type;
140
      Process   : not null access procedure (Element : in out Element_Type));
141
 
142
   procedure Update_Element
143
     (Container : in out Vector;
144
      Position  : Cursor;
145
      Process   : not null access procedure (Element : in out Element_Type));
146
 
147
   type Constant_Reference_Type
148
      (Element : not null access constant Element_Type) is
149
   private
150
   with
151
      Implicit_Dereference => Element;
152
 
153
   type Reference_Type (Element : not null access Element_Type) is private
154
   with
155
      Implicit_Dereference => Element;
156
 
157
   function Constant_Reference
158
     (Container : aliased Vector;
159
      Position  : Cursor) return Constant_Reference_Type;
160
 
161
   function Reference
162
     (Container : aliased in out Vector;
163
      Position  : Cursor) return Reference_Type;
164
 
165
   function Constant_Reference
166
     (Container : aliased Vector;
167
      Index     : Index_Type) return Constant_Reference_Type;
168
 
169
   function Reference
170
     (Container : aliased in out Vector;
171
      Index     : Index_Type) return Reference_Type;
172
 
173
   procedure Assign (Target : in out Vector; Source : Vector);
174
 
175
   function Copy (Source : Vector; Capacity : Count_Type := 0) return Vector;
176
 
177
   procedure Move (Target : in out Vector; Source : in out Vector);
178
 
179
   procedure Insert
180
     (Container : in out Vector;
181
      Before    : Extended_Index;
182
      New_Item  : Vector);
183
 
184
   procedure Insert
185
     (Container : in out Vector;
186
      Before    : Cursor;
187
      New_Item  : Vector);
188
 
189
   procedure Insert
190
     (Container : in out Vector;
191
      Before    : Cursor;
192
      New_Item  : Vector;
193
      Position  : out Cursor);
194
 
195
   procedure Insert
196
     (Container : in out Vector;
197
      Before    : Extended_Index;
198
      New_Item  : Element_Type;
199
      Count     : Count_Type := 1);
200
 
201
   procedure Insert
202
     (Container : in out Vector;
203
      Before    : Cursor;
204
      New_Item  : Element_Type;
205
      Count     : Count_Type := 1);
206
 
207
   procedure Insert
208
     (Container : in out Vector;
209
      Before    : Cursor;
210
      New_Item  : Element_Type;
211
      Position  : out Cursor;
212
      Count     : Count_Type := 1);
213
 
214
   procedure Insert
215
     (Container : in out Vector;
216
      Before    : Extended_Index;
217
      Count     : Count_Type := 1);
218
 
219
   procedure Insert
220
     (Container : in out Vector;
221
      Before    : Cursor;
222
      Position  : out Cursor;
223
      Count     : Count_Type := 1);
224
 
225
   procedure Prepend
226
     (Container : in out Vector;
227
      New_Item  : Vector);
228
 
229
   procedure Prepend
230
     (Container : in out Vector;
231
      New_Item  : Element_Type;
232
      Count     : Count_Type := 1);
233
 
234
   procedure Append
235
     (Container : in out Vector;
236
      New_Item  : Vector);
237
 
238
   procedure Append
239
     (Container : in out Vector;
240
      New_Item  : Element_Type;
241
      Count     : Count_Type := 1);
242
 
243
   procedure Insert_Space
244
     (Container : in out Vector;
245
      Before    : Extended_Index;
246
      Count     : Count_Type := 1);
247
 
248
   procedure Insert_Space
249
     (Container : in out Vector;
250
      Before    : Cursor;
251
      Position  : out Cursor;
252
      Count     : Count_Type := 1);
253
 
254
   procedure Delete
255
     (Container : in out Vector;
256
      Index     : Extended_Index;
257
      Count     : Count_Type := 1);
258
 
259
   procedure Delete
260
     (Container : in out Vector;
261
      Position  : in out Cursor;
262
      Count     : Count_Type := 1);
263
 
264
   procedure Delete_First
265
     (Container : in out Vector;
266
      Count     : Count_Type := 1);
267
 
268
   procedure Delete_Last
269
     (Container : in out Vector;
270
      Count     : Count_Type := 1);
271
 
272
   procedure Reverse_Elements (Container : in out Vector);
273
 
274
   procedure Swap (Container : in out Vector; I, J : Index_Type);
275
 
276
   procedure Swap (Container : in out Vector; I, J : Cursor);
277
 
278
   function First_Index (Container : Vector) return Index_Type;
279
 
280
   function First (Container : Vector) return Cursor;
281
 
282
   function First_Element (Container : Vector) return Element_Type;
283
 
284
   function Last_Index (Container : Vector) return Extended_Index;
285
 
286
   function Last (Container : Vector) return Cursor;
287
 
288
   function Last_Element (Container : Vector) return Element_Type;
289
 
290
   function Next (Position : Cursor) return Cursor;
291
 
292
   procedure Next (Position : in out Cursor);
293
 
294
   function Previous (Position : Cursor) return Cursor;
295
 
296
   procedure Previous (Position : in out Cursor);
297
 
298
   function Find_Index
299
     (Container : Vector;
300
      Item      : Element_Type;
301
      Index     : Index_Type := Index_Type'First) return Extended_Index;
302
 
303
   function Find
304
     (Container : Vector;
305
      Item      : Element_Type;
306
      Position  : Cursor := No_Element) return Cursor;
307
 
308
   function Reverse_Find_Index
309
     (Container : Vector;
310
      Item      : Element_Type;
311
      Index     : Index_Type := Index_Type'Last) return Extended_Index;
312
 
313
   function Reverse_Find
314
     (Container : Vector;
315
      Item      : Element_Type;
316
      Position  : Cursor := No_Element) return Cursor;
317
 
318
   function Contains
319
     (Container : Vector;
320
      Item      : Element_Type) return Boolean;
321
 
322
   procedure Iterate
323
     (Container : Vector;
324
      Process   : not null access procedure (Position : Cursor));
325
 
326
   procedure Reverse_Iterate
327
     (Container : Vector;
328
      Process   : not null access procedure (Position : Cursor));
329
 
330
   function Iterate
331
     (Container : Vector)
332
      return Vector_Iterator_Interfaces.Reversible_Iterator'Class;
333
 
334
   function Iterate
335
     (Container : Vector;
336
      Start     : Cursor)
337
      return Vector_Iterator_Interfaces.Reversible_Iterator'class;
338
 
339
   generic
340
      with function "<" (Left, Right : Element_Type) return Boolean is <>;
341
   package Generic_Sorting is
342
 
343
      function Is_Sorted (Container : Vector) return Boolean;
344
 
345
      procedure Sort (Container : in out Vector);
346
 
347
      procedure Merge (Target : in out Vector; Source : in out Vector);
348
 
349
   end Generic_Sorting;
350
 
351
private
352
 
353
   pragma Inline (First_Index);
354
   pragma Inline (Last_Index);
355
   pragma Inline (Element);
356
   pragma Inline (First_Element);
357
   pragma Inline (Last_Element);
358
   pragma Inline (Query_Element);
359
   pragma Inline (Update_Element);
360
   pragma Inline (Replace_Element);
361
   pragma Inline (Is_Empty);
362
   pragma Inline (Contains);
363
   pragma Inline (Next);
364
   pragma Inline (Previous);
365
 
366
   use Ada.Streams;
367
 
368
   type Elements_Array is array (Count_Type range <>) of aliased Element_Type;
369
   function "=" (L, R : Elements_Array) return Boolean is abstract;
370
 
371
   type Vector (Capacity : Count_Type) is tagged record
372
      Elements : Elements_Array (1 .. Capacity) := (others => <>);
373
      Last     : Extended_Index := No_Index;
374
      Busy     : Natural := 0;
375
      Lock     : Natural := 0;
376
   end record;
377
 
378
   procedure Write
379
     (Stream    : not null access Root_Stream_Type'Class;
380
      Container : Vector);
381
 
382
   for Vector'Write use Write;
383
 
384
   procedure Read
385
     (Stream    : not null access Root_Stream_Type'Class;
386
      Container : out Vector);
387
 
388
   for Vector'Read use Read;
389
 
390
   type Vector_Access is access all Vector;
391
   for Vector_Access'Storage_Size use 0;
392
 
393
   type Cursor is record
394
      Container : Vector_Access;
395
      Index     : Index_Type := Index_Type'First;
396
   end record;
397
 
398
   procedure Write
399
     (Stream   : not null access Root_Stream_Type'Class;
400
      Position : Cursor);
401
 
402
   for Cursor'Write use Write;
403
 
404
   procedure Read
405
     (Stream   : not null access Root_Stream_Type'Class;
406
      Position : out Cursor);
407
 
408
   for Cursor'Read use Read;
409
 
410
   type Constant_Reference_Type
411
      (Element : not null access constant Element_Type) is null record;
412
 
413
   procedure Read
414
     (Stream : not null access Root_Stream_Type'Class;
415
      Item   : out Constant_Reference_Type);
416
 
417
   for Constant_Reference_Type'Read use Read;
418
 
419
   procedure Write
420
     (Stream : not null access Root_Stream_Type'Class;
421
      Item   : Constant_Reference_Type);
422
 
423
   for Constant_Reference_Type'Write use Write;
424
 
425
   type Reference_Type
426
      (Element : not null access Element_Type) is null record;
427
 
428
   procedure Read
429
     (Stream : not null access Root_Stream_Type'Class;
430
      Item   : out Reference_Type);
431
 
432
   for Reference_Type'Read use Read;
433
 
434
   procedure Write
435
     (Stream : not null access Root_Stream_Type'Class;
436
      Item   : Reference_Type);
437
 
438
   for Reference_Type'Write use Write;
439
 
440
   Empty_Vector : constant Vector := (Capacity => 0, others => <>);
441
 
442
   No_Element : constant Cursor := Cursor'(null, Index_Type'First);
443
 
444
end Ada.Containers.Bounded_Vectors;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.