daniel
66d47fb410
Extension stamps a monotonic bank_generation counter, bumped at content mutations; the VST3 instrument polls it off-thread on an editor timer and consumes assignment requests, refreshing playback hands-free.
71 lines
2.8 KiB
C++
71 lines
2.8 KiB
C++
// bank_sync.cpp — see bank_sync.h. Pure; standard library only.
|
|
|
|
#include "bank_sync.h"
|
|
|
|
#include <cstdint>
|
|
#include <limits>
|
|
#include <string>
|
|
|
|
namespace reasampler::vst {
|
|
|
|
std::int64_t parseBankGeneration(const std::string& raw) {
|
|
if (raw.empty()) return kBankGenerationAbsent;
|
|
|
|
// Whole-string, non-negative decimal parse WITHOUT exceptions or locale surprises.
|
|
// A leading '+' / '-' , any non-digit, an empty digit run, or overflow past int64 max
|
|
// all reject to the absent default (0). Manual accumulation with an overflow guard so a
|
|
// pathologically long digit run can never wrap into a bogus small value.
|
|
std::int64_t value = 0;
|
|
constexpr std::int64_t kMax = std::numeric_limits<std::int64_t>::max();
|
|
for (const char c : raw) {
|
|
if (c < '0' || c > '9') return kBankGenerationAbsent; // any non-digit -> reject whole
|
|
const int digit = c - '0';
|
|
// Guard value*10 + digit against overflow before performing it.
|
|
if (value > (kMax - digit) / 10) return kBankGenerationAbsent; // would overflow -> reject
|
|
value = value * 10 + digit;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
std::string formatBankGeneration(std::int64_t generation) {
|
|
// Non-negative decimal; a negative (should never be produced by the writer) formats as
|
|
// its std::to_string form and would parse back to 0, so the writer's monotonic counter
|
|
// stays in the >= 0 domain by construction.
|
|
return std::to_string(generation);
|
|
}
|
|
|
|
bool bankGenerationChanged(std::int64_t seen, std::int64_t current) {
|
|
return current != seen;
|
|
}
|
|
|
|
AssignConsumeDecision consumeDecision(const std::optional<AssignmentRequest>& request,
|
|
std::int64_t lastConsumed, bool resolves,
|
|
bool isFocusedTarget) {
|
|
AssignConsumeDecision d;
|
|
d.consumedGeneration = lastConsumed; // default: nothing changes
|
|
|
|
// Rule 1: no request, or not newer than what we already consumed -> nothing new.
|
|
if (!request) return d;
|
|
if (request->generation <= lastConsumed) return d;
|
|
|
|
// Rule 2: a new request, but this instance is not the target -> do not act, do NOT
|
|
// advance the marker (stay eligible if focus later lands here). No thundering herd.
|
|
if (!isFocusedTarget) return d;
|
|
|
|
// The request is new AND we are the target: it will be consumed-as-seen either way, so
|
|
// advance the marker to its generation so it is never re-evaluated.
|
|
d.consumedGeneration = request->generation;
|
|
|
|
// Rule 3: unresolvable (bankId, sampleId) -> DROP silently (reader requirement): marker
|
|
// advanced above, but no selection change.
|
|
if (!resolves) return d;
|
|
|
|
// Rule 4: new, target, resolvable -> apply the selection.
|
|
d.apply = true;
|
|
d.bankId = request->bankId;
|
|
d.sampleId = request->sampleId;
|
|
return d;
|
|
}
|
|
|
|
} // namespace reasampler::vst
|