static InfAdoptedOperation*
inf_text_remote_delete_operation_copy(InfAdoptedOperation* operation)
{
InfTextRemoteDeleteOperationPrivate* priv;
GObject* result;
InfTextRemoteDeleteOperationPrivate* result_priv;
priv = INF_TEXT_REMOTE_DELETE_OPERATION_PRIVATE(operation);
result = g_object_new(
INF_TEXT_TYPE_REMOTE_DELETE_OPERATION,
"position", priv->position,
"length", priv->length,
NULL
);
result_priv = INF_TEXT_REMOTE_DELETE_OPERATION_PRIVATE(result);
result_priv->recon = inf_text_remote_delete_operation_recon_copy(
priv->recon
);
result_priv->recon_offset = priv->recon_offset;
return INF_ADOPTED_OPERATION(result);
}
static InfTextDeleteOperation*
inf_text_remote_delete_operation_transform_overlap(
InfTextDeleteOperation* operation,
InfTextDeleteOperation* other,
guint position,
guint begin,
guint other_begin,
guint length)
{
InfTextRemoteDeleteOperationPrivate* priv;
InfTextChunk* chunk;
GObject* result;
InfTextRemoteDeleteOperationPrivate* result_priv;
/* It is actually possible that two remote delete operations are
* transformed against each other (actually the parts of a splitted
* remote delete operation). However, they must not overlap. */
g_assert(INF_TEXT_IS_DEFAULT_DELETE_OPERATION(other));
priv = INF_TEXT_REMOTE_DELETE_OPERATION_PRIVATE(operation);
chunk = inf_text_chunk_substring(
inf_text_default_delete_operation_get_chunk(
INF_TEXT_DEFAULT_DELETE_OPERATION(other)
),
other_begin,
length
);
result = g_object_new(
INF_TEXT_TYPE_REMOTE_DELETE_OPERATION,
"position", position,
"length", priv->length - length,
NULL
);
result_priv = INF_TEXT_REMOTE_DELETE_OPERATION_PRIVATE(result);
result_priv->recon = inf_text_remote_delete_operation_recon_feed(
priv->recon,
begin,
chunk
);
inf_text_chunk_free(chunk);
result_priv->recon_offset = priv->recon_offset;
return INF_TEXT_DELETE_OPERATION(result);
}
static void
inf_text_remote_delete_operation_get_property(GObject* object,
guint prop_id,
GValue* value,
GParamSpec* pspec)
{
InfTextRemoteDeleteOperation* operation;
InfTextRemoteDeleteOperationPrivate* priv;
operation = INF_TEXT_REMOTE_DELETE_OPERATION(object);
priv = INF_TEXT_REMOTE_DELETE_OPERATION_PRIVATE(operation);
switch(prop_id)
{
case PROP_POSITION:
g_value_set_uint(value, priv->position);
break;
case PROP_LENGTH:
g_value_set_uint(value, priv->length);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
static void
inf_text_remote_delete_operation_finalize(GObject* object)
{
InfTextRemoteDeleteOperation* operation;
InfTextRemoteDeleteOperationPrivate* priv;
operation = INF_TEXT_REMOTE_DELETE_OPERATION(object);
priv = INF_TEXT_REMOTE_DELETE_OPERATION_PRIVATE(operation);
inf_text_remote_delete_operation_recon_free(priv->recon);
G_OBJECT_CLASS(parent_class)->finalize(object);
}
static void
inf_text_remote_delete_operation_init(GTypeInstance* instance,
gpointer g_class)
{
InfTextRemoteDeleteOperation* operation;
InfTextRemoteDeleteOperationPrivate* priv;
operation = INF_TEXT_REMOTE_DELETE_OPERATION(instance);
priv = INF_TEXT_REMOTE_DELETE_OPERATION_PRIVATE(operation);
priv->position = 0;
priv->length = 0;
priv->recon = NULL;
priv->recon_offset = 0;
}
static void
inf_text_remote_delete_operation_apply(InfAdoptedOperation* operation,
InfAdoptedUser* by,
InfBuffer* buffer)
{
InfTextRemoteDeleteOperationPrivate* priv;
g_assert(INF_TEXT_IS_REMOTE_DELETE_OPERATION(operation));
g_assert(INF_TEXT_IS_BUFFER(buffer));
priv = INF_TEXT_REMOTE_DELETE_OPERATION_PRIVATE(operation);
inf_text_buffer_erase_text(
INF_TEXT_BUFFER(buffer),
priv->position,
priv->length,
INF_USER(by)
);
}
static gboolean
inf_text_remote_delete_operation_apply(InfAdoptedOperation* operation,
InfAdoptedUser* by,
InfBuffer* buffer,
GError** error)
{
InfTextRemoteDeleteOperationPrivate* priv;
g_assert(INF_TEXT_IS_REMOTE_DELETE_OPERATION(operation));
g_assert(INF_TEXT_IS_BUFFER(buffer));
priv = INF_TEXT_REMOTE_DELETE_OPERATION_PRIVATE(operation);
if(priv->position + priv->length >
inf_text_buffer_get_length(INF_TEXT_BUFFER(buffer)))
{
g_set_error(
error,
g_quark_from_static_string("INF_TEXT_OPERATION_ERROR"),
INF_TEXT_OPERATION_ERROR_INVALID_DELETE,
"%s",
_("Attempt to remove text from after the end of the document")
);
return FALSE;
}
else
{
inf_text_buffer_erase_text(
INF_TEXT_BUFFER(buffer),
priv->position,
priv->length,
INF_USER(by)
);
return TRUE;
}
}
static InfAdoptedSplitOperation*
inf_text_remote_delete_operation_transform_split(
InfTextDeleteOperation* operation,
guint split_pos,
guint split_len)
{
/* Need to split the delete operation and the recon list */
InfTextRemoteDeleteOperationPrivate* priv;
InfAdoptedSplitOperation* result;
GObject* first_operation;
GObject* second_operation;
InfTextRemoteDeleteOperationPrivate* result_priv;
InfTextRemoteDeleteOperationRecon* recon;
InfTextRemoteDeleteOperationRecon* new_recon;
GSList* first_recon;
GSList* second_recon;
guint recon_cur_len;
GSList* item;
priv = INF_TEXT_REMOTE_DELETE_OPERATION_PRIVATE(operation);
first_recon = NULL;
second_recon = NULL;
recon_cur_len = 0;
for(item = priv->recon; item != NULL; item = g_slist_next(item))
{
recon = (InfTextRemoteDeleteOperationRecon*)item->data;
g_assert(recon->position >= recon_cur_len);
if(recon->position - recon_cur_len <= split_pos)
{
new_recon = g_slice_new(InfTextRemoteDeleteOperationRecon);
new_recon->position = recon->position;
new_recon->chunk = inf_text_chunk_copy(recon->chunk);
first_recon = g_slist_prepend(first_recon, new_recon);
recon_cur_len += inf_text_chunk_get_length(recon->chunk);
}
else
{
new_recon = g_slice_new(InfTextRemoteDeleteOperationRecon);
new_recon->position = recon->position - (split_pos + recon_cur_len);
new_recon->chunk = inf_text_chunk_copy(recon->chunk);
second_recon = g_slist_prepend(second_recon, new_recon);
}
}
first_operation = g_object_new(
INF_TEXT_TYPE_REMOTE_DELETE_OPERATION,
"position", priv->position,
"length", split_pos,
NULL
);
second_operation = g_object_new(
INF_TEXT_TYPE_REMOTE_DELETE_OPERATION,
"position", priv->position + split_len,
"length", priv->length - split_pos,
NULL
);
result_priv = INF_TEXT_REMOTE_DELETE_OPERATION_PRIVATE(first_operation);
result_priv->recon = g_slist_reverse(first_recon);
result_priv->recon_offset = priv->recon_offset;
result_priv = INF_TEXT_REMOTE_DELETE_OPERATION_PRIVATE(second_operation);
result_priv->recon = g_slist_reverse(second_recon);
result_priv->recon_offset = priv->recon_offset + split_pos + recon_cur_len;
result = inf_adopted_split_operation_new(
INF_ADOPTED_OPERATION(first_operation),
INF_ADOPTED_OPERATION(second_operation)
);
g_object_unref(G_OBJECT(second_operation));
g_object_unref(G_OBJECT(first_operation));
return result;
}
static guint
inf_text_remote_delete_operation_get_length(InfTextDeleteOperation* operation)
{
return INF_TEXT_REMOTE_DELETE_OPERATION_PRIVATE(operation)->length;
}
static InfAdoptedOperation*
inf_text_remote_delete_operation_apply_transformed(InfAdoptedOperation* op,
InfAdoptedOperation* trans,
InfAdoptedUser* by,
InfBuffer* buffer,
GError** error)
{
InfTextRemoteDeleteOperationPrivate* priv;
InfTextChunk* chunk;
InfTextChunk* temp_slice;
GSList* list;
GSList* item;
InfAdoptedOperation* operation;
GSList* recon_list;
GSList* recon_item;
InfTextRemoteDeleteOperationRecon* recon;
InfTextDefaultDeleteOperation* result;
g_assert(INF_TEXT_IS_REMOTE_DELETE_OPERATION(op));
g_assert(INF_TEXT_IS_BUFFER(buffer));
/* TODO: We can probably optimize this function, but then we should
* a) profile it and b) in many cases input parameters to this function
* are trivial anyway. */
if(INF_ADOPTED_IS_SPLIT_OPERATION(trans))
{
list = inf_adopted_split_operation_unsplit(
INF_ADOPTED_SPLIT_OPERATION(trans)
);
}
else
{
list = g_slist_prepend(NULL, trans);
}
chunk = inf_text_chunk_new(
inf_text_buffer_get_encoding(INF_TEXT_BUFFER(buffer))
);
/* We assume the list of remote delete operations to be in order */
for(item = list; item != NULL; item = g_slist_next(item))
{
g_assert(INF_TEXT_IS_REMOTE_DELETE_OPERATION(item->data));
priv = INF_TEXT_REMOTE_DELETE_OPERATION_PRIVATE(item->data);
operation = INF_ADOPTED_OPERATION(item->data);
if(priv->length > 0)
{
temp_slice = inf_text_buffer_get_slice(
INF_TEXT_BUFFER(buffer),
priv->position,
priv->length
);
recon_list = inf_text_remote_delete_operation_recon_feed(
priv->recon,
0,
temp_slice
);
inf_text_chunk_free(temp_slice);
}
else
{
recon_list = priv->recon;
}
for(recon_item = recon_list;
recon_item != NULL;
recon_item = g_slist_next(recon_item))
{
recon = (InfTextRemoteDeleteOperationRecon*)recon_item->data;
g_assert(priv->recon_offset + recon->position ==
inf_text_chunk_get_length(chunk));
inf_text_chunk_insert_chunk(
chunk,
inf_text_chunk_get_length(chunk),
recon->chunk
);
}
/* Free recon list if newly allocated */
if(priv->length > 0)
inf_text_remote_delete_operation_recon_free(recon_list);
if(!inf_adopted_operation_apply(operation, by, buffer, error))
{
g_slist_free(list);
inf_text_chunk_free(chunk);
return NULL;
}
}
g_slist_free(list);
priv = INF_TEXT_REMOTE_DELETE_OPERATION_PRIVATE(op);
result = inf_text_default_delete_operation_new(priv->position, chunk);
inf_text_chunk_free(chunk);
return INF_ADOPTED_OPERATION(result);
}
