Q-W1 pt2: core/shell/app relocation + sub-namespaces; one concrete ui::Rect (LTRB fork retired); slot_map split from bank_book; BankIndex→BankModel; 59/59 green

src/core/capture/tail_control.cpp

@@ -0,0 +1,131 @@
+// tail_control — pure implementation. See tail_control.h. NO REAPER / SWELL / vendor.
+
+#include "core/capture/tail_control.h"
+
+#include <algorithm>
+#include <cstdio>
+
+#include "core/json/json.h"
+
+namespace reasampler::capture {
+
+TailMode cycleTailMode(TailMode current) {
+    switch (current) {
+        case TailMode::None:   return TailMode::Auto;
+        case TailMode::Auto:   return TailMode::Manual;
+        case TailMode::Manual: return TailMode::None;
+    }
+    return TailMode::None;  // unreachable for a valid enum; fail to the safe default
+}
+
+double clampManualMs(double manualMs) {
+    // Same runaway guard the pure tailRenderSettingsFor applies to Manual: floor a
+    // negative request to 0, cap at the 8 s ceiling.
+    return std::clamp(manualMs, 0.0, kMaxTailMs);
+}
+
+double adjustManualMs(double current, int notches, double stepMs) {
+    // Clamp the stepped value so both scroll directions saturate at the bounds rather
+    // than running away (the same [0, kMaxTailMs] guard clampManualMs enforces).
+    return clampManualMs(current + notches * stepMs);
+}
+
+std::string tailToggleLabel(const TailSetting& setting) {
+    switch (setting.mode) {
+        case TailMode::None: return "Tail: Off";
+        case TailMode::Auto: return "Tail: Auto";
+        case TailMode::Manual: {
+            // Append the CLAMPED length in seconds to one decimal so the readout can
+            // never show an over-cap value even if manualMs was stored past the cap.
+            const double seconds = clampManualMs(setting.manualMs) / 1000.0;
+            char buf[32];
+            std::snprintf(buf, sizeof(buf), "Tail: Manual %.1fs", seconds);
+            return std::string(buf);
+        }
+    }
+    return "Tail: Off";  // unreachable for a valid enum; fail to the safe default
+}
+
+// ---------------------------------------------------------------------------
+// JSON round-trip
+// ---------------------------------------------------------------------------
+//
+// The setting is a flat object of one enum + one double, riding the shared
+// core/json layer (Q-W1, T2-02: the former substring-scan valueAfterKey reader —
+// the fifth hand-rolled JSON decoder — is retired). manualMs is emitted with 17
+// significant digits (%.17g) — the shortest form that round-trips every IEEE-754
+// double exactly — so deserialize(serialize(x)) == x holds bit-for-bit.
+// deserialize stays forgiving in outcome: any parse failure returns nullopt so
+// the caller falls back to a default, exactly as an absent ext-state key does.
+
+namespace {
+
+// The persisted integer for a mode. Stable forever (stored in the .rpp): never
+// renumber these values or an already-saved project reads back the wrong mode.
+int modeToInt(TailMode m) {
+    switch (m) {
+        case TailMode::None:   return 0;
+        case TailMode::Auto:   return 1;
+        case TailMode::Manual: return 2;
+    }
+    return 0;
+}
+
+std::optional<TailMode> modeFromInt(int v) {
+    switch (v) {
+        case 0: return TailMode::None;
+        case 1: return TailMode::Auto;
+        case 2: return TailMode::Manual;
+        default: return std::nullopt;  // unknown enumerant -> malformed -> default
+    }
+}
+
+}  // namespace
+
+std::string serializeTailSetting(const TailSetting& setting) {
+    // Byte-identical to the former snprintf writer: {"mode":%d,"manualMs":%.17g}.
+    std::string out;
+    {
+        json::Writer w(out);
+        w.keyRaw("mode", json::numToStr(modeToInt(setting.mode)));
+        w.keyRaw("manualMs", json::numToStr(setting.manualMs));
+    }  // Writer closes the object here (see bank_model's NRVO note)
+    return out;
+}
+
+std::optional<TailSetting> deserializeTailSetting(const std::string& blob) {
+    json::Reader r(blob);
+    if (!r.consume('{')) return std::nullopt;
+
+    int modeInt = 0;
+    double ms = 0.0;
+    bool haveMode = false, haveMs = false;
+    r.skipWs();
+    if (!r.consume('}')) {
+        do {
+            std::string key;
+            if (!r.parseKey(key)) return std::nullopt;
+            if (key == "mode") {
+                if (!r.parseInt(modeInt)) return std::nullopt;
+                haveMode = true;
+            } else if (key == "manualMs") {
+                if (!r.parseDouble(ms)) return std::nullopt;
+                haveMs = true;
+            } else {
+                if (!r.skipValue()) return std::nullopt;  // forward-compat
+            }
+        } while (r.consume(','));
+        if (!r.consume('}')) return std::nullopt;
+    }
+    if (!haveMode || !haveMs) return std::nullopt;  // absent key -> malformed -> default
+
+    const std::optional<TailMode> mode = modeFromInt(modeInt);
+    if (!mode) return std::nullopt;
+
+    TailSetting out;
+    out.mode = *mode;
+    out.manualMs = ms;
+    return out;
+}
+
+} // namespace reasampler::capture