Rename ot_engine.py to ot_engine.hpp

ot_engine.hpp

@@ -0,0 +1,164 @@
+#pragma once
+/*
+ * CollabDocs C++ — Operational Transformation Engine
+ *
+ * Implements:
+ *   insert-insert, insert-delete, delete-insert, delete-delete
+ *   with cursor sync and transform_against_log.
+ *
+ * All operations are VALUE types (copyable, no heap allocation).
+ */
+
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <stdexcept>
+
+namespace collab {
+
+// ─── Operation ───────────────────────────────────────────────────────────────
+
+enum class OpType { INSERT, DELETE };
+
+struct Operation {
+    OpType      type;
+    int         position   = 0;
+    std::string value;          // meaningful for INSERT
+    int         length     = 0; // meaningful for DELETE (insert: derived)
+    int         base_version = 0;
+    std::string user_id;
+    std::string op_id;
+
+    // Normalize: insert.length always == value.size()
+    void normalize() {
+        if (type == OpType::INSERT)
+            length = static_cast<int>(value.size());
+    }
+};
+
+// ─── Pairwise transform functions ────────────────────────────────────────────
+
+// insert vs insert
+inline Operation transform_ii(Operation op, const Operation& against) {
+    if (against.position < op.position) {
+        op.position += static_cast<int>(against.value.size());
+    } else if (against.position == op.position) {
+        // Tie-break: lower user_id wins (goes first)
+        if (against.user_id <= op.user_id)
+            op.position += static_cast<int>(against.value.size());
+    }
+    return op;
+}
+
+// delete vs insert (delete incoming, insert already applied)
+// "delete wins" — absorbs chars inserted inside its range
+inline Operation transform_di(Operation op, const Operation& against) {
+    int ins_pos = against.position;
+    int ins_len = static_cast<int>(against.value.size());
+    int del_end = op.position + op.length;
+
+    if (ins_pos < op.position) {
+        op.position += ins_len;
+    } else if (ins_pos <= del_end) {
+        op.length += ins_len;
+    }
+    return op;
+}
+
+// insert vs delete (insert incoming, delete already applied)
+// if insert fell inside deleted range → collapse to del_start
+inline Operation transform_id(Operation op, const Operation& against) {
+    int del_start = against.position;
+    int del_end   = against.position + against.length;
+
+    if (del_end <= op.position) {
+        op.position -= against.length;
+    } else if (del_start < op.position) {
+        op.position = del_start;
+    }
+    return op;
+}
+
+// delete vs delete
+inline Operation transform_dd(Operation op, const Operation& against) {
+    int op_start = op.position;
+    int op_end   = op.position + op.length;
+    int ag_start = against.position;
+    int ag_end   = against.position + against.length;
+
+    if (ag_end <= op_start) {
+        op.position -= against.length;
+    } else if (ag_start >= op_end) {
+        // no change
+    } else {
+        int overlap_start = std::max(op_start, ag_start);
+        int overlap_end   = std::min(op_end,   ag_end);
+        int overlap       = overlap_end - overlap_start;
+
+        if (ag_start < op_start)
+            op.position = ag_start;
+
+        op.length = std::max(0, op.length - overlap);
+    }
+    return op;
+}
+
+// ─── Dispatch ────────────────────────────────────────────────────────────────
+
+inline Operation transform_operation(Operation incoming, const Operation& applied) {
+    if (incoming.type == OpType::INSERT) {
+        if (applied.type == OpType::INSERT) return transform_ii(incoming, applied);
+        else                               return transform_id(incoming, applied);
+    } else {
+        if (applied.type == OpType::INSERT) return transform_di(incoming, applied);
+        else                                return transform_dd(incoming, applied);
+    }
+}
+
+// Transform `incoming` (based at `from_version`) against log entries
+// with version in range (from_version, to_version].
+inline Operation transform_against_log(
+    Operation incoming,
+    const std::vector<std::pair<int, Operation>>& op_log,
+    int from_version,
+    int to_version)
+{
+    for (auto& [ver, applied_op] : op_log) {
+        if (ver > from_version && ver <= to_version)
+            incoming = transform_operation(incoming, applied_op);
+    }
+    return incoming;
+}
+
+// ─── Apply ───────────────────────────────────────────────────────────────────
+
+inline std::string apply_operation(const std::string& content, const Operation& op) {
+    int len = static_cast<int>(content.size());
+    if (op.type == OpType::INSERT) {
+        int pos = std::max(0, std::min(op.position, len));
+        return content.substr(0, pos) + op.value + content.substr(pos);
+    } else {
+        if (op.length <= 0) return content;
+        int pos = std::max(0, std::min(op.position, len));
+        int end = std::max(0, std::min(pos + op.length, len));
+        return content.substr(0, pos) + content.substr(end);
+    }
+}
+
+// ─── Cursor sync ─────────────────────────────────────────────────────────────
+
+inline int transform_cursor(int cursor, const Operation& op) {
+    if (op.type == OpType::INSERT) {
+        if (op.position <= cursor)
+            cursor += static_cast<int>(op.value.size());
+    } else {
+        int del_end = op.position + op.length;
+        if (del_end <= cursor)
+            cursor -= op.length;
+        else if (op.position <= cursor)
+            cursor = op.position;
+    }
+    return cursor;
+}
+
+} // namespace collab

ot_engine.py

@@ -1,190 +0,0 @@
-"""
-Operational Transformation Engine
-Implements insert-insert, insert-delete, delete-insert, delete-delete
-transformations with correct overlap handling.
-
-Key fixes over original:
-- delete-delete overlap now correctly handles all 4 positional cases
-- transform_against_log is O(n) in missed ops, not re-scanned
-- apply_operation is side-effect free (returns new string)
-- All operations are immutable (copy.deepcopy on transform)
-"""
-
-from __future__ import annotations
-
-import copy
-from dataclasses import dataclass, field
-from typing import List, Literal, Tuple
-
-
-@dataclass
-class Operation:
-    op_type: Literal["insert", "delete"]
-    position: int
-    value: str = ""       # meaningful only for insert
-    length: int = 1       # meaningful only for delete
-    base_version: int = 0
-    user_id: str = ""
-    op_id: str = ""
-
-    def __post_init__(self):
-        # Normalize: insert length always derived from value
-        if self.op_type == "insert":
-            self.length = len(self.value)
-
-
-# ─── Pairwise transforms ──────────────────────────────────────────────────────
-
-def _transform_ii(op: Operation, against: Operation) -> Operation:
-    """insert vs insert"""
-    r = copy.deepcopy(op)
-    if against.position < op.position:
-        r.position += len(against.value)
-    elif against.position == op.position:
-        # Deterministic tie-break: lower user_id wins (goes first)
-        if against.user_id <= op.user_id:
-            r.position += len(against.value)
-    return r
-
-
-def _transform_di(op: Operation, against: Operation) -> Operation:
-    """
-    delete vs insert (against=insert already applied on server).
-
-    Policy: "delete wins" — a concurrent insert inside the delete range is
-    absorbed by the delete (the delete expands to cover new chars).
-    This is the dOPT/Jupiter convention: deletions are authoritative over
-    concurrent inserts within their range.
-    """
-    r = copy.deepcopy(op)
-    ins_len = len(against.value)
-    ins_pos = against.position
-    del_end = op.position + op.length
-
-    if ins_pos < op.position:
-        # Insert before delete start — shift delete right
-        r.position += ins_len
-    elif ins_pos <= del_end:
-        # Insert at or inside delete range (including right boundary) —
-        # expand delete to absorb the inserted chars
-        r.length += ins_len
-    # ins_pos > del_end: insert after delete — no change
-    return r
-
-
-def _transform_id(op: Operation, against: Operation) -> Operation:
-    """
-    insert vs delete (against=delete already applied on server).
-
-    Policy: "delete wins" — if the insert position falls inside the deleted
-    range, collapse the insert to del_start (the insert still happens, but
-    the content it was anchored to is gone).
-    """
-    r = copy.deepcopy(op)
-    del_start = against.position
-    del_end = against.position + against.length
-
-    if del_end <= op.position:
-        # Delete entirely before insert — shift left by deleted amount
-        r.position -= against.length
-    elif del_start < op.position:
-        # Insert was inside deleted range — collapse to del_start
-        r.position = del_start
-    # del_start >= op.position: delete is at or after insert — no change
-    return r
-
-
-def _transform_dd(op: Operation, against: Operation) -> Operation:
-    """delete vs delete"""
-    r = copy.deepcopy(op)
-
-    op_start = op.position
-    op_end = op.position + op.length
-    ag_start = against.position
-    ag_end = against.position + against.length
-
-    if ag_end <= op_start:
-        # Against entirely before op — shift op left
-        r.position -= against.length
-
-    elif ag_start >= op_end:
-        # Against entirely after op — no change
-        pass
-
-    else:
-        # Overlapping. Four sub-cases:
-        overlap_start = max(op_start, ag_start)
-        overlap_end = min(op_end, ag_end)
-        overlap = overlap_end - overlap_start
-
-        # Shift position if against starts before op
-        if ag_start < op_start:
-            # Characters before op that were deleted shift our start left
-            r.position = ag_start
-        # else: op starts before against, position unchanged
-
-        # Reduce length by the overlap (already deleted by `against`)
-        r.length = max(0, op.length - overlap)
-
-    return r
-
-
-def transform_operation(incoming: Operation, applied: Operation) -> Operation:
-    """Transform `incoming` against an already-applied `applied`."""
-    if incoming.op_type == "insert":
-        if applied.op_type == "insert":
-            return _transform_ii(incoming, applied)
-        else:
-            return _transform_id(incoming, applied)
-    else:
-        if applied.op_type == "insert":
-            return _transform_di(incoming, applied)
-        else:
-            return _transform_dd(incoming, applied)
-
-
-def transform_against_log(
-    incoming: Operation,
-    op_log: List[Tuple[int, Operation]],
-    from_version: int,
-    to_version: int,
-) -> Operation:
-    """
-    Transform `incoming` (based at `from_version`) against every operation
-    in op_log with version in range (from_version, to_version].
-    """
-    result = copy.deepcopy(incoming)
-    for ver, applied_op in op_log:
-        if from_version < ver <= to_version:
-            result = transform_operation(result, applied_op)
-    return result
-
-
-# ─── Apply ───────────────────────────────────────────────────────────────────
-
-def apply_operation(content: str, op: Operation) -> str:
-    """Apply a single operation to content. Pure function."""
-    if op.op_type == "insert":
-        pos = max(0, min(op.position, len(content)))
-        return content[:pos] + op.value + content[pos:]
-    elif op.op_type == "delete":
-        if op.length <= 0:
-            return content
-        pos = max(0, min(op.position, len(content)))
-        end = max(0, min(pos + op.length, len(content)))
-        return content[:pos] + content[end:]
-    return content
-
-
-def transform_cursor(cursor_pos: int, op: Operation) -> int:
-    """Adjust a cursor position given an applied operation."""
-    if op.op_type == "insert":
-        if op.position <= cursor_pos:
-            return cursor_pos + len(op.value)
-    elif op.op_type == "delete":
-        del_end = op.position + op.length
-        if del_end <= cursor_pos:
-            return cursor_pos - op.length
-        elif op.position <= cursor_pos:
-            return op.position
-    return cursor_pos