static void
inf_test_text_recover_text_erased_cb(InfTextBuffer* buffer,
guint pos,
InfTextChunk* chunk,
InfUser* user,
gpointer user_data)
{
InfAdoptedOperation* operation;
guint len;
InfTextChunk* print_chunk;
gsize print_bytes;
gpointer print_text;
/* If the document has substantial content and this deletes most of it,
* then print out the document here. */
len = inf_text_chunk_get_length(chunk);
if(inf_text_buffer_get_length(buffer) + len >= 50)
{
if(len >= (inf_text_buffer_get_length(buffer) + len)*75/100)
{
if(*(int*)user_data == 0)
{
print_chunk = inf_text_buffer_get_slice(
buffer,
0,
inf_text_buffer_get_length(buffer)
);
inf_text_chunk_insert_chunk(print_chunk, pos, chunk);
print_text = inf_text_chunk_get_text(print_chunk, &print_bytes);
inf_text_chunk_free(print_chunk);
printf("%.*s\n", (int)print_bytes, (gchar*)print_text);
g_free(print_text);
}
--*(int*)user_data;
}
}
g_object_unref(buffer);
}
static void
inf_test_util_print_buffer(InfTextBuffer* buffer)
{
InfTextChunk* chunk;
gchar* text;
gsize bytes;
chunk = inf_text_buffer_get_slice(
buffer,
0,
inf_text_buffer_get_length(buffer)
);
text = inf_text_chunk_get_text(chunk, &bytes);
inf_text_chunk_free(chunk);
printf("%.*s\n", (int)bytes, text);
g_free(text);
}
static gboolean
check_buffer(InfTextBuffer* buffer,
const gchar* check_text,
const gchar* buffer_name)
{
InfTextChunk* chunk;
gpointer text;
gsize len;
gboolean result;
chunk = inf_text_buffer_get_slice(
buffer,
0,
inf_text_buffer_get_length(buffer)
);
text = inf_text_chunk_get_text(chunk, &len);
inf_text_chunk_free(chunk);
if(strlen(check_text) != len || strncmp(check_text, text, len) != 0)
{
printf(
"%s Buffer has text \"%.*s\" but should have \"%s\"\n",
buffer_name,
(int)len, (gchar*)text,
check_text
);
result = FALSE;
}
else
{
result = TRUE;
}
g_free(text);
return result;
}
static gboolean
inf_text_default_delete_operation_text_match(
InfTextDefaultDeleteOperation* operation,
InfTextBuffer* buffer)
{
InfTextDefaultDeleteOperationPrivate* priv;
InfTextChunk* chunk;
gchar* first;
gchar* second;
gsize first_len;
gsize second_len;
int result;
priv = INF_TEXT_DEFAULT_DELETE_OPERATION_PRIVATE(operation);
/* TODO: inf_text_chunk_cmp_substring */
chunk = inf_text_buffer_get_slice(
buffer,
priv->position,
inf_text_chunk_get_length(priv->chunk)
);
first = inf_text_chunk_get_text(priv->chunk, &first_len);
second = inf_text_chunk_get_text(chunk, &second_len);
inf_text_chunk_free(chunk);
/* TODO: Owners must match, too */
if(first_len == second_len)
result = memcmp(first, second, first_len);
else
result = 1; /* != 0 */
g_free(second);
g_free(first);
return result == 0;
}
static void
infinoted_directory_sync_session_save(InfinotedDirectorySync* dsync,
InfinotedDirectorySyncSession* session)
{
InfdDirectoryIter* iter;
GError* error;
InfBuffer* buffer;
InfTextChunk* chunk;
gchar* content;
gsize bytes;
iter = &session->iter;
error = NULL;
if(session->timeout != NULL)
{
inf_io_remove_timeout(
infd_directory_get_io(dsync->directory),
session->timeout
);
session->timeout = NULL;
}
buffer = inf_session_get_buffer(
infd_session_proxy_get_session(session->proxy)
);
error = NULL;
if(!infinoted_util_create_dirname(session->path, &error))
{
g_warning(_("Failed to create directory for path \"%s\": %s\n\n"),
session->path, error->message);
g_error_free(error);
}
else
{
/* TODO: Use the iterator API here, which should be less expensive */
chunk = inf_text_buffer_get_slice(
INF_TEXT_BUFFER(buffer),
0,
inf_text_buffer_get_length(INF_TEXT_BUFFER(buffer))
);
content = inf_text_chunk_get_text(chunk, &bytes);
inf_text_chunk_free(chunk);
if(!g_file_set_contents(session->path, content, bytes, &error))
{
g_warning(
_("Failed to write session for path \"%s\": %s\n\n"
"Will retry in %u seconds."),
session->path, error->message, dsync->sync_interval
);
g_error_free(error);
infinoted_directory_sync_session_start(session->dsync, session);
}
g_free(content);
}
}
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);
}
TextChunk *TextBuffer::slice( unsigned int pos,
unsigned int len )
{
return new TextChunk( inf_text_buffer_get_slice( INF_TEXT_BUFFER(gobject()),
pos, len ) );
}
