Method createStringDelta

Fleece/Core/JSONDelta.cc:430–488

static*/

    /*static*/ string JSONDelta::createStringDelta(slice oldStr, slice nuuStr) {
        if (nuuStr.size < gMinStringDiffLength
                || (gCompatibleDeltas && oldStr.size > gMinStringDiffLength))
            return "";
        diff_match_patch<string> dmp;
        dmp.Diff_Timeout = gTextDiffTimeout;
        auto patches = dmp.patch_make(string(oldStr), string(nuuStr));

        if (gCompatibleDeltas)
            return dmp.patch_toText(patches);

        // Iterate over the diffs, writing the encoded form to the output stream:
        stringstream diff;
        long lastOldPos = 0, correction = 0;
        for (auto patch = patches.begin(); patch != patches.end(); ++patch) {
            long oldPos = patch->start1 + correction;   // position in oldStr
            long nuuPos = patch->start2;                // position in nuuStr
            auto &diffs = patch->diffs;
            for (auto cur_diff = diffs.begin(); cur_diff != diffs.end(); ++cur_diff) {
                auto length = cur_diff->text.length();
                if (cur_diff->operation == diff_match_patch<string>::EQUAL) {
                    oldPos += narrow_cast<long>(length);
                    nuuPos += narrow_cast<long>(length);
                } else {
                    // Don't break up a UTF-8 multibyte character:
                    if (cur_diff->operation == diff_match_patch<string>::DELETE)
                        snapToUTF8Character(oldPos, length, oldStr);
                    else
                        snapToUTF8Character(nuuPos, length, nuuStr);

                    assert(oldPos >= lastOldPos);
                    if (oldPos > lastOldPos) {
                        // Write the number of matching bytes since the last insert/delete:
                        diff << (oldPos-lastOldPos) << '=';
                    }
                    if (cur_diff->operation == diff_match_patch<string>::DELETE) {
                        // Write the number of deleted bytes:
                        diff << length << '-';
                        oldPos += narrow_cast<long>(length);
                    } else /* INSERT */ {
                        // Write an insertion, both the count and the bytes:
                        diff << length << '+';
                        diff.write((const char*)&nuuStr[nuuPos], length);
                        diff << '|';
                        nuuPos += narrow_cast<long>(length);
                    }
                    lastOldPos = oldPos;
                }
                if ((size_t)diff.tellp() + 6 >= nuuStr.size)
                    return "";          // Patch is too long; give up on using a diff
            }
            correction += patch->length1 - patch->length2;
        }
        if (oldStr.size > size_t(lastOldPos)) {
            // Write a final matching-bytes count:
            diff << (oldStr.size-lastOldPos) << '=';
        }
        return diff.str();