Method check_object_array

emitters/yaml_base_emitter.cpp:841–981

/**************************************************************************************************/

bool yaml_base_emitter::check_object_array(const std::string& filepath,
                                           const json& have_node,
                                           const json& expected_node,
                                           const std::string& nodepath,
                                           json& merged_node,
                                           const std::string& key,
                                           const std::string& object_key,
                                           const check_proc& proc) {
    const auto notify = [&](const std::string& validate_message,
                            const std::string& update_message) {
        check_notify(filepath, nodepath, key, validate_message, update_message);
    };

    const auto notify_fail = [&](const std::string& message) {
        check_notify(filepath, nodepath, key, message, message);
    };

    if (!expected_node.count(key)) {
        return check_removed(filepath, have_node, nodepath, key);
    }

    const json& expected = expected_node[key];

    if (!expected.is_array()) {
        notify_fail("expected type mismatch");
        throw std::runtime_error("Merge object array failure");
    }

    json& result = merged_node[key];

    if (!have_node.count(key)) {
        notify("value missing", "value inserted");
        result = expected;
        return true;
    }

    if (!have_node[key].is_array()) {
        notify("value not an array", "non-array value replaced");
        result = expected;
        return true;
    }

    const json& have = have_node[key];

    // How does one merge an array of objects? The solution is to use one of the
    // elements in each object as the object's "key", and treat the array like a
    // dictionary. This does create the possibility that multiple objects will
    // resolve to the same key, and/or the key value may not be a string, so we
    // establish those requirements as function preconditions.
    //
    // As for the actual merge, we have a `have` array, and an `expected` array.
    // The resulting merge will be built up in a resulting array, then moved
    // into `result.`
    //
    // First we build up a sorted vector of key/position pairs of the `have`
    // array. This will let us find elements in that array in log(N) time.
    //
    // Then we iterate the expected array from first to last. We pull out the