authorgravatar for moconnor@tutanota.comMatthew O'Connor <moconnor@tutanota.com> 2018-11-15 21:09:21-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2018-11-16 09:21:48-05:00
log007783753e2c06bb0e17e4ba1523ef8d37fbad1e
tree8271cb42326871b1a5c9a3e53ea6a6c101bc2d66
parentba361f31c610bb97958201391f929696afd7f5aa

Change rb functions to use snakeCase.

1 files changed, 105 insertions(+), 105 deletions(-)

std/rb.zig+105-105
......@@ -40,7 +40,7 @@ pub const Node = struct {
4040 }
4141
4242 while (true) {
43 var parent = node.get_parent();
43 var parent = node.getParent();
4444 if (parent) |p| {
4545 if (node != p.right)
4646 return p;
......@@ -61,7 +61,7 @@ pub const Node = struct {
6161 }
6262
6363 while (true) {
64 var parent = node.get_parent();
64 var parent = node.getParent();
6565 if (parent) |p| {
6666 if (node != p.left)
6767 return p;
......@@ -71,23 +71,23 @@ pub const Node = struct {
7171 }
7272 }
7373
74 pub fn is_root(node: *Node) bool {
75 return node.get_parent() == null;
74 pub fn isRoot(node: *Node) bool {
75 return node.getParent() == null;
7676 }
7777
78 fn is_red(node: *Node) bool {
79 return node.get_color() == Red;
78 fn isRed(node: *Node) bool {
79 return node.getColor() == Red;
8080 }
8181
82 fn is_black(node: *Node) bool {
83 return node.get_color() == Black;
82 fn isBlack(node: *Node) bool {
83 return node.getColor() == Black;
8484 }
8585
86 fn set_parent(node: *Node, parent: ?*Node) void {
86 fn setParent(node: *Node, parent: ?*Node) void {
8787 node.parent_and_color = @ptrToInt(parent) | (node.parent_and_color & 1);
8888 }
8989
90 fn get_parent(node: *Node) ?*Node {
90 fn getParent(node: *Node) ?*Node {
9191 const mask: usize = 1;
9292 comptime {
9393 assert(@alignOf(*Node) >= 2);
......@@ -95,12 +95,12 @@ pub const Node = struct {
9595 return @intToPtr(*Node, node.parent_and_color & ~mask);
9696 }
9797
98 fn set_color(node: *Node, color: Color) void {
98 fn setColor(node: *Node, color: Color) void {
9999 const mask: usize = 1;
100100 node.parent_and_color = (node.parent_and_color & ~mask) | @enumToInt(color);
101101 }
102102
103 fn get_color(node: *Node) Color {
103 fn getColor(node: *Node) Color {
104104 return @intToEnum(Color, @intCast(u1, node.parent_and_color & 1));
105105 }
106106
......@@ -112,7 +112,7 @@ pub const Node = struct {
112112 }
113113 }
114114
115 fn get_first(nodeconst: *Node) *Node {
115 fn getFirst(nodeconst: *Node) *Node {
116116 var node = nodeconst;
117117 while (node.left) |left| {
118118 node = left;
......@@ -120,7 +120,7 @@ pub const Node = struct {
120120 return node;
121121 }
122122
123 fn get_last(node: *Node) *Node {
123 fn getLast(node: *Node) *Node {
124124 while (node.right) |right| {
125125 node = right;
126126 }
......@@ -161,15 +161,15 @@ pub const Tree = struct {
161161 var maybe_parent: ?*Node = undefined;
162162 var is_left: bool = undefined;
163163
164 maybe_key = do_lookup(node, tree, &maybe_parent, &is_left);
164 maybe_key = doLookup(node, tree, &maybe_parent, &is_left);
165165 if (maybe_key) |key| {
166166 return key;
167167 }
168168
169169 node.left = null;
170170 node.right = null;
171 node.set_color(Red);
172 node.set_parent(maybe_parent);
171 node.setColor(Red);
172 node.setParent(maybe_parent);
173173
174174 if (maybe_parent) |parent| {
175175 parent.set_child(node, is_left);
......@@ -177,58 +177,58 @@ pub const Tree = struct {
177177 tree.root = node;
178178 }
179179
180 while (node.get_parent()) |*parent| {
181 if (parent.*.is_black())
180 while (node.getParent()) |*parent| {
181 if (parent.*.isBlack())
182182 break;
183183 // the root is always black
184 var grandpa = parent.*.get_parent() orelse unreachable;
184 var grandpa = parent.*.getParent() orelse unreachable;
185185
186186 if (parent.* == grandpa.left) {
187187 var maybe_uncle = grandpa.right;
188188
189189 if (maybe_uncle) |uncle| {
190 if (uncle.is_black())
190 if (uncle.isBlack())
191191 break;
192192
193 parent.*.set_color(Black);
194 uncle.set_color(Black);
195 grandpa.set_color(Red);
193 parent.*.setColor(Black);
194 uncle.setColor(Black);
195 grandpa.setColor(Red);
196196 node = grandpa;
197197 } else {
198198 if (node == parent.*.right) {
199 rotate_left(parent.*, tree);
199 rotateLeft(parent.*, tree);
200200 node = parent.*;
201 parent.* = node.get_parent().?; // Just rotated
201 parent.* = node.getParent().?; // Just rotated
202202 }
203 parent.*.set_color(Black);
204 grandpa.set_color(Red);
205 rotate_right(grandpa, tree);
203 parent.*.setColor(Black);
204 grandpa.setColor(Red);
205 rotateRight(grandpa, tree);
206206 }
207207 } else {
208208 var maybe_uncle = grandpa.left;
209209
210210 if (maybe_uncle) |uncle| {
211 if (uncle.is_black())
211 if (uncle.isBlack())
212212 break;
213213
214 parent.*.set_color(Black);
215 uncle.set_color(Black);
216 grandpa.set_color(Red);
214 parent.*.setColor(Black);
215 uncle.setColor(Black);
216 grandpa.setColor(Red);
217217 node = grandpa;
218218 } else {
219219 if (node == parent.*.left) {
220 rotate_right(parent.*, tree);
220 rotateRight(parent.*, tree);
221221 node = parent.*;
222 parent.* = node.get_parent().?; // Just rotated
222 parent.* = node.getParent().?; // Just rotated
223223 }
224 parent.*.set_color(Black);
225 grandpa.set_color(Red);
226 rotate_left(grandpa, tree);
224 parent.*.setColor(Black);
225 grandpa.setColor(Red);
226 rotateLeft(grandpa, tree);
227227 }
228228 }
229229 }
230230 // This was an insert, there is at least one node.
231 tree.root.?.set_color(Black);
231 tree.root.?.setColor(Black);
232232 return null;
233233 }
234234
......@@ -236,14 +236,14 @@ pub const Tree = struct {
236236 var parent: *Node = undefined;
237237 var is_left: bool = undefined;
238238
239 return do_lookup(key, tree, &parent, &is_left);
239 return doLookup(key, tree, &parent, &is_left);
240240 }
241241
242242 pub fn remove(tree: *Tree, nodeconst: *Node) void {
243243 var node = nodeconst;
244244 // as this has the same value as node, it is unsafe to access node after newnode
245245 var newnode: ?*Node = nodeconst;
246 var maybe_parent: ?*Node = node.get_parent();
246 var maybe_parent: ?*Node = node.getParent();
247247 var color: Color = undefined;
248248 var next: *Node = undefined;
249249
......@@ -253,7 +253,7 @@ pub const Tree = struct {
253253 parent.set_child(null, parent.left == node);
254254 } else
255255 tree.root = null;
256 color = node.get_color();
256 color = node.getColor();
257257 newnode = null;
258258 } else {
259259 if (node.left == null) {
......@@ -261,7 +261,7 @@ pub const Tree = struct {
261261 } else if (node.right == null) {
262262 next = node.left.?; // Not both null as per above
263263 } else
264 next = node.right.?.get_first(); // Just checked for null above
264 next = node.right.?.getFirst(); // Just checked for null above
265265
266266 if (maybe_parent) |parent| {
267267 parent.set_child(next, parent.left == node);
......@@ -272,39 +272,39 @@ pub const Tree = struct {
272272 const left = node.left.?;
273273 const right = node.right.?;
274274
275 color = next.get_color();
276 next.set_color(node.get_color());
275 color = next.getColor();
276 next.setColor(node.getColor());
277277
278278 next.left = left;
279 left.set_parent(next);
279 left.setParent(next);
280280
281281 if (next != right) {
282 var parent = next.get_parent().?; // Was traversed via child node (right/left)
283 next.set_parent(node.get_parent());
282 var parent = next.getParent().?; // Was traversed via child node (right/left)
283 next.setParent(node.getParent());
284284
285285 newnode = next.right;
286286 parent.left = node;
287287
288288 next.right = right;
289 right.set_parent(next);
289 right.setParent(next);
290290 } else {
291 next.set_parent(maybe_parent);
291 next.setParent(maybe_parent);
292292 maybe_parent = next;
293293 newnode = next.right;
294294 }
295295 } else {
296 color = node.get_color();
296 color = node.getColor();
297297 newnode = next;
298298 }
299299 }
300300
301301 if (newnode) |n|
302 n.set_parent(maybe_parent);
302 n.setParent(maybe_parent);
303303
304304 if (color == Red)
305305 return;
306306 if (newnode) |n| {
307 n.set_color(Black);
307 n.setColor(Black);
308308 return;
309309 }
310310
......@@ -314,69 +314,69 @@ pub const Tree = struct {
314314 if (node == parent.left) {
315315 var sibling = parent.right.?; // Same number of black nodes.
316316
317 if (sibling.is_red()) {
318 sibling.set_color(Black);
319 parent.set_color(Red);
320 rotate_left(parent, tree);
317 if (sibling.isRed()) {
318 sibling.setColor(Black);
319 parent.setColor(Red);
320 rotateLeft(parent, tree);
321321 sibling = parent.right.?; // Just rotated
322322 }
323 if ((if (sibling.left) |n| n.is_black() else true) and
324 (if (sibling.right) |n| n.is_black() else true))
323 if ((if (sibling.left) |n| n.isBlack() else true) and
324 (if (sibling.right) |n| n.isBlack() else true))
325325 {
326 sibling.set_color(Red);
326 sibling.setColor(Red);
327327 node = parent;
328 maybe_parent = parent.get_parent();
328 maybe_parent = parent.getParent();
329329 continue;
330330 }
331 if (if (sibling.right) |n| n.is_black() else true) {
332 sibling.left.?.set_color(Black); // Same number of black nodes.
333 sibling.set_color(Red);
334 rotate_right(sibling, tree);
331 if (if (sibling.right) |n| n.isBlack() else true) {
332 sibling.left.?.setColor(Black); // Same number of black nodes.
333 sibling.setColor(Red);
334 rotateRight(sibling, tree);
335335 sibling = parent.right.?; // Just rotated
336336 }
337 sibling.set_color(parent.get_color());
338 parent.set_color(Black);
339 sibling.right.?.set_color(Black); // Same number of black nodes.
340 rotate_left(parent, tree);
337 sibling.setColor(parent.getColor());
338 parent.setColor(Black);
339 sibling.right.?.setColor(Black); // Same number of black nodes.
340 rotateLeft(parent, tree);
341341 newnode = tree.root;
342342 break;
343343 } else {
344344 var sibling = parent.left.?; // Same number of black nodes.
345345
346 if (sibling.is_red()) {
347 sibling.set_color(Black);
348 parent.set_color(Red);
349 rotate_right(parent, tree);
346 if (sibling.isRed()) {
347 sibling.setColor(Black);
348 parent.setColor(Red);
349 rotateRight(parent, tree);
350350 sibling = parent.left.?; // Just rotated
351351 }
352 if ((if (sibling.left) |n| n.is_black() else true) and
353 (if (sibling.right) |n| n.is_black() else true))
352 if ((if (sibling.left) |n| n.isBlack() else true) and
353 (if (sibling.right) |n| n.isBlack() else true))
354354 {
355 sibling.set_color(Red);
355 sibling.setColor(Red);
356356 node = parent;
357 maybe_parent = parent.get_parent();
357 maybe_parent = parent.getParent();
358358 continue;
359359 }
360 if (if (sibling.left) |n| n.is_black() else true) {
361 sibling.right.?.set_color(Black); // Same number of black nodes
362 sibling.set_color(Red);
363 rotate_left(sibling, tree);
360 if (if (sibling.left) |n| n.isBlack() else true) {
361 sibling.right.?.setColor(Black); // Same number of black nodes
362 sibling.setColor(Red);
363 rotateLeft(sibling, tree);
364364 sibling = parent.left.?; // Just rotated
365365 }
366 sibling.set_color(parent.get_color());
367 parent.set_color(Black);
368 sibling.left.?.set_color(Black); // Same number of black nodes
369 rotate_right(parent, tree);
366 sibling.setColor(parent.getColor());
367 parent.setColor(Black);
368 sibling.left.?.setColor(Black); // Same number of black nodes
369 rotateRight(parent, tree);
370370 newnode = tree.root;
371371 break;
372372 }
373373
374 if (node.is_red())
374 if (node.isRed())
375375 break;
376376 }
377377
378378 if (newnode) |n|
379 n.set_color(Black);
379 n.setColor(Black);
380380 }
381381
382382 /// This is a shortcut to avoid removing and re-inserting an item with the same key.
......@@ -386,15 +386,15 @@ pub const Tree = struct {
386386 // I assume this can get optimized out if the caller already knows.
387387 if (tree.compareFn(old, new) != mem.Compare.Equal) return ReplaceError.NotEqual;
388388
389 if (old.get_parent()) |parent| {
389 if (old.getParent()) |parent| {
390390 parent.set_child(new, parent.left == old);
391391 } else
392392 tree.root = new;
393393
394394 if (old.left) |left|
395 left.set_parent(new);
395 left.setParent(new);
396396 if (old.right) |right|
397 right.set_parent(new);
397 right.setParent(new);
398398
399399 new.* = old.*;
400400 }
......@@ -405,59 +405,59 @@ pub const Tree = struct {
405405 }
406406};
407407
408fn rotate_left(node: *Node, tree: *Tree) void {
408fn rotateLeft(node: *Node, tree: *Tree) void {
409409 var p: *Node = node;
410410 var q: *Node = node.right orelse unreachable;
411411 var parent: *Node = undefined;
412412
413 if (!p.is_root()) {
414 parent = p.get_parent().?;
413 if (!p.isRoot()) {
414 parent = p.getParent().?;
415415 if (parent.left == p) {
416416 parent.left = q;
417417 } else {
418418 parent.right = q;
419419 }
420 q.set_parent(parent);
420 q.setParent(parent);
421421 } else {
422422 tree.root = q;
423 q.set_parent(null);
423 q.setParent(null);
424424 }
425 p.set_parent(q);
425 p.setParent(q);
426426
427427 p.right = q.left;
428428 if (p.right) |right| {
429 right.set_parent(p);
429 right.setParent(p);
430430 }
431431 q.left = p;
432432}
433433
434fn rotate_right(node: *Node, tree: *Tree) void {
434fn rotateRight(node: *Node, tree: *Tree) void {
435435 var p: *Node = node;
436436 var q: *Node = node.left orelse unreachable;
437437 var parent: *Node = undefined;
438438
439 if (!p.is_root()) {
440 parent = p.get_parent().?;
439 if (!p.isRoot()) {
440 parent = p.getParent().?;
441441 if (parent.left == p) {
442442 parent.left = q;
443443 } else {
444444 parent.right = q;
445445 }
446 q.set_parent(parent);
446 q.setParent(parent);
447447 } else {
448448 tree.root = q;
449 q.set_parent(null);
449 q.setParent(null);
450450 }
451 p.set_parent(q);
451 p.setParent(q);
452452
453453 p.left = q.right;
454454 if (p.left) |left| {
455 left.set_parent(p);
455 left.setParent(p);
456456 }
457457 q.right = p;
458458}
459459
460fn do_lookup(key: *Node, tree: *Tree, pparent: *?*Node, is_left: *bool) ?*Node {
460fn doLookup(key: *Node, tree: *Tree, pparent: *?*Node, is_left: *bool) ?*Node {
461461 var maybe_node: ?*Node = tree.root;
462462
463463 pparent.* = null;