Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * Simple list facilities for frontend code
4 : *
5 : * Data structures for simple lists of OIDs and strings. The support for
6 : * these is very primitive compared to the backend's List facilities, but
7 : * it's all we need in, eg, pg_dump.
8 : *
9 : *
10 : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
11 : * Portions Copyright (c) 1994, Regents of the University of California
12 : *
13 : * src/fe_utils/simple_list.c
14 : *
15 : *-------------------------------------------------------------------------
16 : */
17 : #include "postgres_fe.h"
18 :
19 : #include "fe_utils/simple_list.h"
20 :
21 :
22 : /*
23 : * Append an OID to the list.
24 : */
25 : void
26 0 : simple_oid_list_append(SimpleOidList *list, Oid val)
27 : {
28 0 : SimpleOidListCell *cell;
29 :
30 0 : cell = (SimpleOidListCell *) pg_malloc(sizeof(SimpleOidListCell));
31 0 : cell->next = NULL;
32 0 : cell->val = val;
33 :
34 0 : if (list->tail)
35 0 : list->tail->next = cell;
36 : else
37 0 : list->head = cell;
38 0 : list->tail = cell;
39 0 : }
40 :
41 : /*
42 : * Is OID present in the list?
43 : */
44 : bool
45 0 : simple_oid_list_member(SimpleOidList *list, Oid val)
46 : {
47 0 : SimpleOidListCell *cell;
48 :
49 0 : for (cell = list->head; cell; cell = cell->next)
50 : {
51 0 : if (cell->val == val)
52 0 : return true;
53 0 : }
54 0 : return false;
55 0 : }
56 :
57 : /*
58 : * Append a string to the list.
59 : *
60 : * The given string is copied, so it need not survive past the call.
61 : */
62 : void
63 0 : simple_string_list_append(SimpleStringList *list, const char *val)
64 : {
65 0 : SimpleStringListCell *cell;
66 :
67 0 : cell = (SimpleStringListCell *)
68 0 : pg_malloc(offsetof(SimpleStringListCell, val) + strlen(val) + 1);
69 :
70 0 : cell->next = NULL;
71 0 : cell->touched = false;
72 0 : strcpy(cell->val, val);
73 :
74 0 : if (list->tail)
75 0 : list->tail->next = cell;
76 : else
77 0 : list->head = cell;
78 0 : list->tail = cell;
79 0 : }
80 :
81 : /*
82 : * Is string present in the list?
83 : *
84 : * If found, the "touched" field of the first match is set true.
85 : */
86 : bool
87 0 : simple_string_list_member(SimpleStringList *list, const char *val)
88 : {
89 0 : SimpleStringListCell *cell;
90 :
91 0 : for (cell = list->head; cell; cell = cell->next)
92 : {
93 0 : if (strcmp(cell->val, val) == 0)
94 : {
95 0 : cell->touched = true;
96 0 : return true;
97 : }
98 0 : }
99 0 : return false;
100 0 : }
101 :
102 : /*
103 : * Destroy an OID list
104 : */
105 : void
106 0 : simple_oid_list_destroy(SimpleOidList *list)
107 : {
108 0 : SimpleOidListCell *cell;
109 :
110 0 : cell = list->head;
111 0 : while (cell != NULL)
112 : {
113 0 : SimpleOidListCell *next;
114 :
115 0 : next = cell->next;
116 0 : pg_free(cell);
117 0 : cell = next;
118 0 : }
119 0 : }
120 :
121 : /*
122 : * Destroy a string list
123 : */
124 : void
125 0 : simple_string_list_destroy(SimpleStringList *list)
126 : {
127 0 : SimpleStringListCell *cell;
128 :
129 0 : cell = list->head;
130 0 : while (cell != NULL)
131 : {
132 0 : SimpleStringListCell *next;
133 :
134 0 : next = cell->next;
135 0 : pg_free(cell);
136 0 : cell = next;
137 0 : }
138 0 : }
139 :
140 : /*
141 : * Find first not-touched list entry, if there is one.
142 : */
143 : const char *
144 0 : simple_string_list_not_touched(SimpleStringList *list)
145 : {
146 0 : SimpleStringListCell *cell;
147 :
148 0 : for (cell = list->head; cell; cell = cell->next)
149 : {
150 0 : if (!cell->touched)
151 0 : return cell->val;
152 0 : }
153 0 : return NULL;
154 0 : }
155 :
156 : /*
157 : * Append a pointer to the list.
158 : *
159 : * Caller must ensure that the pointer remains valid.
160 : */
161 : void
162 0 : simple_ptr_list_append(SimplePtrList *list, void *ptr)
163 : {
164 0 : SimplePtrListCell *cell;
165 :
166 0 : cell = (SimplePtrListCell *) pg_malloc(sizeof(SimplePtrListCell));
167 0 : cell->next = NULL;
168 0 : cell->ptr = ptr;
169 :
170 0 : if (list->tail)
171 0 : list->tail->next = cell;
172 : else
173 0 : list->head = cell;
174 0 : list->tail = cell;
175 0 : }
176 :
177 : /*
178 : * Destroy only pointer list and not the pointed-to element
179 : */
180 : void
181 0 : simple_ptr_list_destroy(SimplePtrList *list)
182 : {
183 0 : SimplePtrListCell *cell;
184 :
185 0 : cell = list->head;
186 0 : while (cell != NULL)
187 : {
188 0 : SimplePtrListCell *next;
189 :
190 0 : next = cell->next;
191 0 : pg_free(cell);
192 0 : cell = next;
193 0 : }
194 0 : }
|
