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
|
const std = @import("std");
const testing = std.testing;
const Allocator = std.heap.Allocator;
const ArrayList = std.ArrayList;
// Considerations
// When doing replaces, each replace may need to factor in previous replaces, deletes, etc.
// E.g. the text "Hi (Deletedah) ahThere" will be -2 bytes with replace("ah", "") after the
// deletion has occurred, but if naively written, then -4 bytes will be calculated for.
const OpTag = enum {
append,
prepend,
insert,
replace_all,
};
const Op = union(OpTag) {
append: struct { s: []const u8 },
prepend: struct { s: []const u8 },
insert: struct { pos: usize, s: []const u8 },
replace_all: struct { old: []const u8, new: []const u8, additional_bytes_to_allocate: isize },
};
// TODO
export const StrBuilder = struct {
allocator: Allocator,
ops: ArrayList(Op),
base: []const u8,
pub fn new(allocator: Allocator, base: []const u8) StrBuilder {
var ret = StrBuilder{};
ret.allocator = allocator;
ret.ops = ArrayList(Op).init(allocator);
ret.base = base;
return ret;
}
pub fn build(self: StrBuilder) []const u8 {
// TODO
}
pub fn deinit(self: StrBuilder) void {
self.ops.deinit();
}
pub fn append(self: StrBuilder, s: []const u8) void {
self.ops.append(Op{ .append = .{ .s = s } });
}
pub fn prepend(self: StrBuilder, s: []const u8) void {
self.ops.append(Op{ .prepend = .{ .s = s } });
}
pub fn insert(self: StrBuilder, pos: usize, s: []const u8) void {
self.ops.append(Op{ .insert = .{ .pos = pos, .s = s } });
}
pub fn replaceAll(self: StrBuilder, old_str: []const u8, new_str: []const u8) void {
// TODO: find count of `old` and store the additional allocatable size in the enum(union).
// Signed (isize) so as to allow the case when old.len > new.len.
const additional_bytes_req: isize = std.mem.count(u8, self.base, self.old) * (new.len - old.len);
self.ops.append(Op{ .replace_all = .{ .old = old_str, .new = new_str, .additional_bytes_to_allocate = additional_bytes_req } });
}
/// If the line matches the given predicate, delete the line.
pub fn deleteLineIf(self: StrBuilder, pred: fn (line: []const u8) bool) void {
// TODO
}
/// Replaces a prefix in all lines if the line begins with said prefix.
pub fn replacePrefixLinewise(self: StrBuilder, old_prefix: []const u8, new_prefix: []const u8) void {
// TODO
}
// Used for replacing text of the form: P*I*S where P is a common prefix, I
// an infix, and S a suffix. Any text can occur in * (though consider opts).
// Useful, e.g. to turn @@[text][href] into <a href="href">text</a>.
pub const ReplaceBipartOpts = struct {
allowNewline: bool,
};
pub fn replaceBipart(
self: StrBuilder,
p: []const u8,
i: []const u8,
s: []const u8,
new_p: []const u8,
new_i: []const u8,
new_s: []const u8,
opts: ReplaceBipartOpts,
) void {
// TODO
}
pub fn calculateSizeToAllocate(self: StrBuilder) usize {
var diff: isize = 0;
for (self.ops.items) |op| {
switch (op) {
OpTag.append, OpTag.prepend => |s| {
diff += s.len;
},
OpTag.insert => |c| {
diff += c.s.len;
},
OpTag.replace_all => |c| {
diff += c.additional_bytes_to_allocate;
},
}
}
return self.base.len + diff;
}
};
test "basic add functionality" {
try testing.expect(add(3, 7) == 10);
}
|
