/* Put @ace into @sd. If no ACE corresponding to @ace currently exists, * it will be added in the right place. If it does already exist, its * flags (in particular INHERITED_ACE) will be preserved and only the * mask will be changed. */ static void set_ace (E2kSecurityDescriptor *sd, E2k_ACE *ace) { E2k_ACE *aces = (E2k_ACE *)sd->priv->aces->data; int low, mid = 0, high, cmp = -1; low = 0; high = sd->priv->aces->len - 1; while (low <= high) { mid = (low + high) / 2; cmp = ace_compar (ace, &aces[mid], sd); if (cmp == 0) { if (ace->Mask) aces[mid].Mask = ace->Mask; else g_array_remove_index (sd->priv->aces, mid); return; } else if (cmp < 0) high = mid - 1; else low = mid + 1; } if (ace->Mask) g_array_insert_vals (sd->priv->aces, cmp < 0 ? mid : mid + 1, ace, 1); }
void GLibArrayImpl::Insert(LArrayInst * inst, int index, void * value) { //TODO- Should we use this slightly more sane implementation? /* GPtrArray *array = (GPtrArray *)this->m_impl; if ((index + 1) == array->len) { // add to the end of the array g_ptr_array_add (array, value); return; } if (index >= array->len) { // extend and add PAST the end of the array g_ptr_array_set_size (array, index + 1); array->pdata[index] = value; return; } // normal case - shift all elements starting at @index 1 position to the right g_ptr_array_set_size (array, array->len + 1); for (int i = array->len - 2; i >= index; i--) array->pdata[i + 1] = array->pdata[i]; array->pdata[index] = value; */ g_return_if_fail(inst != NULL); g_array_insert_vals(dynamic_cast<GLibArrayInst *>(inst)->m_array, index, value, 1); }
/** * This function adds images into image list. It is kinda special as it does not * use yank buffer as an input. It should be used at special occasions only, * like for loading image_group from image_pile. * * \param group image list into which images will be added * \param index position to which images will be added * \param data array containing list of image pointers * \param size number of pointers in array * \return OK on success */ extern RCode group_insert(ImageGroup* group, gint index, Image* data[], guint size) { unsigned int source_index = 0; unsigned int target_index = 0; ImageGroupRecord* buffer = NULL; ASSERT(NULL != group); ASSERT(NULL != group->list); /* check position into which images are being inserted * we do not fail if index = list length ( which is one record after the * last one to be able to add at the end of array */ if ( index < 0 || group->list->len < index ) { ERROR_SET(ERROR.OUT_OF_RANGE); ERROR_NOTE("Index %d out of range [0, %d]", index, group->list->len); return FAIL; } // allocate internal buffer for insertions TRACE_MESSAGE(IGRP, TL_DEBUG, "Allocate insert buffer (size=%d)", size); buffer = (ImageGroupRecord*) g_try_malloc0(size*sizeof(ImageGroupRecord)); if ( NULL == buffer ) { ERROR_SET(ERROR.MEMORY_FAILURE); return FAIL; } // prepare data in buffer for insertion TRACE_MESSAGE(IGRP, TL_DEBUG, "Preparing values into insert buffer (count=%d)",size); for ( source_index = 0, target_index = 0; source_index < size; source_index++ ) { TagList *tags = image_get_groups(data[source_index]); if ( FALSE == taglist_contains(tags, group->tag) ) { buffer[target_index].image = data[source_index]; buffer[target_index].select = FALSE; image_ref(buffer[target_index].image); taglist_insert(tags, group->tag); target_index++; } } // compute position into which to insert and insert the data TRACE_MESSAGE(IGRP, TL_INFO, "Inserting records into group (name='%s', index=%d, count=%d, filtered=%d)", group->name, index, target_index, (size - target_index) ); group->list = g_array_insert_vals(group->list, index, (gpointer)buffer, target_index); // deallocate insert buffer g_free( (gpointer)buffer ); return OK; }
int main(void) { GArray *a = g_array_new(FALSE, FALSE, sizeof(int)); int x[2] = { 1, 5 }; g_array_append_vals(a, &x, 2); print_array(a); printf("Insert '2'\n"); int b = 2; g_array_insert_val(a, 1, b); print_array(a); printf("Inserting multiple values\n"); int y[2] = { 3, 4 }; g_array_insert_vals(a, 2, y, 2); print_array(a); g_array_free(a, FALSE); }
static void on_recent_menu_item_activate(G_GNUC_UNUSED GtkMenuItem *menuitem, const gchar *name) { RecentProgram *recent = (RecentProgram *) array_find(recent_programs, name, TRUE); if (recent && utils_filenamecmp(recent->name, *program_executable ? program_executable : program_load_script)) { char *configfile = recent_file_name(recent->id); GKeyFile *config = g_key_file_new(); GError *gerror = NULL; gchar *message; if (g_key_file_load_from_file(config, configfile, G_KEY_FILE_NONE, &gerror)) { save_program_settings(); recent = (RecentProgram *) array_find(recent_programs, name, TRUE); stash_foreach((GFunc) stash_group_load_from_key_file, config); if ((unsigned) option_inspect_expand > EXPAND_MAX) option_inspect_expand = 100; breaks_load(config); watches_load(config); inspects_load(config); parse_load(config); message = g_strdup_printf(_("Loaded debug settings for %s."), recent->name); g_array_insert_vals(recent_programs, 0, ++recent, 1); array_remove(recent_programs, recent); recent_menu_create(); program_configure(); } else { message = g_strdup_printf(_("Could not load debug settings file %s: %s."), configfile, gerror->message); g_error_free(gerror); } if (menuitem) ui_set_statusbar(TRUE, "%s", message); else msgwin_status_add("%s", message); g_free(message); g_key_file_free(config); g_free(configfile); } }
static void save_program_settings(void) { const gchar *program_name = *program_executable ? program_executable : program_load_script; if (*program_name) { RecentProgram *recent = (RecentProgram *) array_find(recent_programs, program_name, TRUE); GKeyFile *config = g_key_file_new(); char *configfile; if (!recent) { recent = (RecentProgram *) array_append(recent_programs); recent->name = g_strdup(program_name); for (recent->id = 1; recent->id < RECENT_COUNT; recent->id++) if ((recent_bitmap & (1 << recent->id)) == 0) break; recent_bitmap |= 1 << recent->id; } configfile = recent_file_name(recent->id); stash_foreach((GFunc) stash_group_save_to_key_file, config); breaks_save(config); watches_save(config); inspects_save(config); parse_save(config); utils_key_file_write_to_file(config, configfile); g_free(configfile); g_key_file_free(config); g_array_insert_vals(recent_programs, 0, ++recent, 1); array_remove(recent_programs, recent); recent_menu_create(); if (recent_programs->len > RECENT_COUNT) { recent_bitmap &= ~(1 << recent->id); array_remove(recent_programs, recent); } } }
/** * Enumerate scan options supported by this driver. * * Before calling sr_driver_scan_options_list(), the user must have previously * initialized the driver by calling sr_driver_init(). * * @param driver The driver to enumerate options for. This must be a pointer * to one of the entries returned by sr_driver_list(). Must not * be NULL. * * @return A GArray * of uint32_t entries, or NULL on invalid arguments. Each * entry is a configuration key that is supported as a scan option. * The array must be freed by the caller using g_array_free(). * * @since 0.4.0 */ SR_API GArray *sr_driver_scan_options_list(const struct sr_dev_driver *driver) { GVariant *gvar; const uint32_t *opts; gsize num_opts; GArray *result; if (sr_config_list(driver, NULL, NULL, SR_CONF_SCAN_OPTIONS, &gvar) != SR_OK) return NULL; opts = g_variant_get_fixed_array(gvar, &num_opts, sizeof(uint32_t)); result = g_array_sized_new(FALSE, FALSE, sizeof(uint32_t), num_opts); g_array_insert_vals(result, 0, opts, num_opts); g_variant_unref(gvar); return result; }
void gv_areas_insert_nodes(GvAreas *areas, gint area_id, gint ring_id, gint node_id, gint num_nodes, GvVertex *vertex) { GvArea *area; GArray *ring; GvShapeChangeInfo change_info = {GV_CHANGE_REPLACE, 1, NULL}; change_info.shape_id = &area_id; g_return_if_fail(area_id >= 0 && area_id < areas->areas->len); area = gv_areas_get_area(areas, area_id); g_return_if_fail(ring_id >= 0 && ring_id < area->rings->len); ring = gv_areas_get_ring(area, ring_id); g_return_if_fail(node_id >= 0 && node_id < ring->len); gv_data_changing(GV_DATA(areas), &change_info); g_array_insert_vals(ring, node_id, vertex, num_nodes); gv_data_changed(GV_DATA(areas), &change_info); }
static void ft_operation_provide_or_accept_file_cb (TpChannel *proxy, const GValue *address, const GError *error, gpointer user_data, GObject *weak_object) { EmpathyTpFile *self = EMPATHY_TP_FILE (weak_object); GError *myerr = NULL; g_cancellable_set_error_if_cancelled (self->priv->cancellable, &myerr); if (error != NULL) { if (myerr != NULL) { /* if we were both cancelled and failed when calling the method, * report the method error. */ g_clear_error (&myerr); } myerr = g_error_copy (error); } if (myerr != NULL) { DEBUG ("Error: %s", myerr->message); ft_operation_close_with_error (self, myerr); g_clear_error (&myerr); return; } if (G_VALUE_TYPE (address) == DBUS_TYPE_G_UCHAR_ARRAY) { self->priv->socket_address = g_value_dup_boxed (address); } else if (G_VALUE_TYPE (address) == G_TYPE_STRING) { /* Old bugged version of telepathy-salut used to store the address * as a 's' instead of an 'ay' */ const gchar *path; path = g_value_get_string (address); self->priv->socket_address = g_array_sized_new (TRUE, FALSE, sizeof (gchar), strlen (path)); g_array_insert_vals (self->priv->socket_address, 0, path, strlen (path)); } else if (G_VALUE_TYPE (address) == TP_STRUCT_TYPE_SOCKET_ADDRESS_IPV4) { GValueArray *val_array; GValue *v; const char *addr; val_array = g_value_get_boxed (address); /* IPV4 address */ v = g_value_array_get_nth (val_array, 0); addr = g_value_get_string (v); self->priv->socket_address = g_array_sized_new (TRUE, FALSE, sizeof (gchar), strlen (addr)); g_array_insert_vals (self->priv->socket_address, 0, addr, strlen (addr)); /* port number */ v = g_value_array_get_nth (val_array, 1); self->priv->port = g_value_get_uint (v); } DEBUG ("Got socket address: %s, port (not zero if IPV4): %d", self->priv->socket_address->data, self->priv->port); /* if the channel is already open, start the transfer now, otherwise, * wait for the state change signal. */ if (self->priv->state == TP_FILE_TRANSFER_STATE_OPEN) tp_file_start_transfer (self); }
static void gst_file_index_add_association (GstIndex * index, GstIndexEntry * entry) { GstFileIndex *fileindex = GST_FILE_INDEX (index); GstFileIndexId *id_index; gint mx; GstIndexAssociation sample; gboolean exact; id_index = g_hash_table_lookup (fileindex->id_index, &entry->id); if (!id_index) return; if (!id_index->nformats) { gint fx; id_index->nformats = GST_INDEX_NASSOCS (entry); GST_LOG_OBJECT (fileindex, "creating %d formats for %d", id_index->nformats, entry->id); id_index->format = g_new (GstFormat, id_index->nformats); for (fx = 0; fx < id_index->nformats; fx++) id_index->format[fx] = GST_INDEX_ASSOC_FORMAT (entry, fx); _fc_alloc_array (id_index); } else { /* only sanity checking */ if (id_index->nformats != GST_INDEX_NASSOCS (entry)) GST_WARNING_OBJECT (fileindex, "arity change %d -> %d", id_index->nformats, GST_INDEX_NASSOCS (entry)); else { gint fx; for (fx = 0; fx < id_index->nformats; fx++) if (id_index->format[fx] != GST_INDEX_ASSOC_FORMAT (entry, fx)) GST_WARNING_OBJECT (fileindex, "format[%d] changed %d -> %d", fx, id_index->format[fx], GST_INDEX_ASSOC_FORMAT (entry, fx)); } } /* this is a hack, we should use a private structure instead */ sample.format = 0; sample.value = GST_INDEX_ASSOC_VALUE (entry, 0); exact = _fc_bsearch (id_index->array, ARRAY_ROW_SIZE (id_index), &mx, file_index_compare, &sample, id_index); if (exact) { /* maybe overwrite instead? */ GST_DEBUG_OBJECT (index, "Ignoring duplicate index association at %" G_GINT64_FORMAT, GST_INDEX_ASSOC_VALUE (entry, 0)); return; } { gchar *row_data = (gchar *) g_malloc (ARRAY_ROW_SIZE (id_index)); gint fx; gint32 flags_host = GST_INDEX_ASSOC_FLAGS (entry); ARRAY_ROW_FLAGS (row_data) = GINT32_TO_BE (flags_host); for (fx = 0; fx < id_index->nformats; fx++) { gint64 val_host = GST_INDEX_ASSOC_VALUE (entry, fx); ARRAY_ROW_VALUE (row_data, fx) = GINT64_TO_BE (val_host); } g_array_insert_vals (id_index->array, mx, row_data, 1); g_free (row_data); } }