Function apply_insert_only

atomic-core/src/crdt/apply/branch.rs:216–263

Applies an Insert operation without nested leaf operations.

(
    txn: &mut T,
    context: &mut ApplyContext,
    trunk_id: TrunkId,
    branch_id: BranchId,
    after: Option<BranchId>,
)

/// Applies an Insert operation without nested leaf operations.
fn apply_insert_only<T: MutCrdtTxnT>(
    txn: &mut T,
    context: &mut ApplyContext,
    trunk_id: TrunkId,
    branch_id: BranchId,
    after: Option<BranchId>,
) -> ApplyResult<()> {
    // Check for duplicate ID
    if txn
        .has_branch(branch_id)
        .map_err(|e| storage_err(e, "checking branch exists"))?
    {
        if context.options().allow_duplicate_ids() {
            context.record_skipped();
            return Ok(());
        }
        return Err(ApplyError::branch_already_exists(branch_id));
    }

    // Validate trunk exists (optional based on validation settings)
    if context.options().validate_references()
        && !txn
            .has_trunk(trunk_id)
            .map_err(|e| storage_err(e, "checking trunk exists"))?
    {
        return Err(ApplyError::trunk_not_found(trunk_id));
    }

    // Validate "after" reference if provided
    if context.options().validate_references() {
        if let Some(after_id) = after {
            if !txn
                .has_branch(after_id)
                .map_err(|e| storage_err(e, "checking after branch"))?
            {
                return Err(ApplyError::branch_not_found(after_id));
            }
        }
    }

    // Create and store the branch
    let branch = Branch::new(branch_id, trunk_id);
    txn.put_branch(&branch, after)
        .map_err(|e| storage_err(e, "inserting branch"))?;

    context.record_branch_inserted();
    Ok(())
}

// Delete Operation