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 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 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); }
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; }
/** * 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; }
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; }
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); }