param_ordering.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/state/parameter.hpp>
#include <pulp/state/store.hpp>
 
#include <cstddef>
#include <span>
#include <vector>
 
namespace pulp::state {

struct ParamOrderingViolation {
    enum class Kind {
        IdChangedAtIndex,
        ParamRemoved,
    };
 
    Kind kind;
    std::size_t index;   
    ParamID old_id;      
    ParamID new_id;      
};

inline std::vector<ParamOrderingViolation> diff_param_ordering(
    std::span<const ParamInfo> old_params,
    std::span<const ParamInfo> new_params) {
    std::vector<ParamOrderingViolation> violations;
 
    const auto id_present_in_new = [&](ParamID id) {
        for (const auto& p : new_params)
            if (p.id == id) return true;
        return false;
    };
 
    for (std::size_t i = 0; i < old_params.size(); ++i) {
        const ParamID old_id = old_params[i].id;
        if (i < new_params.size()) {
            const ParamID new_id = new_params[i].id;
            if (new_id != old_id) {
                violations.push_back({ParamOrderingViolation::Kind::IdChangedAtIndex,
                                      i, old_id, new_id});
                // A position mismatch already means this slot moved; if the old
                // ID also vanished entirely, that is the more serious removal —
                // report it too so a caller sees the orphaned automation.
                if (!id_present_in_new(old_id)) {
                    violations.push_back({ParamOrderingViolation::Kind::ParamRemoved,
                                          i, old_id, 0});
                }
            }
        } else {
            // The new version is shorter — this old slot has no counterpart.
            violations.push_back({ParamOrderingViolation::Kind::ParamRemoved,
                                  i, old_id, 0});
        }
    }
    return violations;
}

inline std::vector<ParamOrderingViolation> diff_param_ordering(
    const StateStore& old_store, const StateStore& new_store) {
    return diff_param_ordering(old_store.all_params(), new_store.all_params());
}

inline bool param_ordering_stable(std::span<const ParamInfo> old_params,
                                  std::span<const ParamInfo> new_params) {
    return diff_param_ordering(old_params, new_params).empty();
}

inline bool param_ordering_stable(const StateStore& old_store,
                                  const StateStore& new_store) {
    return diff_param_ordering(old_store, new_store).empty();
}
 
} // namespace pulp::state