ab_compare.hpp

Go to the documentation of this file.

#pragma once
 
// A/B compare.
//
// Two-slot state snapshot component backed by pulp::state::StateStore's
// serialize/deserialize contract. Plugin UIs wire an ABCompare over their
// StateStore to support the workflow every mature audio developer expects:
// edit preset A, snap to B, tweak B separately, toggle A/B to hear the
// difference, copy one slot over the other.
//
// This component holds the raw serialized bytes per slot and drives the
// StateStore through its public API; it does not touch individual
// ParamValue atomics, so the audio thread is never stalled.
 
#include <pulp/state/store.hpp>
 
#include <array>
#include <cstdint>
#include <span>
#include <vector>
 
namespace pulp::view {
 
class ABCompare {
public:
    enum class Slot { A = 0, B = 1 };
 
    explicit ABCompare(state::StateStore* store) : store_(store) {}

    Slot current() const { return current_; }

    void save_to(Slot slot) {
        if (!store_) return;
        buffer_for(slot) = store_->serialize();
    }

    bool load_from(Slot slot) {
        if (!store_) return false;
        const auto& buf = buffer_for(slot);
        if (buf.empty()) return false;
        if (!store_->deserialize(std::span<const uint8_t>(buf.data(), buf.size())))
            return false;
        current_ = slot;
        return true;
    }

    bool toggle() {
        return load_from(current_ == Slot::A ? Slot::B : Slot::A);
    }

    void copy(Slot src, Slot dst) {
        if (src == dst) return;
        buffer_for(dst) = buffer_for(src);
    }

    void swap() {
        std::swap(buffer_for(Slot::A), buffer_for(Slot::B));
    }

    bool has(Slot slot) const { return !buffer_for(slot).empty(); }

    void clear(Slot slot) { buffer_for(slot).clear(); }

    std::span<const uint8_t> snapshot(Slot slot) const {
        const auto& b = buffer_for(slot);
        return {b.data(), b.size()};
    }
 
private:
    std::vector<uint8_t>& buffer_for(Slot slot) {
        return slots_[static_cast<size_t>(slot)];
    }
    const std::vector<uint8_t>& buffer_for(Slot slot) const {
        return slots_[static_cast<size_t>(slot)];
    }
 
    state::StateStore* store_ = nullptr;
    std::array<std::vector<uint8_t>, 2> slots_;
    Slot current_ = Slot::A;
};
 
}  // namespace pulp::view