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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
pragma License (Modified_GPL);
------------------------------------------------------------------------------
-- --
-- CHARLES CONTAINER LIBRARY --
-- --
-- Copyright (C) 2001-2004 Matthew J Heaney --
-- --
-- The Charles Container Library ("Charles") is free software; you can --
-- redistribute it and/or modify it under terms of the GNU General Public --
-- License as published by the Free Software Foundation; either version 2, --
-- or (at your option) any later version. Charles 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 General Public License for more details. You should have --
-- received a copy of the GNU General Public License distributed with --
-- Charles; see file COPYING.TXT. If not, write to the Free Software --
-- Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. --
-- --
-- As a special exception, if other files instantiate generics from this --
-- unit, or you link this unit with other files to produce an executable, --
-- this unit does not by itself cause the resulting executable to be --
-- covered by the GNU General Public License. This exception does not --
-- however invalidate any other reasons why the executable file might be --
-- covered by the GNU Public License. --
-- --
-- Charles is maintained by Matthew J Heaney. --
-- --
-- http://home.earthlink.net/~matthewjheaney/index.html --
-- mailto:matthewjheaney@earthlink.net --
-- --
------------------------------------------------------------------------------
generic
type Element_Type is private;
with function "=" (Left, Right : Element_Type)
return Boolean is <>;
package Charles.Lists.Single.Bounded is
pragma Pure (Bounded);
subtype Element_Subtype is Element_Type;
function Compare_Elements (Left, Right : Element_Type)
return Boolean renames "=";
type Container_Type (Size : Natural) is limited private;
type Iterator_Type is private;
Null_Iterator : constant Iterator_Type;
procedure Assign
(Target : in out Container_Type;
Source : in Container_Type);
function "=" (Left, Right : Container_Type) return Boolean;
generic
with function "<" (Left, Right : Element_Type) return Boolean is <>;
function Generic_Less (Left, Right : Container_Type) return Boolean;
function Length (Container : Container_Type) return Natural;
function Is_Empty (Container : Container_Type) return Boolean;
function Is_Full (Container : Container_Type) return Boolean;
procedure Clear (Container : in out Container_Type);
procedure Prepend
(Container : in out Container_Type;
New_Item : in Element_Type);
procedure Append
(Container : in out Container_Type;
New_Item : in Element_Type);
procedure Insert_After
(Container : in out Container_Type;
Position : in Iterator_Type;
New_Item : in Element_Type;
Iterator : out Iterator_Type);
procedure Insert_After
(Container : in out Container_Type;
Position : in Iterator_Type;
New_Item : in Element_Type);
procedure Insert_After
(Container : in out Container_Type;
Position : in Iterator_Type;
Iterator : out Iterator_Type);
procedure Delete_After
(Container : in out Container_Type;
Position : in Iterator_Type);
procedure Delete_First (Container : in out Container_Type);
procedure Delete
(Container : in out Container_Type;
Item : in Element_Type);
generic
with function Predicate (Element : Element_Type)
return Boolean is <>;
procedure Generic_Delete (Container : in out Container_Type);
procedure Delete_Duplicates (Container : in out Container_Type);
generic
with function Predicate (Left, Right : Element_Type)
return Boolean is <>;
procedure Generic_Delete_Duplicates (Container : in out Container_Type);
procedure Reverse_Container (Container : in out Container_Type);
generic
with function "<" (Left, Right : Element_Type)
return Boolean is <>;
procedure Generic_Sort (Container : in out Container_Type);
procedure Splice_After
(Container : in out Container_Type;
Position : in Iterator_Type;
Pred : in Iterator_Type);
function First (Container : Container_Type) return Iterator_Type;
function First_Element (Container : Container_Type) return Element_Type;
function Last (Container : Container_Type) return Iterator_Type;
function Last_Element (Container : Container_Type) return Element_Type;
function Back (Container : Container_Type) return Iterator_Type;
function Element
(Container : Container_Type;
Iterator : Iterator_Type) return Element_Type;
generic
type Element_Access is access all Element_Type;
function Generic_Element
(Container : Container_Type;
Iterator : Iterator_Type) return Element_Access;
procedure Replace_Element
(Container : in Container_Type;
Iterator : in Iterator_Type;
By : in Element_Type);
function Is_In
(Item : Element_Type;
Container : Container_Type) return Boolean;
function Find
(Container : Container_Type;
Item : Element_Type;
Position : Iterator_Type := Null_Iterator) return Iterator_Type;
generic
with function Predicate (Element : Element_Type)
return Boolean is <>;
function Generic_Find
(Container : Container_Type;
Position : Iterator_Type := Null_Iterator) return Iterator_Type;
function Succ
(Container : Container_Type;
Iterator : Iterator_Type) return Iterator_Type;
function Pred
(Container : Container_Type;
Iterator : Iterator_Type) return Iterator_Type;
procedure Increment
(Container : in Container_Type;
Iterator : in out Iterator_Type);
procedure Decrement
(Container : in Container_Type;
Iterator : in out Iterator_Type);
generic
with procedure Process (Iterator : Iterator_Type) is <>;
procedure Generic_Iteration (Container : in Container_Type);
private
type Node_Type is
limited record
Element : aliased Element_Type;
Next : Natural;
end record;
type Node_Array is array (Positive range <>) of Node_Type;
type Handle_Type (Container : access Container_Type) is
limited null record;
type Container_Type (Size : Natural) is
limited record
Handle : Handle_Type (Container_Type'Access);
Nodes : Node_Array (1 .. Size);
Free : Integer := -1;
First : Natural := 0;
Last : Natural := 0;
Length : Natural := 0;
end record;
type Iterator_Type is
record
Index : Natural := 0;
end record;
Null_Iterator : constant Iterator_Type := (Index => 0);
end Charles.Lists.Single.Bounded;
|
