static void
nemo_list_model_sort_file_entries (NemoListModel *model, GSequence *files, GtkTreePath *path)
{
GSequenceIter **old_order;
GtkTreeIter iter;
int *new_order;
int length;
int i;
FileEntry *file_entry;
gboolean has_iter;
length = g_sequence_get_length (files);
if (length <= 1) {
return;
}
/* generate old order of GSequenceIter's */
old_order = g_new (GSequenceIter *, length);
for (i = 0; i < length; ++i) {
GSequenceIter *ptr = g_sequence_get_iter_at_pos (files, i);
file_entry = g_sequence_get (ptr);
if (file_entry->files != NULL) {
gtk_tree_path_append_index (path, i);
nemo_list_model_sort_file_entries (model, file_entry->files, path);
gtk_tree_path_up (path);
}
old_order[i] = ptr;
}
/* sort */
g_sequence_sort (files, nemo_list_model_file_entry_compare_func, model);
/* generate new order */
new_order = g_new (int, length);
/* Note: new_order[newpos] = oldpos */
for (i = 0; i < length; ++i) {
new_order[g_sequence_iter_get_position (old_order[i])] = i;
}
/* Let the world know about our new order */
g_assert (new_order != NULL);
has_iter = FALSE;
if (gtk_tree_path_get_depth (path) != 0) {
gboolean get_iter_result;
has_iter = TRUE;
get_iter_result = gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, path);
g_assert (get_iter_result);
}
gtk_tree_model_rows_reordered (GTK_TREE_MODEL (model),
path, has_iter ? &iter : NULL, new_order);
g_free (old_order);
g_free (new_order);
}
/**
* gst_rtsp_mount_points_remove_factory:
* @mounts: a #GstRTSPMountPoints
* @path: a mount point
*
* Remove the #GstRTSPMediaFactory associated with @path in @mounts.
*/
void
gst_rtsp_mount_points_remove_factory (GstRTSPMountPoints * mounts,
const gchar * path)
{
GstRTSPMountPointsPrivate *priv;
DataItem item;
GSequenceIter *iter;
g_return_if_fail (GST_IS_RTSP_MOUNT_POINTS (mounts));
g_return_if_fail (path != NULL);
priv = mounts->priv;
item.path = (gchar *) path;
GST_INFO ("removing media factory for path %s", path);
g_mutex_lock (&priv->lock);
if (priv->dirty) {
g_sequence_sort (priv->mounts, data_item_compare, mounts);
priv->dirty = FALSE;
}
iter = g_sequence_lookup (priv->mounts, &item, data_item_compare, mounts);
if (iter) {
g_sequence_remove (iter);
priv->dirty = TRUE;
}
g_mutex_unlock (&priv->lock);
}
/**
* @brief Adjusts the alarm when a time set occurs and the wall clock
* and rtc clock diverge.
*
* This should also be called on init, in case of a crash before we
* were able to adjust the alarms successfully.
*
*/
void
recalculate_alarms(time_t delta)
{
if (delta)
{
/* Adjust each fixed time alarm by the delta.
* i.e. 5 seconds in the future + delta = T + 5 + delta
*/
GSequenceIter *iter = g_sequence_get_begin_iter(gAlarmQueue->alarms);
while (!g_sequence_iter_is_end(iter))
{
_Alarm *alarm = (_Alarm *)g_sequence_get(iter);
GSequenceIter *next = g_sequence_iter_next(iter);
if (alarm && !alarm->calendar)
{
alarm->expiry += delta;
}
iter = next;
}
/* resort */
g_sequence_sort(gAlarmQueue->alarms,
(GCompareDataFunc)alarm_cmp_func, NULL);
/* persist */
alarm_write_db();
}
return;
}
static void populate_service_list(struct connman_session *session)
{
struct service_entry *entry;
GSequenceIter *iter;
session->service_hash =
g_hash_table_new_full(g_direct_hash, g_direct_equal,
NULL, NULL);
session->service_list = __connman_service_get_list(session,
service_match,
create_service_entry,
destroy_service_entry);
g_sequence_sort(session->service_list, sort_services, session);
iter = g_sequence_get_begin_iter(session->service_list);
while (g_sequence_iter_is_end(iter) == FALSE) {
entry = g_sequence_get(iter);
DBG("service %p type %s name %s", entry->service,
service2bearer(connman_service_get_type(entry->service)),
entry->name);
g_hash_table_replace(session->service_hash,
entry->service, iter);
iter = g_sequence_iter_next(iter);
}
}
static void
load_hit_objects(osux_beatmap *beatmap,
GtkTreeStore *tree_store,
GSequence *ho_seq,
GtkTreeIter *hitobjects)
{
for (unsigned i = 0; i < beatmap->hitobject_count; ++i)
{
osux_hitobject *ho = &beatmap->hitobjects[i];
char *type;
switch (HIT_OBJECT_TYPE(ho)) {
case HITOBJECT_CIRCLE: type = _("Circle"); break;
case HITOBJECT_SLIDER: type = _("Slider"); break;
case HITOBJECT_SPINNER:type = _("Spinner"); break;
case HITOBJECT_HOLD: type = _("Hold"); break;
default: type = _("Invalid type"); break;
}
GtkTreeIter iter;
gtk_tree_store_append(tree_store, &iter, hitobjects);
gtk_tree_store_set(tree_store, &iter,
COL_OFFSET, ho->offset,
COL_TYPE, type,
COL_DETAILS, ho->details,
COL_OBJECT, ho, -1);
g_sequence_append(ho_seq, ho);
}
g_sequence_sort(ho_seq, &sort_object_end_offset, NULL);
}
RmOffsetTable rm_offset_create_table(const char *path) {
int fd = rm_sys_open(path, O_RDONLY);
if(fd == -1) {
rm_log_info("Error opening %s in setup_fiemap_extents\n", path);
return NULL;
}
/* struct fiemap does not allocate any extents by default,
* so we choose ourself how many of them we allocate.
* */
const int n_extents = 256;
struct fiemap *fiemap = g_malloc0(sizeof(struct fiemap) + n_extents * sizeof(struct fiemap_extent));
struct fiemap_extent *fm_ext = fiemap->fm_extents;
/* data structure we save our offsets in */
GSequence *self = g_sequence_new((GFreeFunc)rm_offset_free_func);
bool last = false;
while(!last) {
fiemap->fm_flags = 0;
fiemap->fm_extent_count = n_extents;
fiemap->fm_length = FIEMAP_MAX_OFFSET;
if(ioctl(fd, FS_IOC_FIEMAP, (unsigned long) fiemap) == -1) {
break;
}
/* This might happen on empty files - those have no
* extents, but they have an offset on the disk.
*/
if(fiemap->fm_mapped_extents <= 0) {
break;
}
/* used for detecting contiguous extents, which we ignore */
unsigned long expected = 0;
/* Remember all non contiguous extents */
for(unsigned i = 0; i < fiemap->fm_mapped_extents && !last; i++) {
if (i == 0 || fm_ext[i].fe_physical != expected) {
RmOffsetEntry *offset_entry = g_slice_new(RmOffsetEntry);
offset_entry->logical = fm_ext[i].fe_logical;
offset_entry->physical = fm_ext[i].fe_physical;
g_sequence_append(self, offset_entry);
}
expected = fm_ext[i].fe_physical + fm_ext[i].fe_length;
fiemap->fm_start = fm_ext[i].fe_logical + fm_ext[i].fe_length;
last = fm_ext[i].fe_flags & FIEMAP_EXTENT_LAST;
}
}
rm_sys_close(fd);
g_free(fiemap);
g_sequence_sort(self, (GCompareDataFunc)rm_offset_sort_logical, NULL);
return self;
}
static inline void
resort_and_fill_gaps (GESTrack * track)
{
g_sequence_sort (track->priv->trackelements_by_start,
(GCompareDataFunc) element_start_compare, NULL);
if (track->priv->updating == TRUE) {
update_gaps (track);
}
}
void
egg_sorted_hash_set_sort_func (EggSortedHash *hash,
GCompareDataFunc func,
gpointer data)
{
hash->sort_func = func;
hash->sort_func_data = data;
if (func)
g_sequence_sort (hash->items, func, data);
}
static void
clutter_list_model_resort (ClutterModel *model,
ClutterModelSortFunc func,
gpointer data)
{
SortClosure sort_closure = { NULL, 0, NULL, NULL };
sort_closure.model = model;
sort_closure.column = clutter_model_get_sorting_column (model);
sort_closure.func = func;
sort_closure.data = data;
g_sequence_sort (CLUTTER_LIST_MODEL (model)->priv->sequence,
sort_model_default,
&sort_closure);
}
void fm_folder_model_sort(FmFolderModel* model)
{
GHashTable* old_order;
gint *new_order;
GSequenceIter *items_it;
GtkTreePath *path;
/* if there is only one item */
if( model->items == NULL || g_sequence_get_length(model->items) <= 1 )
return;
old_order = g_hash_table_new(g_direct_hash, g_direct_equal);
/* save old order */
items_it = g_sequence_get_begin_iter(model->items);
while( !g_sequence_iter_is_end(items_it) )
{
int i = g_sequence_iter_get_position(items_it);
g_hash_table_insert( old_order, items_it, GINT_TO_POINTER(i) );
items_it = g_sequence_iter_next(items_it);
}
/* sort the list */
g_sequence_sort(model->items, fm_folder_model_compare, model);
/* save new order */
new_order = g_new( int, g_sequence_get_length(model->items) );
items_it = g_sequence_get_begin_iter(model->items);
while( !g_sequence_iter_is_end(items_it) )
{
int i = g_sequence_iter_get_position(items_it);
new_order[i] = (guint)g_hash_table_lookup(old_order, items_it);
items_it = g_sequence_iter_next(items_it);
}
g_hash_table_destroy(old_order);
path = gtk_tree_path_new();
gtk_tree_model_rows_reordered(GTK_TREE_MODEL(model),
path, NULL, new_order);
gtk_tree_path_free(path);
g_free(new_order);
}
static gboolean
g_file_monitor_source_set_rate_limit (GFileMonitorSource *fms,
gint64 rate_limit)
{
gboolean changed;
g_mutex_lock (&fms->lock);
if (rate_limit != fms->rate_limit)
{
fms->rate_limit = rate_limit;
g_sequence_sort (fms->pending_changes, pending_change_compare_ready_time, fms);
g_file_monitor_source_update_ready_time (fms);
changed = TRUE;
}
else
changed = FALSE;
g_mutex_unlock (&fms->lock);
return changed;
}
/**
* gst_rtsp_mount_points_match:
* @mounts: a #GstRTSPMountPoints
* @path: a mount point
* @matched: (out): the amount of @path matched
*
* Find the factory in @mounts that has the longest match with @path.
*
* If @matched is %NULL, @path will match the factory exactly otherwise
* the amount of characters that matched is returned in @matched.
*
* Returns: (transfer full): the #GstRTSPMediaFactory for @path.
* g_object_unref() after usage.
*/
GstRTSPMediaFactory *
gst_rtsp_mount_points_match (GstRTSPMountPoints * mounts,
const gchar * path, gint * matched)
{
GstRTSPMountPointsPrivate *priv;
GstRTSPMediaFactory *result = NULL;
GSequenceIter *iter, *best;
DataItem item, *ritem;
g_return_val_if_fail (GST_IS_RTSP_MOUNT_POINTS (mounts), NULL);
g_return_val_if_fail (path != NULL, NULL);
priv = mounts->priv;
item.path = (gchar *) path;
item.len = strlen (path);
g_mutex_lock (&priv->lock);
if (priv->dirty) {
g_sequence_sort (priv->mounts, data_item_compare, mounts);
g_sequence_foreach (priv->mounts, (GFunc) data_item_dump,
(gpointer) "sort :");
priv->dirty = FALSE;
}
/* find the location of the media in the hashtable we only use the absolute
* path of the uri to find a media factory. If the factory depends on other
* properties found in the url, this method should be overridden. */
iter = g_sequence_get_begin_iter (priv->mounts);
best = NULL;
while (!g_sequence_iter_is_end (iter)) {
ritem = g_sequence_get (iter);
data_item_dump (ritem, "inspect: ");
if (best == NULL) {
if (has_prefix (&item, ritem)) {
data_item_dump (ritem, "prefix: ");
best = iter;
}
} else {
if (!has_prefix (&item, ritem))
break;
best = iter;
data_item_dump (ritem, "new best: ");
}
iter = g_sequence_iter_next (iter);
}
if (best) {
ritem = g_sequence_get (best);
data_item_dump (ritem, "result: ");
if (matched || ritem->len == item.len) {
result = g_object_ref (ritem->factory);
if (matched)
*matched = ritem->len;
}
}
g_mutex_unlock (&priv->lock);
GST_INFO ("found media factory %p for path %s", result, path);
return result;
}
/*
* Select the top segments that are most similar with features.
* (top-k * prefetching_num) cannot be larger than the segment cache size.
*/
static void top_segment_select(GHashTable* features) {
/*
* Mapping segment IDs to similar segments that hold at least one of features.
*/
GHashTable *similar_segments = g_hash_table_new_full(g_int64_hash, g_int64_equal, NULL,
free_segment);
GHashTableIter iter;
gpointer key, value;
g_hash_table_iter_init(&iter, features);
/* Iterate the features of the segment. */
while (g_hash_table_iter_next(&iter, &key, &value)) {
/* Each feature is mapped to several segment IDs. */
segmentid *ids = kvstore_lookup((fingerprint*) key);
if (ids) {
index_overhead.lookup_requests++;
int i;
for (i = 0; i < destor.index_value_length; i++) {
if (ids[i] == TEMPORARY_ID)
break;
struct segment* s = g_hash_table_lookup(similar_segments, &ids[i]);
if (!s) {
s = new_segment_full();
s->id = ids[i];
g_hash_table_insert(similar_segments, &s->id, s);
}
char* feature = malloc(destor.index_key_size);
memcpy(feature, key, destor.index_key_size);
assert(!g_hash_table_contains(s->features, feature));
g_hash_table_insert(s->features, feature, NULL);
}
}else{
index_overhead.lookup_requests_for_unique++;
}
}
if (g_hash_table_size(similar_segments) != 0) {
/* Sorting similar segments in order of their number of hit features. */
GSequence *seq = g_sequence_new(NULL);
GHashTableIter iter;
gpointer key, value;
g_hash_table_iter_init(&iter, similar_segments);
while (g_hash_table_iter_next(&iter, &key, &value)) {
/* Insert similar segments into GSequence. */
struct segment* s = value;
NOTICE("candidate segment %lld with %d shared features", s->id,
g_hash_table_size(s->features));
g_sequence_insert_sorted(seq, s, g_segment_cmp_feature_num, NULL);
}
/* The number of selected similar segments */
int num = g_sequence_get_length(seq)
> destor.index_segment_selection_method[1] ?
destor.index_segment_selection_method[1] :
g_sequence_get_length(seq), i;
NOTICE("select Top-%d in %d segments", num, g_sequence_get_length(seq));
/* Prefetched top similar segments are pushed into the queue. */
for (i = 0; i < num; i++) {
/* Get the top segment */
struct segment *top = g_sequence_get(
g_sequence_get_begin_iter(seq));
NOTICE("read segment %lld", top->id);
fingerprint_cache_prefetch(top->id);
g_sequence_remove(g_sequence_get_begin_iter(seq));
g_sequence_foreach(seq, features_trim, top);
g_sequence_sort(seq, g_segment_cmp_feature_num, NULL);
}
g_sequence_free(seq);
}
g_hash_table_destroy(similar_segments);
}
static void t_key(ui_tab_t *tab, guint64 key) {
tab_t *t = (tab_t *)tab;
if(ui_listing_key(t->list, key, winrows/2))
return;
hub_user_t *sel = g_sequence_iter_is_end(t->list->sel) ? NULL : g_sequence_get(t->list->sel);
gboolean sort = FALSE;
switch(key) {
case INPT_CHAR('?'):
uit_main_keys("userlist");
break;
// Sorting
#define SETSORT(c) \
t->reverse = t->order == c ? !t->reverse : FALSE;\
t->order = c;\
sort = TRUE;
case INPT_CHAR('s'): // s/S - sort on share size
case INPT_CHAR('S'):
SETSORT(SORT_SHARE);
break;
case INPT_CHAR('u'): // u/U - sort on username
case INPT_CHAR('U'):
SETSORT(SORT_USER)
break;
case INPT_CHAR('D'): // D - sort on description
SETSORT(SORT_DESC)
break;
case INPT_CHAR('T'): // T - sort on client (= tag)
SETSORT(SORT_CLIENT)
break;
case INPT_CHAR('E'): // E - sort on email
SETSORT(SORT_MAIL)
break;
case INPT_CHAR('C'): // C - sort on connection
SETSORT(SORT_CONN)
break;
case INPT_CHAR('P'): // P - sort on IP
SETSORT(SORT_IP)
break;
case INPT_CHAR('o'): // o - toggle sorting OPs before others
t->opfirst = !t->opfirst;
sort = TRUE;
break;
#undef SETSORT
// Column visibility
case INPT_CHAR('d'): // d (toggle description visibility)
t->hide_desc = !t->hide_desc;
break;
case INPT_CHAR('t'): // t (toggle tag visibility)
t->hide_tag = !t->hide_tag;
break;
case INPT_CHAR('e'): // e (toggle e-mail visibility)
t->hide_mail = !t->hide_mail;
break;
case INPT_CHAR('c'): // c (toggle connection visibility)
t->hide_conn = !t->hide_conn;
break;
case INPT_CHAR('p'): // p (toggle IP visibility)
t->hide_ip = !t->hide_ip;
break;
case INPT_CTRL('j'): // newline
case INPT_CHAR('i'): // i (toggle user info)
t->details = !t->details;
break;
case INPT_CHAR('m'): // m (/msg user)
if(!sel)
ui_m(NULL, 0, "No user selected.");
else
uit_msg_open(sel->uid, tab);
break;
case INPT_CHAR('g'): // g (grant slot)
if(!sel)
ui_m(NULL, 0, "No user selected.");
else {
db_users_set(sel->hub->id, sel->uid, sel->name, db_users_get(sel->hub->id, sel->name) | DB_USERFLAG_GRANT);
ui_m(NULL, 0, "Slot granted.");
}
break;
case INPT_CHAR('b'): // b (/browse userlist)
case INPT_CHAR('B'): // B (force /browse userlist)
if(!sel)
ui_m(NULL, 0, "No user selected.");
else
uit_fl_queue(sel->uid, key == INPT_CHAR('B'), NULL, tab, TRUE, FALSE);
break;
case INPT_CHAR('q'): // q - download filelist and match queue for selected user
if(!sel)
ui_m(NULL, 0, "No user selected.");
else
uit_fl_queue(sel->uid, FALSE, NULL, NULL, FALSE, TRUE);
break;
}
if(sort) {
g_sequence_sort(t->list->list, sort_func, tab);
ui_listing_sorted(t->list);
ui_mf(NULL, 0, "Ordering by %s (%s%s)",
t->order == SORT_USER ? "user name" :
t->order == SORT_SHARE ? "share size" :
t->order == SORT_CONN ? "connection" :
t->order == SORT_DESC ? "description" :
t->order == SORT_MAIL ? "e-mail" :
t->order == SORT_CLIENT? "tag" : "IP address",
t->reverse ? "descending" : "ascending", t->opfirst ? ", OPs first" : "");
}
}
