gboolean
get_task_list (GArray *task_list)
{
GDir *dir;
const gchar *name;
GPid pid;
Task task;
if ((dir = g_dir_open ("/proc", 0, NULL)) == NULL)
return FALSE;
while ((name = g_dir_read_name(dir)) != NULL)
{
if ((pid = (GPid)g_ascii_strtoull (name, NULL, 0)) > 0)
{
if (get_task_details (pid, &task))
g_array_append_val(task_list, task);
}
}
g_dir_close (dir);
g_array_sort (task_list, task_pid_compare_fn);
return FALSE;
}
void
g_mount_spec_set_with_len (GMountSpec *spec,
const char *key,
const char *value,
int value_len)
{
int i;
char *value_copy;
g_return_if_fail (key != NULL);
g_return_if_fail (value != NULL);
if (value_len == -1)
value_copy = g_strdup (value);
else
value_copy = g_strndup (value, value_len);
for (i = 0; i < spec->items->len; i++)
{
GMountSpecItem *item = &g_array_index (spec->items, GMountSpecItem, i);
if (strcmp (item->key, key) == 0)
{
g_free (item->value);
item->value = value_copy;
return;
}
}
add_item (spec, key, value_copy);
g_array_sort (spec->items, item_compare);
}
GMountSpec *
g_mount_spec_from_dbus (GVariant *value)
{
GMountSpec *spec;
const gchar *key;
const gchar *mount_prefix;
GVariantIter *iter_mount_spec_items;
GVariant *v;
mount_prefix = NULL;
g_variant_get (value, "(^&aya{sv})",
&mount_prefix,
&iter_mount_spec_items);
spec = g_mount_spec_new (NULL);
g_free (spec->mount_prefix);
spec->mount_prefix = NULL;
if (mount_prefix && mount_prefix[0])
spec->mount_prefix = g_strdup (mount_prefix);
while (g_variant_iter_loop (iter_mount_spec_items, "{&sv}", &key, &v))
{
add_item (spec, key, g_variant_dup_bytestring (v, NULL));
}
g_variant_iter_free (iter_mount_spec_items);
/* Sort on key */
g_array_sort (spec->items, item_compare);
return spec;
}
void
eos_shard_writer_v1_write_to_fd (EosShardWriterV1 *self, int fd)
{
GVariant *variant;
/* Sort our records to allow for binary searches on retrieval. */
g_array_sort (self->entries, &compare_records);
variant = header_entry_variant (self->entries);
uint64_t header_size = g_variant_get_size (variant);
header_size = GUINT64_TO_LE (header_size);
g_variant_unref (variant);
lseek (fd, ALIGN (sizeof (header_size) + header_size), SEEK_SET);
int i;
for (i = 0; i < self->entries->len; i++) {
struct eos_shard_writer_v1_record_entry *e = &g_array_index (self->entries, struct eos_shard_writer_v1_record_entry, i);
write_blob (fd, &e->metadata);
write_blob (fd, &e->data);
}
lseek (fd, 0, SEEK_SET);
g_assert (write (fd, &header_size, sizeof (header_size)) >= 0);
variant = header_entry_variant (self->entries);
write_variant (fd, variant);
g_variant_unref (variant);
}
static void
mex_music_player_shuffle_toggled (MexMusicPlayer *player,
GParamSpec *spec,
MxButton *button)
{
MexMusicPlayerPrivate *priv = player->priv;
gint i;
if (mx_button_get_toggled (button))
{
gint length;
length = mex_model_get_length (priv->model);
priv->shuffle = g_array_sized_new (FALSE, FALSE, sizeof (gint), length);
for (i = 0; i < length; i++)
g_array_insert_val (priv->shuffle, i, i);
/* shuffle the list */
g_array_sort (priv->shuffle, mex_music_player_random_sort);
}
else
{
if (priv->shuffle)
{
g_array_free (priv->shuffle, TRUE);
priv->shuffle = NULL;
}
}
}
GkmFactory*
gkm_module_find_factory (GkmModule *self, CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs)
{
GkmFactory *factory;
gboolean matched;
gulong j;
gsize i;
g_return_val_if_fail (GKM_IS_MODULE (self), NULL);
g_return_val_if_fail (attrs || !n_attrs, NULL);
if (!self->pv->factories_sorted) {
g_array_sort (self->pv->factories, sort_factory_by_n_attrs);
self->pv->factories_sorted = TRUE;
}
for (i = 0; i < self->pv->factories->len; ++i) {
factory = &(g_array_index (self->pv->factories, GkmFactory, i));
matched = TRUE;
for (j = 0; j < factory->n_attrs; ++j) {
if (!gkm_attributes_contains (attrs, n_attrs, &factory->attrs[j])) {
matched = FALSE;
break;
}
}
if (matched)
return factory;
}
return NULL;
}
TwitterRequestParams *twitter_request_params_add_oauth_params(PurpleAccount * account, gboolean post, const gchar * url, const TwitterRequestParams * params, const gchar * token, const gchar * signing_key)
{
gboolean use_https = twitter_option_use_https(account) && purple_ssl_is_supported();
TwitterRequestParams *oauth_params = twitter_request_params_clone(params);
gchar *signme;
gchar *signature;
if (oauth_params == NULL)
oauth_params = twitter_request_params_new();
twitter_request_params_add(oauth_params, twitter_request_param_new("oauth_consumer_key", prpltwtr_auth_get_oauth_key(account)));
twitter_request_params_add(oauth_params, twitter_request_param_new_ll("oauth_nonce", twitter_oauth_generate_nonce()));
twitter_request_params_add(oauth_params, twitter_request_param_new("oauth_signature_method", "HMAC-SHA1"));
/* Added for status.net. Twitter doesn't seem to care */
twitter_request_params_add(oauth_params, twitter_request_param_new("oauth_callback", "oob"));
twitter_request_params_add(oauth_params, twitter_request_param_new_ll("oauth_timestamp", time(NULL)));
if (token)
twitter_request_params_add(oauth_params, twitter_request_param_new("oauth_token", token));
g_array_sort(oauth_params, (GCompareFunc) twitter_request_params_sort_do);
signme = twitter_oauth_get_text_to_sign(post, use_https, url, oauth_params);
signature = twitter_oauth_sign(signme, signing_key);
g_free(signme);
if (!signature) {
twitter_request_params_free(oauth_params);
return NULL;
} else {
twitter_request_params_add(oauth_params, twitter_request_param_new("oauth_signature", signature));
g_free(signature);
return oauth_params;
}
}
int
phraser_get_phrases(GArray * result, GString * input, PHRASER * phraser)
{
char * ptr, *start_ptr,*p;
int i,size;
MATCHED mt;
result = g_array_set_size(result, 0);
for (start_ptr = ptr = phraser->start_ptr; (ptr - start_ptr) < phraser->fsize; ptr
+= 64)
{
if (memcmp(ptr, input->str, input->len) == 0)
{
memset(&mt, 0,64);
p = ptr;
while (*p != ' ' && *p != '\t')
++p;
memcpy(mt.code, ptr, p - ptr );
while (*p == ' ' || *p == '\t')
++p;
strcpy(mt.hanzi, p);
result = g_array_append_val(result,mt );
size++;
}
}
//调节顺序
g_array_sort(result, mysort);
return size;
}
int
main (int argc, char **argv)
{
GMappedFile *f;
gchar *xml_data;
gsize xml_len;
f = g_mapped_file_new (ISO_639_XML_PATH, FALSE, NULL);
if (f != NULL) {
xml_data = (gchar *) g_mapped_file_get_contents (f);
xml_len = g_mapped_file_get_length (f);
} else {
GError *err = NULL;
if (!g_file_get_contents (ISO_639_XML_PATH, &xml_data, &xml_len, &err))
g_error ("Could not read %s: %s", ISO_639_XML_PATH, err->message);
}
languages = g_array_new (FALSE, TRUE, sizeof (IsoLang));
parse_iso_639_xml (xml_data, xml_len);
g_array_sort (languages, (GCompareFunc) languages_sort_func);
dump_languages ();
g_array_free (languages, TRUE);
if (f != NULL)
g_mapped_file_unref (f);
else
g_free (xml_data);
return 0;
}
void GLibArrayImpl::Sort(LArrayInst * inst, int (* list_compare_func) (const void * value1,
const void * value2))
{
g_return_if_fail(inst != NULL);
g_return_if_fail(list_compare_func != NULL);
g_array_sort(dynamic_cast<GLibArrayInst *>(inst)->m_array, (GCompareFunc)list_compare_func);
}
static GArray *
_get_ref_frame_cache (GstValidateSsim * self, const gchar * ref_file)
{
GFile *ref_dir_file = NULL;
GFileInfo *info;
GFileEnumerator *fenum;
GArray *frames = NULL;
gchar *ref_dir = NULL;
ref_dir = g_path_get_dirname (ref_file);
frames = g_hash_table_lookup (self->priv->ref_frames_cache, ref_file);
if (frames)
goto done;
ref_dir_file = g_file_new_for_path (ref_dir);
if (!(fenum = g_file_enumerate_children (ref_dir_file,
"standard::*", G_FILE_QUERY_INFO_NONE, NULL, NULL))) {
GST_INFO ("%s is not a folder", ref_dir);
goto done;
}
for (info = g_file_enumerator_next_file (fenum, NULL, NULL);
info; info = g_file_enumerator_next_file (fenum, NULL, NULL)) {
Frame iframe;
const gchar *display_name = g_file_info_get_display_name (info);
if (!_filename_get_timestamp (self, display_name, &iframe.ts)) {
g_object_unref (info);
continue;
}
iframe.path = g_build_path (G_DIR_SEPARATOR_S,
ref_dir, g_file_info_get_name (info), NULL);
g_object_unref (info);
if (!frames) {
frames = g_array_new (TRUE, TRUE, sizeof (Frame));
g_array_set_clear_func (frames, (GDestroyNotify) _free_frame);
}
g_array_append_val (frames, iframe);
}
if (frames) {
g_array_sort (frames, (GCompareFunc) _sort_frames);
g_hash_table_insert (self->priv->ref_frames_cache, g_strdup (ref_dir),
frames);
}
done:
g_clear_object (&ref_dir_file);
g_free (ref_dir);
return frames;
}
static void
gbl_symbols_vs_ext_new(void) {
DISSECTOR_ASSERT(gbl_symbols_vs_ext == NULL);
DISSECTOR_ASSERT(gbl_symbols_array != NULL);
g_array_sort(gbl_symbols_array, gbl_symbols_compare_vs);
gbl_symbols_vs_ext = value_string_ext_new((value_string *)(void *)gbl_symbols_array->data,
gbl_symbols_array->len+1,
"etch-global-symbols" );
}
/**
* fuzzy_insert:
* @fuzzy: (in): A #Fuzzy.
* @key: (in): An ASCII string.
* @value: (in): A value to associate with key.
*
* Inserts a string into the fuzzy matcher.
*
* Note that @key MUST be an ascii string. UTF-8 is not supported.
*/
void
fuzzy_insert (Fuzzy *fuzzy,
const gchar *key,
gpointer value)
{
FuzzyItem item;
GArray *table;
gchar *downcase = NULL;
gsize offset;
guint idx;
gint id;
gint i;
g_return_if_fail(fuzzy);
g_return_if_fail(key);
g_return_if_fail(fuzzy->id_to_text_offset->len < ((1 << 20) - 1));
if (!*key) {
return;
}
if (!fuzzy->case_sensitive) {
downcase = g_ascii_strdown(key, -1);
}
/*
* Insert the string into our heap.
* Track the offset within the heap since the heap could realloc.
*/
offset = fuzzy_heap_insert(fuzzy, key);
g_array_append_val(fuzzy->id_to_text_offset, offset);
g_ptr_array_add(fuzzy->id_to_value, value);
g_assert_cmpint(fuzzy->id_to_value->len, ==, fuzzy->id_to_text_offset->len);
id = fuzzy->id_to_text_offset->len - 1;
if (!fuzzy->case_sensitive) {
key = downcase;
}
for (i = 0; key[i]; i++) {
idx = key[i];
table = g_ptr_array_index(fuzzy->char_tables, idx);
item.id = id;
item.pos = i;
g_array_append_val(table, item);
if (!fuzzy->in_bulk_insert) {
g_array_sort(table, fuzzy_item_compare);
}
}
if (!fuzzy->case_sensitive) {
g_free(downcase);
}
}
static void
view_remove_contact_cb (EBookClientView *client_view,
const GSList *ids,
EAddressbookModel *model)
{
/* XXX we should keep a hash around instead of this O(n*m) loop */
const GSList *iter;
GArray *indices;
GPtrArray *array;
gint ii;
array = model->priv->contacts;
indices = g_array_new (FALSE, FALSE, sizeof (gint));
for (iter = ids; iter != NULL; iter = iter->next) {
const gchar *target_uid = iter->data;
for (ii = 0; ii < array->len; ii++) {
EContact *contact;
const gchar *uid;
contact = array->pdata[ii];
/* check if already removed */
if (!contact)
continue;
uid = e_contact_get_const (contact, E_CONTACT_UID);
g_return_if_fail (uid != NULL);
if (strcmp (uid, target_uid) == 0) {
g_object_unref (contact);
g_array_append_val (indices, ii);
array->pdata[ii] = NULL;
break;
}
}
}
/* Sort the 'indices' array in descending order, since
* g_ptr_array_remove_index() shifts subsequent elements
* down one position to fill the gap. */
g_array_sort (indices, sort_descending);
for (ii = 0; ii < indices->len; ii++) {
gint index;
index = g_array_index (indices, gint, ii);
g_ptr_array_remove_index (array, index);
}
g_signal_emit (model, signals[CONTACTS_REMOVED], 0, indices);
g_array_free (indices, FALSE);
update_folder_bar_message (model);
}
GMountSpec *
g_mount_spec_from_dbus (DBusMessageIter *iter)
{
GMountSpec *spec;
DBusMessageIter array_iter, struct_iter, spec_iter;
const char *key;
char *value;
char *mount_prefix;
if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_STRUCT)
return NULL;
dbus_message_iter_recurse (iter, &spec_iter);
mount_prefix = NULL;
if (!_g_dbus_message_iter_get_args (&spec_iter, NULL,
G_DBUS_TYPE_CSTRING, &mount_prefix,
0))
return NULL;
spec = g_mount_spec_new (NULL);
g_free (spec->mount_prefix);
spec->mount_prefix = mount_prefix;
if (dbus_message_iter_get_arg_type (&spec_iter) != DBUS_TYPE_ARRAY ||
dbus_message_iter_get_element_type (&spec_iter) != DBUS_TYPE_STRUCT)
{
g_mount_spec_unref (spec);
return NULL;
}
dbus_message_iter_recurse (&spec_iter, &array_iter);
while (dbus_message_iter_get_arg_type (&array_iter) == DBUS_TYPE_STRUCT)
{
dbus_message_iter_recurse (&array_iter, &struct_iter);
if (_g_dbus_message_iter_get_args (&struct_iter, NULL,
DBUS_TYPE_STRING, &key,
G_DBUS_TYPE_CSTRING, &value,
0))
add_item (spec, key, value);
dbus_message_iter_next (&array_iter);
}
dbus_message_iter_next (iter);
/* Sort on key */
g_array_sort (spec->items, item_compare);
return spec;
}
static void read_ntp_units(void) {
gchar path[PATH_MAX], **unit_dir, **unit_dirs, *contents, **lines, **line;
const gchar *entry;
struct ntp_unit unit;
GDir *dir;
free_ntp_units();
g_assert(!ntp_units);
ntp_units = g_array_new(FALSE, FALSE, sizeof (struct ntp_unit));
/* Read the NTP unit names from files in ntp-unit.d directories */
unit_dirs = g_strsplit(NTP_UNITS_PATHS, ":", -1);
for (unit_dir = unit_dirs; *unit_dir; unit_dir++) {
dir = g_dir_open(*unit_dir, 0, NULL);
if (!dir)
continue;
while ((entry = g_dir_read_name(dir))) {
snprintf(path, sizeof path, "%s/%s", *unit_dir, entry);
if (!g_file_get_contents(path, &contents, NULL, NULL))
continue;
lines = g_strsplit_set(contents, "\r\n", -1);
g_free(contents);
for (line = lines; *line; line++) {
if (!**line || **line == '#')
continue;
/* Ignore units that can't be loaded */
if (!call_systemd_noresult("LoadUnit", g_variant_new("(s)", *line)))
continue;
unit.name = g_strdup(*line);
unit.sort_name = g_strdup(entry);
g_array_append_val(ntp_units, unit);
}
g_strfreev(lines);
}
g_dir_close(dir);
}
g_strfreev(unit_dirs);
/* Sort the units by filename */
g_array_sort(ntp_units, compare_ntp_units);
}
gint
is_permutation(a, b)
{
GArray *array_a, *array_b;
gint i = 0;
array_a = g_array_new(FALSE, FALSE, sizeof (gint));
array_b = g_array_new(FALSE, FALSE, sizeof (gint));
i = a % 10;
g_array_prepend_val(array_a, i);
i = b % 10;
g_array_prepend_val(array_b, i);
while(a > 0)
{
i = a % 10;
g_array_prepend_val(array_a, i);
a /= 10;
}
i = 0;
while(b > 0)
{
i = b % 10;
g_array_prepend_val(array_b, i);
b /= 10;
}
g_array_remove_index_fast(array_a, array_a->len-1);
g_array_remove_index_fast(array_b, array_b->len-1);
g_array_sort(array_a, compare);
g_array_sort(array_b, compare);
print_array(array_a);
print_array(array_b);
return 0;
}
/**
* fuzzy_end_bulk_insert:
* @fuzzy: (in): A #Fuzzy.
*
* Complete a bulk insert and resort the index.
*/
void
fuzzy_end_bulk_insert (Fuzzy *fuzzy)
{
GArray *table;
gint i;
g_return_if_fail(fuzzy);
g_return_if_fail(fuzzy->in_bulk_insert);
fuzzy->in_bulk_insert = FALSE;
for (i = 0; i < fuzzy->char_tables->len; i++) {
table = g_ptr_array_index(fuzzy->char_tables, i);
g_array_sort(table, fuzzy_item_compare);
}
}
GArray *
sblb_block_change_map_get_indexes (SBlbBlockChangeMap *block_change_map)
{
SBlbBlockChangeMapPrivate *priv;
GArray *indexes;
g_return_val_if_fail (SBLB_IS_BLOCK_CHANGE_MAP (block_change_map), NULL);
priv = block_change_map->priv;
indexes = g_array_sized_new (FALSE, FALSE, sizeof (gint), g_hash_table_size (priv->run_changed_blocks));
g_hash_table_foreach (priv->run_changed_blocks, (GHFunc) key_to_array, indexes);
g_array_sort (indexes, (GCompareFunc) compare_ints);
return indexes;
}
/* Takes ownership of passed in data */
GMountSpec *
g_mount_spec_new_from_data (GArray *items,
char *mount_prefix)
{
GMountSpec *spec;
spec = g_new0 (GMountSpec, 1);
spec->ref_count = 1;
spec->items = items;
if (mount_prefix == NULL)
spec->mount_prefix = g_strdup ("/");
else
spec->mount_prefix = g_mount_spec_canonicalize_path (mount_prefix);
g_array_sort (spec->items, item_compare);
return spec;
}
static GArray *
get_kernel_symbols (void)
{
static GArray *kernel_syms;
static gboolean initialized = FALSE;
#if 0
find_kernel_binary();
#endif
if (!initialized)
{
char *kallsyms;
if (g_file_get_contents ("/proc/kallsyms", &kallsyms, NULL, NULL))
{
if (kallsyms)
{
kernel_syms = g_array_new (TRUE, TRUE, sizeof (kernel_symbol_t));
if (parse_kallsyms (kallsyms, kernel_syms))
{
g_array_sort (kernel_syms, compare_syms);
}
else
{
g_array_free (kernel_syms, TRUE);
kernel_syms = NULL;
}
}
g_free (kallsyms);
}
if (!kernel_syms)
{
g_print ("Warning: /proc/kallsyms could not be "
"read. Kernel symbols will not be available\n");
}
initialized = TRUE;
}
return kernel_syms;
}
/**
* news_parser_register_format:
* @parser: (in): A #NewsParser.
* @priority: (in): The discoverer priority.
*
* Registers a format discoverer with the given priority. The first match
* is used when discovering formats. Lowest priorities first.
*
* Returns: None.
*/
void
news_parser_register_format (NewsFormatDiscoverer discoverer,
gint priority)
{
static gsize initialized = FALSE;
Discoverer disc = { 0 };
g_return_if_fail(discoverer != NULL);
if (g_once_init_enter(&initialized)) {
gDiscoverers = g_array_new(FALSE, FALSE, sizeof disc);
g_once_init_leave(&initialized, TRUE);
}
disc.func = discoverer;
disc.priority = priority;
g_array_append_val(gDiscoverers, disc);
g_array_sort(gDiscoverers, discoverer_sort);
}
gboolean
get_task_list (GArray *task_list)
{
GPid pid = 0;
Task task;
//while (/* read all PIDs */)
{
// if (/* pid is valid */)
{
if (get_task_details (pid, &task))
{
g_array_append_val (task_list, task);
}
}
}
g_array_sort (task_list, task_pid_compare_fn);
return TRUE;
}
void
context_info_db_index(ContextInfoDB *self)
{
if (self->data->len > 0)
{
g_array_sort(self->data, _contextual_data_record_cmp);
gsize range_start = 0;
ContextualDataRecord range_start_record =
g_array_index(self->data, ContextualDataRecord, 0);
for (gsize i = 1; i < self->data->len; ++i)
{
ContextualDataRecord current_record =
g_array_index(self->data, ContextualDataRecord, i);
if (_contextual_data_record_cmp
(&range_start_record, ¤t_record))
{
element_range *current_range = g_new(element_range, 1);
current_range->offset = range_start;
current_range->length = i - range_start;
g_hash_table_insert(self->index, range_start_record.selector->str,
current_range);
range_start_record = current_record;
range_start = i;
}
}
{
element_range *last_range = g_new(element_range, 1);
last_range->offset = range_start;
last_range->length = self->data->len - range_start;
g_hash_table_insert(self->index, range_start_record.selector->str,
last_range);
}
self->is_data_indexed = TRUE;
}
}
/* Convert swissprot name suffixes to organisms */
static void suffix2organism(GArray *alignArr, GArray *organismArr)
{
int i = 0;
char *cp = NULL;
for (i = 0; i < (int)alignArr->len; ++i)
{
ALN *alnp = g_array_index(alignArr, ALN*, i);
if (!alnp->markup && (cp = strchr(alnp->name, '_')))
{
char *suffix = (char*)g_malloc(strlen(cp) + 1);
strcpy(suffix, cp + 1);
/* Add organism to table of organisms. This is necessary to make all
sequences of the same organism point to the same place and to make a
non-redundant list of present organisms */
alnp->organism = suffix;
/* Only insert a new organism if it is not already in the array */
int ip = 0;
if (!alnArrayFind(organismArr, alnp, &ip, organism_order))
{
ALN *organism = createEmptyAln();
alncpy(organism, alnp);
organism->organism = alnp->organism;
g_array_append_val(organismArr, organism);
g_array_sort(organismArr, organism_order);
}
else
{
/* Store pointer to existing organism in ALN struct */
ALN *alnTmp = g_array_index(organismArr, ALN*, ip);
g_free(alnp->organism);
alnp->organism = alnTmp->organism;
}
}
}
static struct beans_content_s *
_beans_to_content(const GSList *beans)
{
struct beans_content_s *c = g_malloc0(sizeof(struct beans_content_s));
GPtrArray *contents, *chunks;
chunk_pair_t pair;
contents = g_ptr_array_new();
chunks = g_ptr_array_new();
/*dispatch */
for(; beans; beans = beans->next) {
if (DESCR(beans->data) == &descr_struct_CHUNKS)
g_ptr_array_add(chunks, _bean_dup(beans->data));
else if (DESCR(beans->data) == &descr_struct_CONTENTS)
g_ptr_array_add(contents, _bean_dup(beans->data));
else if (DESCR(beans->data) == &descr_struct_CONTENTS_HEADERS)
c->header = _bean_dup(beans->data);
else if (DESCR(beans->data) == &descr_struct_ALIASES)
c->alias = _bean_dup(beans->data);
else if (DESCR(beans->data) == &descr_struct_PROPERTIES)
c->properties = g_slist_append(c->properties, _bean_dup(beans->data));
}
/* build pairs */
c->pairs = g_array_new(FALSE, FALSE, sizeof(chunk_pair_t));
for(guint i=0; i < contents->len ; i++) {
init_chunk_pair(chunks, &pair, g_ptr_array_index(contents, i));
if(pair.chunk != NULL)
g_array_append_vals(c->pairs, &pair, 1);
}
g_array_sort(c->pairs, (GCompareFunc) compare_pairs_positions);
// what we want to preserve are the pointers to beans created by
// _bean_dup, not the GPtrArray -> we can safely free the arrays.
g_ptr_array_unref(contents);
g_ptr_array_unref(chunks);
return c;
}
static gboolean
set_content_hash_type_from_classes (EmpathyFTHandler *handler,
GPtrArray *classes)
{
GArray *possible_values;
guint value;
gboolean valid;
EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
gboolean support_ft = FALSE;
guint i;
possible_values = g_array_new (TRUE, TRUE, sizeof (guint));
for (i = 0; i < classes->len; i++)
{
GHashTable *fixed;
GStrv allowed;
const gchar *chan_type;
tp_value_array_unpack (g_ptr_array_index (classes, i), 2,
&fixed, &allowed);
chan_type = tp_asv_get_string (fixed, TP_PROP_CHANNEL_CHANNEL_TYPE);
if (tp_strdiff (chan_type, TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER))
continue;
if (tp_asv_get_uint32 (fixed, TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, NULL) !=
TP_HANDLE_TYPE_CONTACT)
continue;
support_ft = TRUE;
value = tp_asv_get_uint32
(fixed, TP_PROP_CHANNEL_TYPE_FILE_TRANSFER_CONTENT_HASH_TYPE,
&valid);
if (valid)
g_array_append_val (possible_values, value);
}
if (!support_ft)
{
g_array_free (possible_values, TRUE);
return FALSE;
}
if (possible_values->len == 0)
{
/* there are no channel classes with hash support, disable it. */
priv->use_hash = FALSE;
priv->content_hash_type = TP_FILE_HASH_TYPE_NONE;
goto out;
}
priv->use_hash = TRUE;
if (possible_values->len == 1)
{
priv->content_hash_type = g_array_index (possible_values, guint, 0);
}
else
{
/* order the array and pick the first non zero, so that MD5
* is the preferred value.
*/
g_array_sort (possible_values, empathy_uint_compare);
if (g_array_index (possible_values, guint, 0) == 0)
priv->content_hash_type = g_array_index (possible_values, guint, 1);
else
priv->content_hash_type = g_array_index (possible_values, guint, 0);
}
out:
g_array_free (possible_values, TRUE);
DEBUG ("Hash enabled %s; setting content hash type as %u",
priv->use_hash ? "True" : "False", priv->content_hash_type);
return TRUE;
}
/**
* g_byte_array_sort:
* @array: a #GByteArray
* @compare_func: comparison function
*
* Sorts a byte array, using @compare_func which should be a
* qsort()-style comparison function (returns less than zero for first
* arg is less than second arg, zero for equal, greater than zero if
* first arg is greater than second arg).
*
* If two array elements compare equal, their order in the sorted array
* is undefined. If you want equal elements to keep their order (i.e.
* you want a stable sort) you can write a comparison function that,
* if two elements would otherwise compare equal, compares them by
* their addresses.
*/
void
g_byte_array_sort (GByteArray *array,
GCompareFunc compare_func)
{
g_array_sort ((GArray *)array, compare_func);
}
static PeasExtension *
peas_plugin_loader_seed_create_extension (PeasPluginLoader *loader,
PeasPluginInfo *info,
GType exten_type,
guint n_parameters,
GParameter *parameters)
{
PeasPluginLoaderSeed *sloader = PEAS_PLUGIN_LOADER_SEED (loader);
SeedInfo *sinfo;
SeedValue extension_ctor, extension;
guint i, j;
SeedValue value;
GValue gvalue = { 0 };
GArray *interfaces;
gchar **property_names;
sinfo = (SeedInfo *) g_hash_table_lookup (sloader->loaded_plugins, info);
/* FIXME: instantiate new object and pass the parameters */
extension_ctor = seed_object_get_property (sinfo->context,
sinfo->extensions,
g_type_name (exten_type));
if (!extension_ctor ||
seed_value_is_undefined (sinfo->context, extension_ctor) ||
seed_value_is_null (sinfo->context, extension_ctor))
return NULL;
if (!seed_value_is_object (sinfo->context, extension_ctor))
{
g_warning ("Extension '%s' in plugin '%s' is not a Seed object",
g_type_name (exten_type), peas_plugin_info_get_module_name (info));
return NULL;
}
/* Instantiate the ctor object into a new specific object. */
extension = JSObjectCallAsConstructor (sinfo->context, extension_ctor, 0, NULL, NULL);
if (extension == NULL)
{
#ifndef PEAS_DISABLE_DEPRECATED_FEATURES
gchar **property_names;
g_warning ("DEPRECATION WARNING: Extension '%s' in plugin '%s' is not a valid "
"constructor function. Support for extension initialization by array "
"copy will be dropped soon.",
g_type_name (exten_type), peas_plugin_info_get_module_name (info));
extension = seed_make_object (sinfo->context, NULL, NULL);
property_names = seed_object_copy_property_names (sinfo->context,
extension_ctor);
for (i = 0; property_names[i] != NULL; i++)
{
SeedValue value;
value = seed_object_get_property (sinfo->context,
extension_ctor,
property_names[i]);
seed_object_set_property (sinfo->context,
extension,
property_names[i],
value);
}
g_strfreev (property_names);
#else
g_warning ("Extension '%s' in plugin '%s' is not a valid constructor",
g_type_name (exten_type), peas_plugin_info_get_module_name (info));
return NULL;
#endif
}
/* Set the properties as well, cannot use
* g_object_set_property() because it may be construct-only
*/
for (i = 0; i < n_parameters; i++)
{
gchar *key;
/* We want to normalize the property names to have a '_' instead of the
* conventional '-', to make them accessible through this.property_name */
key = g_strdup (parameters[i].name);
for (j = 0; key[j] != '\0'; j++)
{
if (key[j] == '-')
key[j] = '_';
}
value = seed_value_from_gvalue (sinfo->context,
¶meters[i].value,
NULL);
seed_object_set_property (sinfo->context,
extension,
key,
value);
g_free (key);
}
/* Set the plugin info as an attribute of the instance */
g_value_init (&gvalue, PEAS_TYPE_PLUGIN_INFO);
g_value_set_boxed (&gvalue, info);
value = seed_value_from_gvalue (sinfo->context, &gvalue, NULL);
seed_object_set_property (sinfo->context, extension, "plugin_info", value);
g_value_unset (&gvalue);
/* Do not add exten_type as it will be added below */
interfaces = g_array_new (TRUE, FALSE, sizeof (GType));
property_names = seed_object_copy_property_names (sinfo->context,
sinfo->extensions);
for (i = 0; property_names[i] != NULL; ++i)
{
gchar *property_name = property_names[i];
SeedValue *prop_extension_ctor;
GType the_type;
prop_extension_ctor = seed_object_get_property (sinfo->context,
sinfo->extensions,
property_name);
if (prop_extension_ctor != extension_ctor)
continue;
if (!seed_value_is_object (sinfo->context, extension_ctor))
{
g_warning ("Extension '%s' in plugin '%s' is not a Seed object",
property_name, peas_plugin_info_get_module_name (info));
continue;
}
the_type = peas_gi_get_type_from_name (property_name);
if (the_type == G_TYPE_INVALID)
{
g_warning ("Could not find GType for '%s', "
"did you forget to import it?", property_name);
}
else
{
g_array_append_val (interfaces, the_type);
}
}
g_array_sort (interfaces, (GCompareFunc) prerequisites_sort);
g_strfreev (property_names);
return peas_extension_seed_new (exten_type,
(GType *) g_array_free (interfaces, FALSE),
sinfo->context, extension);
}
/**
* gcr_importer_create_for_parsed:
* @parsed: a parser with a parsed item to import
*
* Create a set of importers which can import this parsed item.
* The parsed item is represented by the state of the GcrParser at the
* time of calling this method.
*
* Returns: (element-type Gcr.Importer) (transfer full): a list of importers
* which can import the parsed item, which should be freed with
* g_object_unref(), or %NULL if no types of importers can be created
*/
GList *
gcr_importer_create_for_parsed (GcrParsed *parsed)
{
GcrRegistered *registered;
GcrImporterIface *iface;
gpointer instance_class;
GckAttributes *attrs;
gboolean matched;
gulong n_attrs;
GList *results = NULL;
GHashTable *seen;
gulong j;
gsize i;
g_return_val_if_fail (parsed != NULL, NULL);
gcr_importer_register_well_known ();
if (!registered_importers)
return NULL;
if (!registered_sorted) {
g_array_sort (registered_importers, sort_registered_by_n_attrs);
registered_sorted = TRUE;
}
attrs = gcr_parsed_get_attributes (parsed);
if (attrs != NULL)
gck_attributes_ref (attrs);
else
attrs = gck_attributes_new_empty (GCK_INVALID);
seen = g_hash_table_new (g_direct_hash, g_direct_equal);
if (_gcr_debugging) {
gchar *a = gck_attributes_to_string (attrs);
_gcr_debug ("looking for importer for: %s", a);
g_free (a);
}
for (i = 0; i < registered_importers->len; ++i) {
registered = &(g_array_index (registered_importers, GcrRegistered, i));
n_attrs = gck_attributes_count (registered->attrs);
matched = TRUE;
for (j = 0; j < n_attrs; ++j) {
if (!gck_attributes_contains (attrs, gck_attributes_at (registered->attrs, j))) {
matched = FALSE;
break;
}
}
if (_gcr_debugging) {
gchar *a = gck_attributes_to_string (registered->attrs);
_gcr_debug ("importer %s %s: %s", g_type_name (registered->importer_type),
matched ? "matched" : "didn't match", a);
g_free (a);
}
if (matched) {
if (check_if_seen_or_add (seen, GUINT_TO_POINTER (registered->importer_type)))
continue;
instance_class = g_type_class_ref (registered->importer_type);
iface = g_type_interface_peek (instance_class, GCR_TYPE_IMPORTER);
g_return_val_if_fail (iface != NULL, NULL);
g_return_val_if_fail (iface->create_for_parsed, NULL);
results = g_list_concat (results, (iface->create_for_parsed) (parsed));
g_type_class_unref (instance_class);
}
}
g_hash_table_unref (seen);
gck_attributes_unref (attrs);
return results;
}