1/*[clinic input]
2preserve
3[clinic start generated code]*/
4
5PyDoc_STRVAR(_heapq_heappush__doc__,
6"heappush($module, heap, item, /)\n"
7"--\n"
8"\n"
9"Push item onto heap, maintaining the heap invariant.");
10
11#define _HEAPQ_HEAPPUSH_METHODDEF \
12 {"heappush", (PyCFunction)(void(*)(void))_heapq_heappush, METH_FASTCALL, _heapq_heappush__doc__},
13
14static PyObject *
15_heapq_heappush_impl(PyObject *module, PyObject *heap, PyObject *item);
16
17static PyObject *
18_heapq_heappush(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
19{
20 PyObject *return_value = NULL;
21 PyObject *heap;
22 PyObject *item;
23
24 if (!_PyArg_CheckPositional("heappush", nargs, 2, 2)) {
25 goto exit;
26 }
27 if (!PyList_Check(args[0])) {
28 _PyArg_BadArgument("heappush", "argument 1", "list", args[0]);
29 goto exit;
30 }
31 heap = args[0];
32 item = args[1];
33 return_value = _heapq_heappush_impl(module, heap, item);
34
35exit:
36 return return_value;
37}
38
39PyDoc_STRVAR(_heapq_heappop__doc__,
40"heappop($module, heap, /)\n"
41"--\n"
42"\n"
43"Pop the smallest item off the heap, maintaining the heap invariant.");
44
45#define _HEAPQ_HEAPPOP_METHODDEF \
46 {"heappop", (PyCFunction)_heapq_heappop, METH_O, _heapq_heappop__doc__},
47
48static PyObject *
49_heapq_heappop_impl(PyObject *module, PyObject *heap);
50
51static PyObject *
52_heapq_heappop(PyObject *module, PyObject *arg)
53{
54 PyObject *return_value = NULL;
55 PyObject *heap;
56
57 if (!PyList_Check(arg)) {
58 _PyArg_BadArgument("heappop", "argument", "list", arg);
59 goto exit;
60 }
61 heap = arg;
62 return_value = _heapq_heappop_impl(module, heap);
63
64exit:
65 return return_value;
66}
67
68PyDoc_STRVAR(_heapq_heapreplace__doc__,
69"heapreplace($module, heap, item, /)\n"
70"--\n"
71"\n"
72"Pop and return the current smallest value, and add the new item.\n"
73"\n"
74"This is more efficient than heappop() followed by heappush(), and can be\n"
75"more appropriate when using a fixed-size heap. Note that the value\n"
76"returned may be larger than item! That constrains reasonable uses of\n"
77"this routine unless written as part of a conditional replacement:\n"
78"\n"
79" if item > heap[0]:\n"
80" item = heapreplace(heap, item)");
81
82#define _HEAPQ_HEAPREPLACE_METHODDEF \
83 {"heapreplace", (PyCFunction)(void(*)(void))_heapq_heapreplace, METH_FASTCALL, _heapq_heapreplace__doc__},
84
85static PyObject *
86_heapq_heapreplace_impl(PyObject *module, PyObject *heap, PyObject *item);
87
88static PyObject *
89_heapq_heapreplace(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
90{
91 PyObject *return_value = NULL;
92 PyObject *heap;
93 PyObject *item;
94
95 if (!_PyArg_CheckPositional("heapreplace", nargs, 2, 2)) {
96 goto exit;
97 }
98 if (!PyList_Check(args[0])) {
99 _PyArg_BadArgument("heapreplace", "argument 1", "list", args[0]);
100 goto exit;
101 }
102 heap = args[0];
103 item = args[1];
104 return_value = _heapq_heapreplace_impl(module, heap, item);
105
106exit:
107 return return_value;
108}
109
110PyDoc_STRVAR(_heapq_heappushpop__doc__,
111"heappushpop($module, heap, item, /)\n"
112"--\n"
113"\n"
114"Push item on the heap, then pop and return the smallest item from the heap.\n"
115"\n"
116"The combined action runs more efficiently than heappush() followed by\n"
117"a separate call to heappop().");
118
119#define _HEAPQ_HEAPPUSHPOP_METHODDEF \
120 {"heappushpop", (PyCFunction)(void(*)(void))_heapq_heappushpop, METH_FASTCALL, _heapq_heappushpop__doc__},
121
122static PyObject *
123_heapq_heappushpop_impl(PyObject *module, PyObject *heap, PyObject *item);
124
125static PyObject *
126_heapq_heappushpop(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
127{
128 PyObject *return_value = NULL;
129 PyObject *heap;
130 PyObject *item;
131
132 if (!_PyArg_CheckPositional("heappushpop", nargs, 2, 2)) {
133 goto exit;
134 }
135 if (!PyList_Check(args[0])) {
136 _PyArg_BadArgument("heappushpop", "argument 1", "list", args[0]);
137 goto exit;
138 }
139 heap = args[0];
140 item = args[1];
141 return_value = _heapq_heappushpop_impl(module, heap, item);
142
143exit:
144 return return_value;
145}
146
147PyDoc_STRVAR(_heapq_heapify__doc__,
148"heapify($module, heap, /)\n"
149"--\n"
150"\n"
151"Transform list into a heap, in-place, in O(len(heap)) time.");
152
153#define _HEAPQ_HEAPIFY_METHODDEF \
154 {"heapify", (PyCFunction)_heapq_heapify, METH_O, _heapq_heapify__doc__},
155
156static PyObject *
157_heapq_heapify_impl(PyObject *module, PyObject *heap);
158
159static PyObject *
160_heapq_heapify(PyObject *module, PyObject *arg)
161{
162 PyObject *return_value = NULL;
163 PyObject *heap;
164
165 if (!PyList_Check(arg)) {
166 _PyArg_BadArgument("heapify", "argument", "list", arg);
167 goto exit;
168 }
169 heap = arg;
170 return_value = _heapq_heapify_impl(module, heap);
171
172exit:
173 return return_value;
174}
175
176PyDoc_STRVAR(_heapq__heappop_max__doc__,
177"_heappop_max($module, heap, /)\n"
178"--\n"
179"\n"
180"Maxheap variant of heappop.");
181
182#define _HEAPQ__HEAPPOP_MAX_METHODDEF \
183 {"_heappop_max", (PyCFunction)_heapq__heappop_max, METH_O, _heapq__heappop_max__doc__},
184
185static PyObject *
186_heapq__heappop_max_impl(PyObject *module, PyObject *heap);
187
188static PyObject *
189_heapq__heappop_max(PyObject *module, PyObject *arg)
190{
191 PyObject *return_value = NULL;
192 PyObject *heap;
193
194 if (!PyList_Check(arg)) {
195 _PyArg_BadArgument("_heappop_max", "argument", "list", arg);
196 goto exit;
197 }
198 heap = arg;
199 return_value = _heapq__heappop_max_impl(module, heap);
200
201exit:
202 return return_value;
203}
204
205PyDoc_STRVAR(_heapq__heapreplace_max__doc__,
206"_heapreplace_max($module, heap, item, /)\n"
207"--\n"
208"\n"
209"Maxheap variant of heapreplace.");
210
211#define _HEAPQ__HEAPREPLACE_MAX_METHODDEF \
212 {"_heapreplace_max", (PyCFunction)(void(*)(void))_heapq__heapreplace_max, METH_FASTCALL, _heapq__heapreplace_max__doc__},
213
214static PyObject *
215_heapq__heapreplace_max_impl(PyObject *module, PyObject *heap,
216 PyObject *item);
217
218static PyObject *
219_heapq__heapreplace_max(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
220{
221 PyObject *return_value = NULL;
222 PyObject *heap;
223 PyObject *item;
224
225 if (!_PyArg_CheckPositional("_heapreplace_max", nargs, 2, 2)) {
226 goto exit;
227 }
228 if (!PyList_Check(args[0])) {
229 _PyArg_BadArgument("_heapreplace_max", "argument 1", "list", args[0]);
230 goto exit;
231 }
232 heap = args[0];
233 item = args[1];
234 return_value = _heapq__heapreplace_max_impl(module, heap, item);
235
236exit:
237 return return_value;
238}
239
240PyDoc_STRVAR(_heapq__heapify_max__doc__,
241"_heapify_max($module, heap, /)\n"
242"--\n"
243"\n"
244"Maxheap variant of heapify.");
245
246#define _HEAPQ__HEAPIFY_MAX_METHODDEF \
247 {"_heapify_max", (PyCFunction)_heapq__heapify_max, METH_O, _heapq__heapify_max__doc__},
248
249static PyObject *
250_heapq__heapify_max_impl(PyObject *module, PyObject *heap);
251
252static PyObject *
253_heapq__heapify_max(PyObject *module, PyObject *arg)
254{
255 PyObject *return_value = NULL;
256 PyObject *heap;
257
258 if (!PyList_Check(arg)) {
259 _PyArg_BadArgument("_heapify_max", "argument", "list", arg);
260 goto exit;
261 }
262 heap = arg;
263 return_value = _heapq__heapify_max_impl(module, heap);
264
265exit:
266 return return_value;
267}
268/*[clinic end generated code: output=9975cf51762878d5 input=a9049054013a1b77]*/
269