daniel/reasampler
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c534c91181bcbb2f38f66249fb00fc0c61b484ee
reasampler/src/view_mode_model.cpp
T

725 lines
26 KiB
C++
Raw Blame History

#include "view_mode_model.h"
#include <algorithm>
#include <cerrno>
#include <climits>
#include <cstdio>
#include <cstdlib>
// view_mode_model implementation.
//
// JSON is hand-rolled and self-contained, mirroring bank_model's approach (brief:
// keep the pure core dependency-free — no third-party JSON lib). A compact writer
// plus a recursive-descent parser covers the field set: the mode registry, the
// GUID-keyed membership map, per-track snapshots (with a variable-length per-FX
// offline vector), and the active mode. Ints are emitted plainly; strings are
// escaped identically to bank_model so control chars and unicode survive.
namespace reasampler {
// ---------------------------------------------------------------------------
// equality
// ---------------------------------------------------------------------------
bool Mode::operator==(const Mode& o) const {
return id == o.id && displayName == o.displayName && ordinal == o.ordinal;
}
// ---------------------------------------------------------------------------
// ModeRegistry
// ---------------------------------------------------------------------------
ModeRegistry::ModeRegistry() {
modes_.push_back(Mode{kArrangeModeId, "Arrange", 0});
modes_.push_back(Mode{kDesignModeId, "Design", 1});
}
bool ModeRegistry::add(const Mode& mode) {
if (mode.id.empty()) return false;
if (query(mode.id) != nullptr) return false; // ids are unique
modes_.push_back(mode);
// Keep ordinal order stable; std::stable_sort so equal ordinals keep insertion
// order (the tie-break documented in the header).
std::stable_sort(modes_.begin(), modes_.end(),
[](const Mode& a, const Mode& b) { return a.ordinal < b.ordinal; });
return true;
}
const Mode* ModeRegistry::query(const std::string& id) const {
for (const auto& m : modes_)
if (m.id == id) return &m;
return nullptr;
}
// ---------------------------------------------------------------------------
// MembershipIndex
// ---------------------------------------------------------------------------
bool MembershipIndex::tag(const std::string& guid, const std::string& modeId) {
if (guid.empty() || modeId.empty()) return false;
Membership& m = entries_[guid];
m.modeIds.clear(); // a leaf lives in exactly one mode (show-both aside)
m.modeIds.insert(modeId);
return true;
}
bool MembershipIndex::untag(const std::string& guid) {
return entries_.erase(guid) > 0;
}
bool MembershipIndex::setShowBoth(const std::string& guid, bool showBoth) {
if (guid.empty()) return false;
entries_[guid].showBoth = showBoth; // creates an Arrange-default entry if new
return true;
}
bool MembershipIndex::restore(const std::string& guid, const Membership& membership) {
if (guid.empty()) return false;
entries_[guid] = membership;
return true;
}
const Membership* MembershipIndex::query(const std::string& guid) const {
auto it = entries_.find(guid);
return it == entries_.end() ? nullptr : &it->second;
}
std::set<std::string> MembershipIndex::modesOf(const std::string& guid) const {
const Membership* m = query(guid);
return m ? m->modeIds : std::set<std::string>{};
}
// ---------------------------------------------------------------------------
// planner helpers
// ---------------------------------------------------------------------------
TrackPlan makeParkPlan(const std::string& guid, int fxCount) {
// Parking contract: hide both panels, out of the mix, FX bypassed, every FX
// offline. All fixed zeros — park never consults a snapshot.
TrackPlan p;
p.flags = {
{guid, Flag::ShowInTcp, 0},
{guid, Flag::ShowInMixer, 0},
{guid, Flag::MainSend, 0},
{guid, Flag::FxEnable, 0},
};
for (int i = 0; i < fxCount; ++i)
p.fxOffline.push_back({guid, i, true});
return p;
}
TrackPlan makeRestorePlan(const std::string& guid, const TrackSnapshot& snap) {
// Restore contract: every driven flag returns to its SNAPSHOTTED value — never
// a hardcoded "on"/default. A flag captured at 0 restores to 0.
TrackPlan p;
p.flags = {
{guid, Flag::ShowInTcp, snap.showInTcp},
{guid, Flag::ShowInMixer, snap.showInMixer},
{guid, Flag::MainSend, snap.mainSend},
{guid, Flag::FxEnable, snap.fxEnable},
};
for (std::size_t i = 0; i < snap.fxOffline.size(); ++i)
p.fxOffline.push_back({guid, static_cast<int>(i), snap.fxOffline[i] != 0});
return p;
}
// ---------------------------------------------------------------------------
// ViewModeModel
// ---------------------------------------------------------------------------
ViewModeModel::ViewModeModel() : activeModeId_(kArrangeModeId) {}
bool ViewModeModel::setActiveMode(const std::string& modeId) {
if (!modes_.contains(modeId)) return false;
activeModeId_ = modeId;
return true;
}
void ViewModeModel::storeSnapshot(const std::string& guid, const TrackSnapshot& snap) {
snapshots_[guid] = snap;
}
void ViewModeModel::clearSnapshot(const std::string& guid) {
snapshots_.erase(guid);
}
const TrackSnapshot* ViewModeModel::snapshot(const std::string& guid) const {
auto it = snapshots_.find(guid);
return it == snapshots_.end() ? nullptr : &it->second;
}
bool ViewModeModel::leafBelongsToMode(const std::string& guid, const std::string& modeId) const {
const Membership* m = membership_.query(guid);
if (!m) return modeId == kArrangeModeId; // untagged ⇒ Arrange default
if (m->showBoth) return true; // show-both ⇒ every mode
if (m->modeIds.empty()) return modeId == kArrangeModeId; // show-both-cleared, no mode
return m->modeIds.count(modeId) > 0;
}
std::set<std::string> ViewModeModel::visibleTracks(const FolderTree& tree,
const std::string& modeId) const {
std::set<std::string> visible;
// Pass 1: every leaf that belongs to the mode is visible.
for (const auto& node : tree.nodes) {
if (node.isParent) continue; // parents derived in pass 2
if (leafBelongsToMode(node.guid, modeId))
visible.insert(node.guid);
}
// Pass 2: a parent is visible if any descendant leaf is visible. Walk each
// visible leaf up its parent chain and mark ancestors. Parent chains are read
// from the supplied tree only (no REAPER access). A cycle-guard bounds the walk
// in case a malformed tree links a node to itself.
std::map<std::string, std::string> parentOf;
for (const auto& node : tree.nodes) parentOf[node.guid] = node.parentGuid;
// Snapshot the leaf-visible set so we don't re-walk parents we add mid-loop.
const std::vector<std::string> seeds(visible.begin(), visible.end());
for (const auto& leaf : seeds) {
auto it = parentOf.find(leaf);
std::size_t guard = 0;
while (it != parentOf.end() && !it->second.empty() && guard++ < parentOf.size()) {
const std::string& parent = it->second;
if (!visible.insert(parent).second) break; // already marked ⇒ chain done
it = parentOf.find(parent);
}
}
return visible;
}
TogglePlan ViewModeModel::planToggle(const FolderTree& tree, const std::string& targetMode) const {
TogglePlan plan;
// Index the tree so we can classify each tagged GUID (leaf vs parent vs stale).
std::map<std::string, const FolderNode*> byGuid;
for (const auto& node : tree.nodes) byGuid[node.guid] = &node;
for (const auto& [guid, m] : membership_.all()) {
auto it = byGuid.find(guid);
if (it == byGuid.end()) continue; // stale GUID: prune-safe, ignore
if (it->second->isParent) continue; // parents are derived, never parked
if (m.showBoth) continue; // show-both leaves are never parked
const bool active = leafBelongsToMode(guid, targetMode);
if (active) {
// Returning to visibility: restore from snapshot if we have one. No
// snapshot ⇒ the track was never parked, nothing to restore.
if (const TrackSnapshot* snap = snapshot(guid))
plan.restore.push_back(makeRestorePlan(guid, *snap));
} else {
// Inactive tagged leaf ⇒ park. fxOffline is intentionally empty here:
// the D2 shell expands per-FX offline writes using TrackFX_GetCount.
// The pure model has no access to REAPER FX counts at plan time;
// makeParkPlan(guid, 0) emits only the scalar flags as a result.
plan.park.push_back(makeParkPlan(guid, /*fxCount=*/0));
}
}
return plan;
}
bool ViewModeModel::operator==(const ViewModeModel& o) const {
return modes_ == o.modes_ && membership_ == o.membership_ &&
activeModeId_ == o.activeModeId_ && snapshots_ == o.snapshots_;
}
// ===========================================================================
// JSON — writer
// ===========================================================================
namespace {
void writeEscaped(std::string& out, const std::string& s) {
out += '"';
for (char c : s) {
switch (c) {
case '"': out += "\\\""; break;
case '\\': out += "\\\\"; break;
case '\b': out += "\\b"; break;
case '\f': out += "\\f"; break;
case '\n': out += "\\n"; break;
case '\r': out += "\\r"; break;
case '\t': out += "\\t"; break;
default:
if (static_cast<unsigned char>(c) < 0x20) {
char buf[8];
std::snprintf(buf, sizeof(buf), "\\u%04x", static_cast<unsigned char>(c));
out += buf;
} else {
out += c;
}
}
}
out += '"';
}
std::string intToStr(int v) {
char buf[16];
std::snprintf(buf, sizeof(buf), "%d", v);
return buf;
}
void writeIntArray(std::string& out, const std::vector<int>& v) {
out += '[';
for (std::size_t i = 0; i < v.size(); ++i) {
if (i) out += ',';
out += intToStr(v[i]);
}
out += ']';
}
class ObjWriter {
public:
explicit ObjWriter(std::string& out) : out_(out) { out_ += '{'; }
~ObjWriter() { out_ += '}'; }
void keyRaw(const char* key, const std::string& rawValue) {
sep();
writeEscaped(out_, key);
out_ += ':';
out_ += rawValue;
}
void keyStr(const char* key, const std::string& value) {
sep();
writeEscaped(out_, key);
out_ += ':';
writeEscaped(out_, value);
}
void keyBegin(const char* key) {
sep();
writeEscaped(out_, key);
out_ += ':';
}
private:
void sep() { if (first_) first_ = false; else out_ += ','; }
std::string& out_;
bool first_ = true;
};
} // namespace
std::string ViewModeModel::serialize() const {
std::string out;
{
ObjWriter root(out);
root.keyRaw("version", intToStr(1));
root.keyStr("activeMode", activeModeId_);
// modes
root.keyBegin("modes");
out += '[';
{
const auto& all = modes_.all();
for (std::size_t i = 0; i < all.size(); ++i) {
if (i) out += ',';
ObjWriter m(out);
m.keyStr("id", all[i].id);
m.keyStr("displayName", all[i].displayName);
m.keyRaw("ordinal", intToStr(all[i].ordinal));
}
}
out += ']';
// membership: array of { guid, modes[], showBoth }
root.keyBegin("membership");
out += '[';
{
bool first = true;
for (const auto& [guid, mem] : membership_.all()) {
if (!first) out += ','; first = false;
ObjWriter e(out);
e.keyStr("guid", guid);
e.keyBegin("modes");
out += '[';
{
bool mf = true;
for (const auto& id : mem.modeIds) {
if (!mf) out += ','; mf = false;
writeEscaped(out, id);
}
}
out += ']';
e.keyRaw("showBoth", mem.showBoth ? "true" : "false");
}
}
out += ']';
// snapshots: array of { guid, showInTcp, showInMixer, mainSend, fxEnable, fxOffline[] }
root.keyBegin("snapshots");
out += '[';
{
bool first = true;
for (const auto& [guid, snap] : snapshots_) {
if (!first) out += ','; first = false;
ObjWriter e(out);
e.keyStr("guid", guid);
e.keyRaw("showInTcp", intToStr(snap.showInTcp));
e.keyRaw("showInMixer", intToStr(snap.showInMixer));
e.keyRaw("mainSend", intToStr(snap.mainSend));
e.keyRaw("fxEnable", intToStr(snap.fxEnable));
e.keyBegin("fxOffline");
writeIntArray(out, snap.fxOffline);
}
}
out += ']';
} // root closes here (see bank_model note on NRVO + deferred close)
return out;
}
// ===========================================================================
// JSON — parser (recursive descent; false on any malformed input, never UB)
// ===========================================================================
namespace {
class Parser {
public:
explicit Parser(const std::string& s) : s_(s) {}
bool parseModel(ViewModeModel& out);
private:
const std::string& s_;
std::size_t pos_ = 0;
bool eof() const { return pos_ >= s_.size(); }
void skipWs() {
while (!eof()) {
char c = s_[pos_];
if (c == ' ' || c == '\t' || c == '\n' || c == '\r') ++pos_;
else break;
}
}
bool consume(char c) {
skipWs();
if (eof() || s_[pos_] != c) return false;
++pos_;
return true;
}
bool parseString(std::string& out);
bool parseRawScalar(std::string& out);
bool parseInt(int& out);
bool parseBool(bool& out);
bool parseKey(std::string& key);
bool skipValue();
bool parseModes(ModeRegistry& reg);
bool parseMembership(MembershipIndex& idx);
bool parseSnapshots(std::map<std::string, TrackSnapshot>& snaps);
bool parseIntArray(std::vector<int>& out);
};
bool Parser::parseString(std::string& out) {
skipWs();
if (eof() || s_[pos_] != '"') return false;
++pos_;
out.clear();
while (!eof()) {
char c = s_[pos_++];
if (c == '"') return true;
if (c == '\\') {
if (eof()) return false;
char e = s_[pos_++];
switch (e) {
case '"': out += '"'; break;
case '\\': out += '\\'; break;
case '/': out += '/'; break;
case 'b': out += '\b'; break;
case 'f': out += '\f'; break;
case 'n': out += '\n'; break;
case 'r': out += '\r'; break;
case 't': out += '\t'; break;
case 'u': {
auto readHex4 = [&](unsigned int& cp) -> bool {
if (pos_ + 4 > s_.size()) return false;
cp = 0;
for (int i = 0; i < 4; ++i) {
char h = s_[pos_++];
cp <<= 4;
if (h >= '0' && h <= '9') cp |= static_cast<unsigned>(h - '0');
else if (h >= 'a' && h <= 'f') cp |= static_cast<unsigned>(h - 'a' + 10);
else if (h >= 'A' && h <= 'F') cp |= static_cast<unsigned>(h - 'A' + 10);
else return false;
}
return true;
};
unsigned int hi = 0;
if (!readHex4(hi)) return false;
unsigned int codePoint = hi;
if (hi >= 0xD800 && hi <= 0xDBFF) {
if (pos_ + 6 > s_.size()) return false;
if (s_[pos_] != '\\' || s_[pos_ + 1] != 'u') return false;
pos_ += 2;
unsigned int lo = 0;
if (!readHex4(lo)) return false;
if (lo < 0xDC00 || lo > 0xDFFF) return false;
codePoint = 0x10000 + ((hi - 0xD800) << 10) + (lo - 0xDC00);
} else if (hi >= 0xDC00 && hi <= 0xDFFF) {
return false;
}
if (codePoint <= 0x7F) {
out += static_cast<char>(codePoint);
} else if (codePoint <= 0x7FF) {
out += static_cast<char>(0xC0 | (codePoint >> 6));
out += static_cast<char>(0x80 | (codePoint & 0x3F));
} else if (codePoint <= 0xFFFF) {
out += static_cast<char>(0xE0 | (codePoint >> 12));
out += static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F));
out += static_cast<char>(0x80 | (codePoint & 0x3F));
} else {
out += static_cast<char>(0xF0 | (codePoint >> 18));
out += static_cast<char>(0x80 | ((codePoint >> 12) & 0x3F));
out += static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F));
out += static_cast<char>(0x80 | (codePoint & 0x3F));
}
break;
}
default: return false;
}
} else {
out += c;
}
}
return false; // unterminated
}
bool Parser::parseRawScalar(std::string& out) {
skipWs();
std::size_t start = pos_;
while (!eof()) {
char c = s_[pos_];
if (c == ',' || c == '}' || c == ']' || c == ' ' || c == '\t' ||
c == '\n' || c == '\r')
break;
++pos_;
}
if (pos_ == start) return false;
out.assign(s_, start, pos_ - start);
return true;
}
bool Parser::parseInt(int& out) {
std::string tok;
if (!parseRawScalar(tok)) return false;
const char* b = tok.c_str();
char* end = nullptr;
errno = 0;
long long v = std::strtoll(b, &end, 10);
if (end != b + tok.size()) return false;
if (errno == ERANGE) return false;
if (v < INT_MIN || v > INT_MAX) return false;
out = static_cast<int>(v);
return true;
}
bool Parser::parseBool(bool& out) {
std::string tok;
if (!parseRawScalar(tok)) return false;
if (tok == "true") { out = true; return true; }
if (tok == "false") { out = false; return true; }
return false;
}
bool Parser::parseKey(std::string& key) {
if (!parseString(key)) return false;
return consume(':');
}
bool Parser::skipValue() {
skipWs();
if (eof()) return false;
char c = s_[pos_];
if (c == '"') { std::string tmp; return parseString(tmp); }
if (c == '{' || c == '[') {
char open = c, close = (c == '{') ? '}' : ']';
++pos_;
int depth = 1;
while (!eof() && depth > 0) {
char d = s_[pos_];
if (d == '"') { std::string tmp; if (!parseString(tmp)) return false; continue; }
if (d == open) ++depth;
else if (d == close) --depth;
++pos_;
}
return depth == 0;
}
std::string tmp;
return parseRawScalar(tmp);
}
bool Parser::parseIntArray(std::vector<int>& out) {
if (!consume('[')) return false;
skipWs();
if (consume(']')) return true;
do {
int v = 0;
if (!parseInt(v)) return false;
out.push_back(v);
} while (consume(','));
return consume(']');
}
// The registry starts seeded (Arrange + Design). Deserialization must reproduce the
// serialized set exactly, so we replace the seeded contents with the parsed ones —
// add() dedups by id, so a serialized Arrange/Design would otherwise be rejected as
// duplicates and the ordinals/names would not round-trip. We therefore parse into a
// fresh vector and swap. `reg` is passed empty (see parseModel).
bool Parser::parseModes(ModeRegistry& reg) {
if (!consume('[')) return false;
skipWs();
if (consume(']')) return true; // empty array (unusual, but valid)
do {
if (!consume('{')) return false;
Mode m;
bool haveId = false;
do {
std::string k;
if (!parseKey(k)) return false;
if (k == "id") { if (!parseString(m.id)) return false; haveId = true; }
else if (k == "displayName") { if (!parseString(m.displayName)) return false; }
else if (k == "ordinal") { if (!parseInt(m.ordinal)) return false; }
else if (!skipValue()) return false;
} while (consume(','));
if (!consume('}')) return false;
if (!haveId || !reg.add(m)) return false; // malformed / duplicate id
} while (consume(','));
return consume(']');
}
bool Parser::parseMembership(MembershipIndex& idx) {
if (!consume('[')) return false;
skipWs();
if (consume(']')) return true;
do {
if (!consume('{')) return false;
std::string guid;
Membership mem;
bool haveGuid = false;
do {
std::string k;
if (!parseKey(k)) return false;
if (k == "guid") { if (!parseString(guid)) return false; haveGuid = true; }
else if (k == "modes") {
if (!consume('[')) return false;
skipWs();
if (!consume(']')) {
do {
std::string id;
if (!parseString(id)) return false;
mem.modeIds.insert(id);
} while (consume(','));
if (!consume(']')) return false;
}
}
else if (k == "showBoth") { if (!parseBool(mem.showBoth)) return false; }
else if (!skipValue()) return false;
} while (consume(','));
if (!consume('}')) return false;
if (!haveGuid || guid.empty()) return false;
// Install the entry verbatim (tag() would clear a multi-mode set and drop
// show-both). A serialized entry is trusted to already satisfy the model's
// invariants.
//
// Deliberate tolerance: we do NOT validate that membership modeIds reference
// registered modes, and we do not validate snapshot GUIDs against the index.
// Stale-GUID and stale-mode tolerance is a stated invariant of this model —
// a deserialized entry is treated as trusted data, not as live cross-checked
// state. Rejecting stale entries here would violate that invariant. The one
// exception is activeMode (validated below in parseModel): a persisted active
// mode that no longer exists has an immediate behavioral consequence, so it
// is caught and the parse is rejected.
if (!idx.restore(guid, mem)) return false;
} while (consume(','));
return consume(']');
}
bool Parser::parseSnapshots(std::map<std::string, TrackSnapshot>& snaps) {
if (!consume('[')) return false;
skipWs();
if (consume(']')) return true;
do {
if (!consume('{')) return false;
std::string guid;
TrackSnapshot snap;
bool haveGuid = false;
do {
std::string k;
if (!parseKey(k)) return false;
if (k == "guid") { if (!parseString(guid)) return false; haveGuid = true; }
else if (k == "showInTcp") { if (!parseInt(snap.showInTcp)) return false; }
else if (k == "showInMixer") { if (!parseInt(snap.showInMixer)) return false; }
else if (k == "mainSend") { if (!parseInt(snap.mainSend)) return false; }
else if (k == "fxEnable") { if (!parseInt(snap.fxEnable)) return false; }
else if (k == "fxOffline") { if (!parseIntArray(snap.fxOffline)) return false; }
else if (!skipValue()) return false;
} while (consume(','));
if (!consume('}')) return false;
if (!haveGuid || guid.empty()) return false;
snaps[guid] = snap;
} while (consume(','));
return consume(']');
}
bool Parser::parseModel(ViewModeModel& out) {
if (!consume('{')) return false;
skipWs();
if (consume('}')) return true; // lenient empty root ⇒ default-seeded model
ModeRegistry reg; // seeded default; REPLACED if a modes array is present
bool haveModes = false;
std::string activeMode;
bool haveActive = false;
MembershipIndex membership;
std::map<std::string, TrackSnapshot> snaps;
do {
std::string key;
if (!parseKey(key)) return false;
if (key == "activeMode") {
if (!parseString(activeMode)) return false;
haveActive = true;
} else if (key == "modes") {
ModeRegistry fresh = ModeRegistry::makeEmpty(); // parse into empty, then own
if (!parseModes(fresh)) return false;
reg = fresh;
haveModes = true;
} else if (key == "membership") {
if (!parseMembership(membership)) return false;
} else if (key == "snapshots") {
if (!parseSnapshots(snaps)) return false;
} else {
// Unknown keys and the "version" field are skipped here.
// "version" is serialized as a forward-compat placeholder — there is no
// active version gate yet; all persisted data is parsed the same way
// regardless of the value. A future gate would add a version branch here.
if (!skipValue()) return false;
}
} while (consume(','));
if (!consume('}')) return false;
skipWs();
if (!eof()) return false; // trailing garbage
if (haveModes) out.modes() = reg;
out.membership() = membership;
for (const auto& [guid, snap] : snaps) out.storeSnapshot(guid, snap);
if (haveActive) {
if (!out.setActiveMode(activeMode)) return false; // active mode must exist
}
return true;
}
} // namespace
std::optional<ViewModeModel> ViewModeModel::deserialize(const std::string& json) {
ViewModeModel vm;
Parser p(json);
if (!p.parseModel(vm)) return std::nullopt;
return vm;
}
} // namespace reasampler
Reference in New Issue View Git Blame Copy Permalink