static GSequenceIter *
find_first_proposal (GscProviderDevhelp *devhelp)
{
GSequenceIter *iter;
GSequenceIter *prev;
iter = g_sequence_search (devhelp->priv->proposals,
NULL,
(GCompareDataFunc)compare_items,
devhelp);
if (iter == NULL)
{
return NULL;
}
/* Test if this position might be after the last match */
if (!g_sequence_iter_is_begin (iter) &&
(g_sequence_iter_is_end (iter) ||
!iter_match_prefix (devhelp, iter)))
{
iter = g_sequence_iter_prev (iter);
/* Maybe there is actually nothing in the sequence */
if (g_sequence_iter_is_end (iter) ||
!iter_match_prefix (devhelp, iter))
{
return NULL;
}
}
if (g_sequence_iter_is_end (iter))
{
return NULL;
}
/* Go back while it matches */
while (iter &&
(prev = g_sequence_iter_prev (iter)) &&
iter_match_prefix (devhelp, prev))
{
iter = prev;
if (g_sequence_iter_is_begin (iter))
{
break;
}
}
return iter;
}
void
swfdec_text_buffer_insert_text (SwfdecTextBuffer *buffer,
gsize pos, const char *text)
{
gsize len;
GSequenceIter *iter;
SwfdecTextBufferFormat *format;
g_return_if_fail (SWFDEC_IS_TEXT_BUFFER (buffer));
g_return_if_fail (pos <= buffer->text->len);
g_return_if_fail (text != NULL);
len = strlen (text);
if (len == 0)
return;
if (pos == buffer->text->len) {
g_string_insert_len (buffer->text, pos, text, len);
format = swfdec_text_buffer_format_new ();
format->start = pos;
swfdec_text_attributes_copy (&format->attr,
&buffer->default_attributes, SWFDEC_TEXT_ATTRIBUTES_MASK);
iter = g_sequence_append (buffer->attributes, format);
swfdec_text_buffer_remove_duplicates (g_sequence_iter_prev (iter),
g_sequence_iter_next (iter));
} else {
g_string_insert_len (buffer->text, pos, text, len);
iter = g_sequence_get_end_iter (buffer->attributes);
for (;;) {
iter = g_sequence_iter_prev (iter);
format = g_sequence_get (iter);
if (format->start <= pos)
break;
format->start += len;
}
}
CHECK_ATTRIBUTES (buffer);
/* adapt cursor */
if (buffer->cursor_start >= pos)
buffer->cursor_start += len;
if (buffer->cursor_end >= pos)
buffer->cursor_end += len;
g_signal_emit (buffer, signals[TEXT_CHANGED], 0);
g_signal_emit (buffer, signals[CURSOR_CHANGED], 0,
(gulong) MIN (buffer->cursor_start, buffer->cursor_end),
(gulong) MAX (buffer->cursor_start, buffer->cursor_end));
}
void g_sequence_remove_sorted ( GSequence * seq, gpointer data, GCompareDataFunc cmp_func, gpointer cmp_data )
{
gpointer found;
GSequenceIter * sj, * si = g_sequence_lookup( seq, data, cmp_func, cmp_data );
if ( si == NULL )
return;
sj = si;
while ( !g_sequence_iter_is_end( sj ) )
{
found = g_sequence_get( sj );
if ( found == data )
return g_sequence_remove( sj );
else if ( cmp_func( found, data, cmp_data ) != 0 )
break;
sj = g_sequence_iter_next( sj );
}
sj = si;
while ( !g_sequence_iter_is_begin( sj ) )
{
sj = g_sequence_iter_prev( sj );
found = g_sequence_get( sj );
if ( found == data )
return g_sequence_remove( sj );
else if ( cmp_func( found, data, cmp_data ) != 0 )
break;
}
}
static gpointer
photos_base_manager_get_item (GListModel *list, guint position)
{
PhotosBaseManager *self = PHOTOS_BASE_MANAGER (list);
PhotosBaseManagerPrivate *priv;
GSequenceIter *iter = NULL;
gpointer ret_val = NULL;
priv = photos_base_manager_get_instance_private (self);
if (priv->last_position != G_MAXUINT)
{
if (priv->last_position == position + 1)
iter = g_sequence_iter_prev (priv->last_iter);
else if (priv->last_position == position - 1)
iter = g_sequence_iter_next (priv->last_iter);
else if (priv->last_position == position)
iter = priv->last_iter;
}
if (iter == NULL)
iter = g_sequence_get_iter_at_pos (priv->sequence, position);
priv->last_iter = iter;
priv->last_position = position;
if (g_sequence_iter_is_end (iter))
goto out;
ret_val = g_object_ref (g_sequence_get (iter));
out:
return ret_val;
}
gboolean sorted_sequence_contains(SortedSequence * sequence, gpointer data)
{
GSequenceIter * iter = g_sequence_search(sequence -> seq, data, sequence -> cmp_func, NULL);
GSequenceIter * prev = g_sequence_iter_prev(iter);
if (g_sequence_iter_is_end(prev)) return FALSE;
gpointer element = g_sequence_get(prev);
return sequence -> cmp_func(data, element, NULL) == 0;
}
static gboolean
clutter_list_model_iter_is_last (ClutterModelIter *iter)
{
ClutterListModelIter *iter_default;
ClutterModelIter *temp_iter;
ClutterModel *model;
GSequence *sequence;
GSequenceIter *begin, *end;
iter_default = CLUTTER_LIST_MODEL_ITER (iter);
g_assert (iter_default->seq_iter != NULL);
if (g_sequence_iter_is_end (iter_default->seq_iter))
return TRUE;
model = clutter_model_iter_get_model (iter);
sequence = CLUTTER_LIST_MODEL (model)->priv->sequence;
begin = g_sequence_get_end_iter (sequence);
begin = g_sequence_iter_prev (begin);
end = iter_default->seq_iter;
temp_iter = CLUTTER_LIST_MODEL (model)->priv->temp_iter;
while (!g_sequence_iter_is_begin (begin))
{
CLUTTER_LIST_MODEL_ITER (temp_iter)->seq_iter = begin;
if (clutter_model_filter_iter (model, temp_iter))
{
end = begin;
break;
}
begin = g_sequence_iter_prev (begin);
}
/* This is because the 'end_iter' is always *after* the last valid iter.
* Otherwise we'd have endless loops
*/
end = g_sequence_iter_next (end);
return iter_default->seq_iter == end;
}
void sorted_sequence_remove(SortedSequence * sequence, gpointer data)
{
GSequenceIter * iter = g_sequence_search(sequence -> seq, data, sequence -> cmp_func, NULL);
GSequenceIter * prev = g_sequence_iter_prev(iter);
gpointer element = g_sequence_get(prev);
if(sequence -> cmp_func(data, element, NULL) == 0){
g_sequence_remove(prev);
}
}
static ClutterModelIter *
clutter_list_model_iter_prev (ClutterModelIter *iter)
{
ClutterListModelIter *iter_default;
ClutterModelIter *temp_iter;
ClutterModel *model;
GSequenceIter *filter_prev;
guint row;
iter_default = CLUTTER_LIST_MODEL_ITER (iter);
g_assert (iter_default->seq_iter != NULL);
model = clutter_model_iter_get_model (iter);
row = clutter_model_iter_get_row (iter);
filter_prev = g_sequence_iter_prev (iter_default->seq_iter);
g_assert (filter_prev != NULL);
temp_iter = CLUTTER_LIST_MODEL (model)->priv->temp_iter;
while (!g_sequence_iter_is_begin (filter_prev))
{
CLUTTER_LIST_MODEL_ITER (temp_iter)->seq_iter = filter_prev;
if (clutter_model_filter_iter (model, temp_iter))
{
row -= 1;
break;
}
filter_prev = g_sequence_iter_prev (filter_prev);
}
if (g_sequence_iter_is_begin (filter_prev))
row -= 1;
/* update the iterator and return it */
clutter_model_iter_set_row (CLUTTER_MODEL_ITER (iter_default), row);
iter_default->seq_iter = filter_prev;
return CLUTTER_MODEL_ITER (iter_default);
}
/* return iter to format relevant for position, that is the format pointed to
* by iter will have a lower or equal start index than pos */
static GSequenceIter *
swfdec_text_buffer_get_iter_for_pos (SwfdecTextBuffer *buffer, guint pos)
{
SwfdecTextBufferFormat format = { pos, };
GSequenceIter *iter;
iter = g_sequence_search (buffer->attributes, &format,
swfdec_text_buffer_format_compare, NULL);
if (g_sequence_iter_is_end (iter) ||
((SwfdecTextBufferFormat *) g_sequence_get (iter))->start > pos)
iter = g_sequence_iter_prev (iter);
return iter;
}
const BlueSkyRangesetItem *bluesky_rangeset_lookup(BlueSkyRangeset *rangeset,
uint64_t offset)
{
GSequenceIter *i;
i = g_sequence_search(rangeset->seq, &offset, compare64, NULL);
i = g_sequence_iter_prev(i);
if (g_sequence_iter_is_end(i))
return NULL;
BlueSkyRangesetItem *item = (BlueSkyRangesetItem *)g_sequence_get(i);
if (offset >= item->start && offset < item->start + item->length)
return item;
else
return NULL;
}
static void
decorator_blacklist_add (TrackerDecorator *decorator,
gint id)
{
TrackerDecoratorPrivate *priv = decorator->priv;
GSequenceIter *iter;
iter = g_sequence_search (priv->blacklist_items,
GINT_TO_POINTER (id),
sequence_compare_func,
NULL);
if (g_sequence_iter_is_end (iter) ||
g_sequence_get (g_sequence_iter_prev (iter)) != GINT_TO_POINTER (id))
g_sequence_insert_before (iter, GINT_TO_POINTER (id));
}
/* Look up the first rangeset item starting at or following the given address.
* Can be used to iterate through a rangeset. */
const BlueSkyRangesetItem *bluesky_rangeset_lookup_next(BlueSkyRangeset *rangeset, uint64_t offset)
{
GSequenceIter *i;
i = g_sequence_search(rangeset->seq, &offset, compare64, NULL);
i = g_sequence_iter_prev(i);
if (g_sequence_iter_is_end(i))
return NULL;
BlueSkyRangesetItem *item = (BlueSkyRangesetItem *)g_sequence_get(i);
if (item->start < offset) {
i = g_sequence_iter_next(i);
if (g_sequence_iter_is_end(i))
item = NULL;
else
item = (BlueSkyRangesetItem *)g_sequence_get(i);
}
return item;
}
void
swfdec_text_buffer_set_attributes (SwfdecTextBuffer *buffer, gsize start,
gsize length, const SwfdecTextAttributes *attr, guint mask)
{
SwfdecTextBufferFormat *format;
GSequenceIter *start_iter, *iter, *end_iter;
gsize end;
g_return_if_fail (SWFDEC_IS_TEXT_BUFFER (buffer));
g_return_if_fail (start + length <= buffer->text->len);
g_return_if_fail (length > 0);
g_return_if_fail (attr != NULL);
g_return_if_fail (mask != 0);
/* ensure start and end position have an attribtues entry. If not, create one */
end = start + length;
start_iter = swfdec_text_buffer_get_iter_for_pos (buffer, start);
format = g_sequence_get (start_iter);
if (format->start < start) {
start_iter = swfdec_text_buffer_copy_format (buffer, start_iter, start);
}
if (end == buffer->text->len) {
end_iter = g_sequence_get_end_iter (buffer->attributes);
} else {
end_iter = swfdec_text_buffer_get_iter_for_pos (buffer, end);
format = g_sequence_get (end_iter);
if (format->start < end) {
end_iter = swfdec_text_buffer_copy_format (buffer, end_iter, end);
}
}
/* start_iter points to first item to modify, end_iter points after last item to modify */
/* modify all formats in range [start_iter, end_iter) */
for (iter = start_iter; iter != end_iter; iter = g_sequence_iter_next (iter)) {
format = g_sequence_get (iter);
swfdec_text_attributes_copy (&format->attr, attr, mask);
}
/* remove entries that are identical now */
swfdec_text_buffer_remove_duplicates (g_sequence_iter_prev (start_iter),
g_sequence_iter_next (end_iter));
CHECK_ATTRIBUTES (buffer);
g_signal_emit (buffer, signals[TEXT_CHANGED], 0);
}
gboolean bluesky_rangeset_insert(BlueSkyRangeset *rangeset,
uint64_t start, uint64_t length,
gpointer data)
{
GSequenceIter *i;
i = g_sequence_search(rangeset->seq, &start, compare64, NULL);
i = g_sequence_iter_prev(i);
/* TODO: Checks that no other item overlaps. */
BlueSkyRangesetItem *item = g_new(BlueSkyRangesetItem, 1);
item->start = start;
item->length = length;
item->data = data;
g_sequence_insert_sorted(rangeset->seq, item, compare64, NULL);
return TRUE;
}
/* removes duplicates in the range [iter, end) */
static void
swfdec_text_buffer_remove_duplicates (GSequenceIter *iter, GSequenceIter *end)
{
SwfdecTextBufferFormat *format, *next;
g_assert (iter != end);
format = g_sequence_get (iter);
for (iter = g_sequence_iter_next (iter); iter != end; iter = g_sequence_iter_next (iter)) {
next = g_sequence_get (iter);
if (swfdec_text_attributes_diff (&format->attr, &next->attr) == 0) {
GSequenceIter *prev = g_sequence_iter_prev (iter);
g_sequence_remove (iter);
iter = prev;
} else {
format = next;
}
}
}
/**
* gst_timed_value_control_source_find_control_point_iter:
* @self: the control source to search in
* @timestamp: the search key
*
* Find last value before given timestamp in control point list.
* If all values in the control point list come after the given
* timestamp or no values exist, %NULL is returned.
*
* For use in control source implementations.
*
* Returns: (transfer none): the found #GSequenceIter or %NULL
*/
GSequenceIter *gst_timed_value_control_source_find_control_point_iter
(GstTimedValueControlSource * self, GstClockTime timestamp)
{
GSequenceIter *iter;
if (!self->values)
return NULL;
iter =
g_sequence_search (self->values, ×tamp,
(GCompareDataFunc) gst_control_point_find, NULL);
/* g_sequence_search() returns the iter where timestamp
* would be inserted, i.e. the iter > timestamp, so
* we need to get the previous one. And of course, if
* there is no previous one, we return NULL. */
if (g_sequence_iter_is_begin (iter))
return NULL;
return g_sequence_iter_prev (iter);
}
RmOff rm_offset_bytes_to_next_fragment(RmOffsetTable offset_list, RmOff file_offset) {
if (offset_list != NULL) {
RmOffsetEntry token;
token.physical = 0;
token.logical = file_offset;
GSequenceIter *next_fragment = g_sequence_iter_prev(
g_sequence_search(
offset_list, &token,
(GCompareDataFunc)rm_offset_find_logical, NULL
)
);
if(!g_sequence_iter_is_end(next_fragment) && !g_sequence_iter_is_begin(next_fragment) ) {
RmOffsetEntry *off = g_sequence_get(next_fragment);
return off->logical - file_offset;
}
}
/* default to 0 always */
return 0;
}
/* Determine the full extent of a rangeset--the smallest offset covered and the
* length needed to extend to the end of the last item. */
void bluesky_rangeset_get_extents(BlueSkyRangeset *rangeset,
uint64_t *start, uint64_t *length)
{
GSequenceIter *i;
BlueSkyRangesetItem *item;
i = g_sequence_get_begin_iter(rangeset->seq);
if (g_sequence_iter_is_end(i)) {
*start = 0;
*length = 0;
return;
}
item = (BlueSkyRangesetItem *)g_sequence_get(i);
*start = item->start;
i = g_sequence_get_end_iter(rangeset->seq);
i = g_sequence_iter_prev(i);
item = (BlueSkyRangesetItem *)g_sequence_get(i);
*length = (item->start + item->length) - *start;
}
static GObject *
photos_base_manager_default_get_previous_object (PhotosBaseManager *self, GObject *object)
{
PhotosBaseManagerPrivate *priv;
GObject *ret_val = NULL;
GSequenceIter *iter;
PhotosBaseManagerObjectData *object_data;
const gchar *id;
priv = photos_base_manager_get_instance_private (self);
id = photos_filterable_get_id (PHOTOS_FILTERABLE (object));
object_data = g_hash_table_lookup (priv->objects, id);
g_return_val_if_fail (object_data != NULL, NULL);
iter = g_sequence_iter_prev (object_data->iter);
if (g_sequence_iter_compare (iter, object_data->iter) == 0)
goto out;
ret_val = G_OBJECT (g_sequence_get (iter));
out:
return ret_val;
}
static ClutterModelIter *
clutter_list_model_get_iter_at_row (ClutterModel *model,
guint row)
{
ClutterListModel *model_default = CLUTTER_LIST_MODEL (model);
GSequence *sequence = model_default->priv->sequence;
gint seq_length = g_sequence_get_length (sequence);
ClutterListModelIter *retval;
if (row >= seq_length)
return NULL;
retval = g_object_new (CLUTTER_TYPE_LIST_MODEL_ITER,
"model", model,
"row", row,
NULL);
/* short-circuit in case we don't have a filter in place */
if (!clutter_model_get_filter_set (model))
{
retval->seq_iter = g_sequence_get_iter_at_pos (sequence, row);
return CLUTTER_MODEL_ITER (retval);
}
if (row == 0)
{
GSequenceIter *filter_next;
gboolean row_found = FALSE;
filter_next = g_sequence_get_begin_iter (sequence);
g_assert (filter_next != NULL);
while (!g_sequence_iter_is_end (filter_next))
{
retval->seq_iter = filter_next;
if (clutter_model_filter_iter (model, CLUTTER_MODEL_ITER (retval)))
{
/* We've found a row that is valid under the filter */
row_found = TRUE;
break;
}
filter_next = g_sequence_iter_next (filter_next);
}
/* Everything has been filtered -> there is no first row */
if (!row_found)
{
g_object_unref (retval);
return NULL;
}
}
else
{
GSequenceIter *filter_prev;
filter_prev = g_sequence_get_end_iter (sequence);
g_assert (filter_prev != NULL);
filter_prev = g_sequence_iter_prev (filter_prev);
while (!g_sequence_iter_is_begin (filter_prev))
{
retval->seq_iter = filter_prev;
if (clutter_model_filter_iter (model, CLUTTER_MODEL_ITER (retval)))
break;
filter_prev = g_sequence_iter_prev (filter_prev);
}
}
return CLUTTER_MODEL_ITER (retval);
}
gboolean rclib_lyric_load_file(const gchar *filename, guint index)
{
RCLibLyricParsedData *parsed_data;
gchar *line;
GFile *file;
GFileInputStream *input_stream;
GDataInputStream *data_stream;
gsize line_len;
gint64 time = -1;
RCLibLyricPrivate *priv;
GSequenceIter *iter;
RCLibLyricData *lyric_data;
rclib_lyric_clean(index);
if(lyric_instance==NULL) return FALSE;
if(filename==NULL) return FALSE;
priv = RCLIB_LYRIC(lyric_instance)->priv;
if(priv==NULL) return FALSE;
file = g_file_new_for_path(filename);
if(file==NULL) return FALSE;
if(!g_file_query_exists(file, NULL))
{
g_object_unref(file);
return FALSE;
}
input_stream = g_file_read(file, NULL, NULL);
g_object_unref(file);
if(input_stream==NULL) return FALSE;
data_stream = g_data_input_stream_new(G_INPUT_STREAM(input_stream));
g_object_unref(input_stream);
if(data_stream==NULL) return FALSE;
g_data_input_stream_set_newline_type(data_stream,
G_DATA_STREAM_NEWLINE_TYPE_ANY);
if(index==1)
parsed_data = &(priv->parsed_data2);
else
parsed_data = &(priv->parsed_data1);
if(index!=1) index = 0;
while((line=g_data_input_stream_read_line(data_stream, &line_len,
NULL, NULL))!=NULL)
{
rclib_lyric_add_line(parsed_data, priv->regex, priv->encoding,
line, line_len);
g_free(line);
}
g_object_unref(data_stream);
for(iter = g_sequence_get_end_iter(parsed_data->seq);
!g_sequence_iter_is_begin(iter);)
{
iter = g_sequence_iter_prev(iter);
lyric_data = g_sequence_get(iter);
if(lyric_data==NULL) continue;
if(time>=0)
{
lyric_data->length = time - lyric_data->time;
}
time = lyric_data->time;
}
parsed_data->filename = g_strdup(filename);
g_signal_emit(lyric_instance, lyric_signals[SIGNAL_LYRIC_READY], 0,
index);
return TRUE;
}
void close_har() {
sds fname = sdsdup(destor.working_directory);
fname = sdscat(fname, "recipes/bv");
char s[20];
sprintf(s, "%d", jcr.id);
fname = sdscat(fname, s);
fname = sdscat(fname, ".sparse");
FILE* fp = fopen(fname, "w");
if (!fp) {
fprintf(stderr, "Can not create sparse file");
perror("The reason is");
exit(1);
}
jcr.total_container_num = g_hash_table_size(container_utilization_monitor);
GSequence *seq = g_sequence_new(NULL);
int64_t total_size = 0;
int64_t sparse_size = 0;
/* collect sparse containers */
GHashTableIter iter;
gpointer key, value;
g_hash_table_iter_init(&iter, container_utilization_monitor);
while (g_hash_table_iter_next(&iter, &key, &value)) {
struct containerRecord* cr = (struct containerRecord*) value;
total_size += cr->size;
if((1.0*cr->size/(CONTAINER_SIZE - CONTAINER_META_SIZE))
< destor.rewrite_har_utilization_threshold){
/* It is sparse */
if (inherited_sparse_containers
&& g_hash_table_lookup(inherited_sparse_containers, &cr->cid))
/* It is an inherited sparse container */
jcr.inherited_sparse_num++;
jcr.sparse_container_num++;
sparse_size += cr->size;
g_sequence_insert_sorted(seq, cr, g_record_cmp, NULL);
}
}
/*
* If the sparse size is too large,
* we need to trim the sequence to control the rewrite ratio.
* We use sparse_size/total_size to estimate the rewrite ratio of next backup.
* However, the estimation is inaccurate (generally over-estimating), since:
* 1. the sparse size is not an accurate indicator of utilization for next backup.
* 2. self-references.
*/
while(sparse_size*1.0/total_size > destor.rewrite_har_rewrite_limit){
/*
* The expected rewrite ratio exceeds the limit.
* We trim the last several records in the sequence.
* */
GSequenceIter* iter = g_sequence_iter_prev(g_sequence_get_end_iter(seq));
struct containerRecord* r = g_sequence_get(iter);
NOTICE("Trim sparse container %lld", r->cid);
sparse_size -= r->size;
g_sequence_remove(iter);
}
GSequenceIter* sparse_iter = g_sequence_get_begin_iter(seq);
while(sparse_iter != g_sequence_get_end_iter(seq)){
struct containerRecord* r = g_sequence_get(sparse_iter);
fprintf(fp, "%lld %d\n", r->cid, r->size);
sparse_iter = g_sequence_iter_next(sparse_iter);
}
fclose(fp);
NOTICE("Record %d sparse containers, and %d of them are inherited",
g_sequence_get_length(seq), jcr.inherited_sparse_num);
g_sequence_free(seq);
sdsfree(fname);
}
