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
|
/// A ScreenSet holds multiple terminal screens. This is initially created
/// to handle simple primary vs alternate screens, but could be extended
/// in the future to handle N screens.
///
/// One of the goals of this is to allow lazy initialization of screens
/// as needed. The primary screen is always initialized, but the alternate
/// screen may not be until first used.
const ScreenSet = @This();
const std = @import("std");
const assert = @import("../quirks.zig").inlineAssert;
const lib = @import("lib.zig");
const testing = std.testing;
const Allocator = std.mem.Allocator;
const Screen = @import("Screen.zig");
/// The possible keys for screens in the screen set.
pub const Key = lib.Enum(lib.target, &.{
"primary",
"alternate",
});
/// The key value of the currently active screen. Useful for simple
/// comparisons, e.g. "is this screen the primary screen".
active_key: Key,
/// The active screen pointer.
active: *Screen,
/// All screens that are initialized.
all: std.EnumMap(Key, *Screen),
/// Monotonic generation counter for each screen key. This changes whenever
/// screen storage is removed or replaced so external handles can distinguish a
/// newly initialized screen from stale references into destroyed storage.
generations: std.EnumMap(Key, usize),
pub fn init(
io: std.Io,
alloc: Allocator,
opts: Screen.Options,
) Allocator.Error!ScreenSet {
// We need to initialize our initial primary screen
const screen = try alloc.create(Screen);
errdefer alloc.destroy(screen);
screen.* = try .init(io, alloc, opts);
return .{
.active_key = .primary,
.active = screen,
.all = .init(.{ .primary = screen }),
.generations = .initFull(0),
};
}
pub fn deinit(self: *ScreenSet, alloc: Allocator) void {
// Destroy all initialized screens
var it = self.all.iterator();
while (it.next()) |entry| {
entry.value.*.deinit();
alloc.destroy(entry.value.*);
}
}
/// Get the screen for the given key, if it is initialized.
pub fn get(self: *const ScreenSet, key: Key) ?*Screen {
return self.all.get(key);
}
/// Get the current generation for the given screen key.
pub fn generation(self: *const ScreenSet, key: Key) usize {
return self.generations.get(key).?;
}
/// Get the screen for the given key, initializing it if necessary.
pub fn getInit(
self: *ScreenSet,
io: std.Io,
alloc: Allocator,
key: Key,
opts: Screen.Options,
) Allocator.Error!*Screen {
if (self.get(key)) |screen| return screen;
const screen = try alloc.create(Screen);
errdefer alloc.destroy(screen);
screen.* = try .init(io, alloc, opts);
self.all.put(key, screen);
return screen;
}
/// Remove a key from the set. The primary screen cannot be removed (asserted).
pub fn remove(
self: *ScreenSet,
alloc: Allocator,
key: Key,
) void {
assert(key != .primary);
if (self.all.fetchRemove(key)) |screen| {
self.generations.put(key, self.generation(key) +% 1);
screen.deinit();
alloc.destroy(screen);
}
}
/// Switch the active screen to the given key. Requires that the
/// screen is initialized.
pub fn switchTo(self: *ScreenSet, key: Key) void {
self.active_key = key;
self.active = self.all.get(key).?;
}
test ScreenSet {
const alloc = testing.allocator;
const io = testing.io;
var set: ScreenSet = try .init(io, alloc, .default);
defer set.deinit(alloc);
try testing.expectEqual(.primary, set.active_key);
try testing.expectEqual(@as(usize, 0), set.generation(.primary));
try testing.expectEqual(@as(usize, 0), set.generation(.alternate));
// Initialize a secondary screen
_ = try set.getInit(io, alloc, .alternate, .default);
try testing.expectEqual(@as(usize, 0), set.generation(.alternate));
set.switchTo(.alternate);
try testing.expectEqual(.alternate, set.active_key);
}
test "ScreenSet generations" {
const alloc = testing.allocator;
const io = testing.io;
var set: ScreenSet = try .init(io, alloc, .default);
defer set.deinit(alloc);
try testing.expectEqual(@as(usize, 0), set.generation(.primary));
try testing.expectEqual(@as(usize, 0), set.generation(.alternate));
// A no-op removal doesn't change the generation.
set.remove(alloc, .alternate);
try testing.expectEqual(@as(usize, 0), set.generation(.alternate));
// Initializing a screen doesn't change the generation.
_ = try set.getInit(io, alloc, .alternate, .default);
try testing.expectEqual(@as(usize, 0), set.generation(.alternate));
const alternate_generation = set.generation(.alternate);
set.remove(alloc, .alternate);
try testing.expectEqual(alternate_generation +% 1, set.generation(.alternate));
// Reinitializing keeps the generation from the last removal, so stale
// handles can distinguish the new screen from the destroyed screen.
_ = try set.getInit(io, alloc, .alternate, .default);
try testing.expectEqual(alternate_generation +% 1, set.generation(.alternate));
try testing.expectEqual(@as(usize, 0), set.generation(.primary));
}
|
