static void _introspect_append_interface(Eina_Strbuf *buf, Eldbus_Service_Interface *iface) { const Eldbus_Method *method; Property *prop; Eina_Iterator *iterator; unsigned short i; eina_strbuf_append_printf(buf, "<interface name=\"%s\">", iface->name); iterator = eina_hash_iterator_data_new(iface->methods); EINA_ITERATOR_FOREACH(iterator, method) _introspect_append_method(buf, method); eina_iterator_free(iterator); for (i = 0; i < eina_array_count(iface->sign_of_signals); i++) _introspect_append_signal(buf, &iface->signals[i]); iterator = eina_hash_iterator_data_new(iface->properties); EINA_ITERATOR_FOREACH(iterator, prop) _instrospect_append_property(buf, prop->property, iface); eina_iterator_free(iterator); eina_strbuf_append(buf, "</interface>"); }
EAPI void efreet_hash_free(Eina_Hash *hash, Eina_Free_Cb free_cb) { Eina_Iterator *it; void *data; it = eina_hash_iterator_data_new(hash); EINA_ITERATOR_FOREACH(it, data) (*free_cb)(data); eina_iterator_free(it); eina_hash_free(hash); }
static void print_live_connection(Eldbus_Connection *conn) { if (!conn->names) ERR("conn=%p has no alive objects", conn); else { Eina_Iterator *iter = eina_hash_iterator_data_new(conn->names); Eldbus_Connection_Name *name; EINA_ITERATOR_FOREACH(iter, name) { Eldbus_Object *obj; Eina_Iterator *inner_itr; if (!name->objects) continue; inner_itr = eina_hash_iterator_data_new(name->objects); EINA_ITERATOR_FOREACH(inner_itr, obj) ERR("conn=%p alive object=%p %s of bus=%s", conn, obj, obj->name, name->name); eina_iterator_free(inner_itr); } eina_iterator_free(iter); }
void clean_inexistant_files(Eina_Hash *map_histo) { struct stat st; Eina_Iterator *iter = eina_hash_iterator_data_new(map_histo); void **data = malloc(sizeof(void**)); list_t *to_delete = NULL; while(eina_iterator_next(iter, data)) { histogram_t *current = *data; if(stat(current->file, &st) != 0) { to_delete = list_append(to_delete, current->file); } } eina_iterator_free(iter); list_t *current = to_delete; while(current) { printf("Deleting cache for %s\n", current->value); eina_hash_del_by_key(map_histo, current->value); current = current->next; } }
void _elm_module_shutdown(void) { Eina_Iterator *it; Elm_Module *m; if (modules) { Eina_List *tl = NULL; it = eina_hash_iterator_data_new(modules); EINA_ITERATOR_FOREACH(it, m) tl = eina_list_append(tl, m); eina_iterator_free(it); EINA_LIST_FREE(tl, m) _elm_module_del(m); ELM_SAFE_FREE(modules, eina_hash_free); } ELM_SAFE_FREE(modules_as, eina_hash_free); }
static int data_write_header(Eet_File *ef) { int bytes = 0; if (edje_file) { if (edje_file->collection) { Edje_Part_Collection_Directory_Entry *ce; /* copy aliases into collection directory */ EINA_LIST_FREE(aliases, ce) { Edje_Part_Collection_Directory_Entry *sce; Eina_Iterator *it; if (!ce->entry) error_and_abort(ef, "Collection %i: name missing.\n", ce->id); it = eina_hash_iterator_data_new(edje_file->collection); EINA_ITERATOR_FOREACH(it, sce) if (ce->id == sce->id) { memcpy(&ce->count, &sce->count, sizeof (ce->count)); break; } if (!sce) error_and_abort(ef, "Collection %s (%i) can't find an correct alias.\n", ce->entry, ce->id); eina_iterator_free(it); eina_hash_direct_add(edje_file->collection, ce->entry, ce); } }
int main(int argc, const char *argv[]) { Eina_Hash *phone_book = NULL; int i; int64_t entry_id = 4; char *phone = NULL; Eina_Bool r; Eina_Iterator *it; void *data; eina_init(); phone_book = eina_hash_int64_new(_phone_entry_free_cb); // Add initial entries to our hash for (i = 0; _start_entries[i].id != -1; i++) { eina_hash_add(phone_book, &_start_entries[i].id, strdup(_start_entries[i].number)); } // Look for a specific entry and get its phone number phone = eina_hash_find(phone_book, &entry_id); if (phone) { printf("Printing entry.\n"); printf("Id: %lld\n", entry_id); printf("Number: %s\n\n", phone); } // Delete this entry r = eina_hash_del(phone_book, &entry_id, NULL); printf("Hash entry successfully deleted? %d\n\n", r); // Modify the pointer data of an entry and free the old one int64_t id3 = 3; phone = eina_hash_modify(phone_book, &id3, strdup("+23 45 111-11111")); free(phone); // Modify or add an entry to the hash with eina_hash_set // Let's first add a new entry int64_t id5 = 5; eina_error_set(0); phone = eina_hash_set(phone_book, &id5, strdup("+55 01 234-56789")); if (!phone) { Eina_Error err = eina_error_get(); if (!err) { printf("No previous phone found for id5. "); printf("Creating new entry.\n"); } else printf("Error when setting phone for Raul Seixas\n"); } else { printf("Old phone for id5 was %s\n", phone); free(phone); } printf("\n"); // Now change the phone number eina_error_set(0); phone = eina_hash_set(phone_book, &id5, strdup("+55 02 222-22222")); if (phone) { printf("Changing phone for id5 to +55 02 222-22222. "); printf("Old phone was %s\n", phone); free(phone); } else { Eina_Error err = eina_error_get(); if (err) printf("Error when changing phone for id5\n"); else { printf("No previous phone found for id5. "); printf("Creating new entry.\n"); } } // There are many ways to iterate over our Phone book. // First, iterate showing the names and associated numbers. printf("List of phones:\n"); eina_hash_foreach(phone_book, _phone_book_foreach_cb, NULL); printf("\n"); // Now iterate using an iterator printf("List of phones:\n"); it = eina_hash_iterator_tuple_new(phone_book); while (eina_iterator_next(it, &data)) { Eina_Hash_Tuple *t = data; const int64_t *id = t->key; const char *number = t->data; printf("%lld: %s\n", *id, number); } eina_iterator_free(it); // Always free the iterator after its use printf("\n"); // Just iterate over the keys (names) printf("List of ids in the phone book:\n"); it = eina_hash_iterator_key_new(phone_book); while (eina_iterator_next(it, &data)) { const int64_t *id = data; printf("%lld\n", *id); } eina_iterator_free(it); printf("\n"); // Just iterate over the data (numbers) printf("List of numbers in the phone book:\n"); it = eina_hash_iterator_data_new(phone_book); while (eina_iterator_next(it, &data)) { const char *number = data; printf("%s\n", number); } eina_iterator_free(it); printf("\n"); // Check how many items are in the phone book printf("There are %d items in the hash.\n\n", eina_hash_population(phone_book)); // Change the name (key) on an entry int64_t id6 = 6; eina_hash_move(phone_book, &id5, &id6); printf("List of phones after change:\n"); eina_hash_foreach(phone_book, _phone_book_foreach_cb, NULL); printf("\n"); // Empty the phone book, but don't destroy it eina_hash_free_buckets(phone_book); printf("There are %d items in the hash.\n\n", eina_hash_population(phone_book)); // Phone book could still be used, but we are freeing it since we are // done for now eina_hash_free(phone_book); eina_shutdown(); }
int main(int argc, char **argv) { Edje_Part_Collection_Directory_Entry *ce; Old_Edje_File *oef; Edje_File *nef; Eina_Iterator *it; Eet_File *ef; setlocale(LC_NUMERIC, "C"); ecore_app_no_system_modules(); if (!eina_init()) return -1; _edje_cc_log_dom = eina_log_domain_register ("edje_convert", EDJE_CC_DEFAULT_LOG_COLOR); if (_edje_cc_log_dom < 0) { EINA_LOG_ERR("Enable to create a log domain."); exit(-1); } eet_init(); progname = argv[0]; if (argc > 2 || argc < 2 || !strcmp(argv[1], "-h")) { main_help(); return 0; } _edje_edd_old_init(); _edje_edd_init(); ef = eet_open(argv[1], EET_FILE_MODE_READ_WRITE); if (!ef) { EINA_LOG_ERR("Unable to open `%s'.", argv[1]); return -1; } oef = eet_data_read(ef, _edje_edd_old_edje_file, "edje_file"); if (!oef) { EINA_LOG_ERR("Unable to get edje_file section from old file format, are you sure it's an old file ?"); return -1; } nef = _edje_file_convert(ef, oef); _edje_file_set(nef); /* convert old structure to new one */ it = eina_hash_iterator_data_new(nef->collection); EINA_ITERATOR_FOREACH(it, ce) { Old_Edje_Part_Collection *opc; Edje_Part_Collection *npc; char buf[1024]; int bytes = 0; snprintf(buf, sizeof (buf), "collections/%i", ce->id); opc = eet_data_read(ef, _edje_edd_old_edje_part_collection, buf); if (!opc) { EINA_LOG_ERR("Unable to find collection `%s'[%i] in `%s'.", ce->entry, ce->id, argv[1]); return -1; } npc = _edje_collection_convert(ef, ce, opc); snprintf(buf, sizeof (buf), "edje/collections/%i", ce->id); bytes = eet_data_write(ef, _edje_edd_edje_part_collection, buf, npc, 1); if (bytes <= 0) { EINA_LOG_ERR("Unable to save `%s' in section `%s' of `%s'.", ce->entry, buf, argv[1]); return -1; } }
{ const Eolian_Function *ctor_func = eolian_constructor_function_get(ctor); if (!ctor_func) { fprintf(stderr, "eolian: unable to find function '%s'\n", eolian_constructor_full_name_get(ctor)); eina_iterator_free(itr); goto error; } else database_function_constructor_add((Eolian_Function*)ctor_func, ctor->klass); } eina_iterator_free(itr); /* parse deferred eos (doc dependencies) */ itr = eina_hash_iterator_data_new(_defereos); EINA_ITERATOR_FOREACH(itr, dep) { if (!eina_hash_find(_parsingeos, dep) && !eolian_file_parse(dep)) { eina_iterator_free(itr); eina_hash_free_buckets(_defereos); goto error; } } eina_iterator_free(itr); eina_hash_free_buckets(_defereos); done: eina_hash_set(_parsedeos, filename, (void *)EINA_TRUE); eina_hash_set(_parsingeos, filename, (void *)EINA_FALSE);
static Ewk_JS_Object* ewk_js_npobject_to_object(NPObject* npObject) { NPIdentifier* values; uint32_t np_props_count; Ewk_JS_Class* cls; Ewk_JS_Object* object; Eina_Iterator* it; Ewk_JS_Property* prop; JavaScriptObject* jso; if (EINA_MAGIC_CHECK(reinterpret_cast<Ewk_JS_Object*>(npObject), EWK_JS_OBJECT_MAGIC)) return reinterpret_cast<Ewk_JS_Object*>(npObject); if (!_NPN_Enumerate(0, npObject, &values, &np_props_count)) return 0; cls = static_cast<Ewk_JS_Class*>(malloc(sizeof(Ewk_JS_Class))); if (!cls) { ERR("Could not allocate memory for ewk_js_class"); return 0; } cls->meta = 0; Ewk_JS_Default def = { ewk_js_npobject_property_set, ewk_js_npobject_property_get, ewk_js_npobject_property_del }; cls->default_prop = def; cls->methods = eina_hash_pointer_new(0); cls->properties = eina_hash_pointer_new(reinterpret_cast<Eina_Free_Cb>(ewk_js_property_free)); for (uint32_t i = 0; i < np_props_count; i++) { if (_NPN_HasProperty(0, npObject, values[i])) { NPVariant var; Ewk_JS_Property* prop = static_cast<Ewk_JS_Property*>(calloc(sizeof(Ewk_JS_Property), 1)); if (!prop) { ERR("Could not allocate memory for ewk_js_property"); goto error; } _NPN_GetProperty(0, npObject, values[i], &var); ewk_js_npvariant_to_variant(&(prop->value), &var); prop->name = _NPN_UTF8FromIdentifier(values[i]); eina_hash_add(cls->properties, values[i], prop); } } // Can't use ewk_js_object_new(cls) because it expects cls->meta to exist. object = static_cast<Ewk_JS_Object*>(malloc(sizeof(Ewk_JS_Object))); if (!object) { ERR("Could not allocate memory for ewk_js_object"); goto error; } free(values); EINA_MAGIC_SET(object, EWK_JS_OBJECT_MAGIC); object->name = 0; object->cls = cls; object->view = 0; jso = reinterpret_cast<JavaScriptObject*>(npObject); if (!strcmp("Array", jso->imp->methodTable()->className(jso->imp).ascii().data())) object->type = EWK_JS_OBJECT_ARRAY; else if (!strcmp("Function", jso->imp->methodTable()->className(jso->imp).ascii().data())) object->type = EWK_JS_OBJECT_FUNCTION; else object->type = EWK_JS_OBJECT_OBJECT; if (eina_hash_population(cls->properties) < 25) object->properties = eina_hash_string_small_new(0); else object->properties = eina_hash_string_superfast_new(0); it = eina_hash_iterator_data_new(cls->properties); EINA_ITERATOR_FOREACH(it, prop) { const char* key = prop->name; Ewk_JS_Variant* value = &prop->value; eina_hash_add(object->properties, key, value); } eina_iterator_free(it); object->base = *reinterpret_cast<JavaScriptObject*>(npObject); return object; error: ewk_js_class_free(cls); free(values); return 0; }
int main(int argc, char **argv) { Eina_File *f; Eina_Iterator *it; Eina_File_Line *l; GeoIP *geo; Community_Country *country; unsigned long long correct = 0; unsigned long long lines = 0; int i; if (argc != 2) return -1; eina_init(); community = eina_hash_stringshared_new(NULL); days = eina_hash_new(_community_day_key_length, _community_day_key_cmp, _community_day_key_hash, NULL, 5); countries = eina_hash_string_superfast_new(NULL); geo = GeoIP_new(GEOIP_STANDARD); memset(months, 0, sizeof (months)); /* Read real name country to tld file */ f = eina_file_open("country_tld.csv", EINA_FALSE); if (!f) return -1; it = eina_file_map_lines(f); EINA_ITERATOR_FOREACH(it, l) { const char *s; int i; s = memchr(l->start, ',', l->length); if (!s) continue ; country = calloc(1, sizeof (Community_Country)); country->tld = _eina_stringshare_up(l->start, s - l->start); country->country = _eina_stringshare_up(s + 1, l->length - (s - l->start + 1)); country->access = eina_hash_stringshared_new(NULL); eina_hash_direct_add(countries, country->tld, country); } eina_iterator_free(it); eina_file_close(f); /* Read population information */ f = eina_file_open("country_population.csv", EINA_FALSE); if (!f) return -1; it = eina_file_map_lines(f); EINA_ITERATOR_FOREACH(it, l) { Eina_Iterator *it2; const char *s; const char *country_name; const char *r; for (s = l->start; s < l->end; s++) { const char *convert = VIGRID_NUMBER_SEARCH; r = strchr(convert, *s); if (r) break ; } if (!r) continue; country = NULL; country_name = _eina_stringshare_up(l->start, s - l->start - 1); it2 = eina_hash_iterator_data_new(countries); EINA_ITERATOR_FOREACH(it2, country) { if (country->country == country_name) { unsigned long long offset = s - l->start; country->population = _eina_file_int_get(l, &offset); break; } } eina_iterator_free(it2); }
EAPI Eina_Bool edje_file_group_exists(const char *file, const char *glob) { Edje_File *edf; int error_ret = 0; Eina_Bool succeed = EINA_FALSE; Eina_Bool is_glob = EINA_FALSE; const char *p; if ((!file) || (!*file) || (!glob)) return EINA_FALSE; edf = _edje_cache_file_coll_open(file, NULL, &error_ret, NULL); if (!edf) return EINA_FALSE; for (p = glob; *p; p++) { if ((*p == '*') || (*p == '?') || (*p == '[')) { is_glob = EINA_TRUE; break; } } if (is_glob) { if (!edf->collection_patterns) { Edje_Part_Collection_Directory_Entry *ce; Eina_Iterator *i; Eina_List *l = NULL; i = eina_hash_iterator_data_new(edf->collection); EINA_ITERATOR_FOREACH(i, ce) l = eina_list_append(l, ce); eina_iterator_free(i); edf->collection_patterns = edje_match_collection_dir_init(l); eina_list_free(l); } succeed = edje_match_collection_dir_exec(edf->collection_patterns, glob); if (edf->collection_patterns) { edje_match_patterns_free(edf->collection_patterns); edf->collection_patterns = NULL; } } else { if (eina_hash_find(edf->collection, glob)) succeed = EINA_TRUE; } _edje_cache_file_unref(edf); INF("edje_file_group_exists: '%s', '%s': %i\n", file, glob, succeed); return succeed; }
static int _evas_gl_common_shader_binary_save(Evas_GL_Shared *shared) { char bin_dir_path[PATH_MAX]; char bin_file_path[PATH_MAX]; char tmp_file_name[PATH_MAX]; int tmpfd = -1, copy; Eina_Tmpstr *tmp_file_path = NULL; Eet_File *ef = NULL; Evas_GL_Program *p; Eina_Iterator *it; char pname[32]; /* use eet */ if (!eet_init()) return 0; if (!evas_gl_common_file_cache_dir_check(bin_dir_path, sizeof(bin_dir_path))) { if (!evas_gl_common_file_cache_mkpath(bin_dir_path)) return 0; /* we can't make directory */ } copy = evas_gl_common_file_cache_file_check(bin_dir_path, SHADER_EET_CACHENAME, bin_file_path, sizeof(bin_dir_path)); /* use mkstemp for writing */ snprintf(tmp_file_name, sizeof(tmp_file_name), "%s.XXXXXX.cache", bin_file_path); tmpfd = eina_file_mkstemp(tmp_file_name, &tmp_file_path); if (tmpfd < 0) goto error; /* copy old file */ if (copy) { ef = eet_open(tmp_file_path, EET_FILE_MODE_READ); if (!ef) goto save; if (!_evas_gl_common_shader_binary_checksum_check(shared, ef)) copy = EINA_FALSE; eet_close(ef); if (copy) eina_file_copy(bin_file_path, tmp_file_path, EINA_FILE_COPY_DATA, NULL, NULL); } save: ef = eet_open(tmp_file_path, copy ? EET_FILE_MODE_READ_WRITE : EET_FILE_MODE_WRITE); if (!ef) goto error; if (!_evas_gl_common_shader_binary_checksum_write(shared, ef)) goto error; it = eina_hash_iterator_data_new(shared->shaders_hash); EINA_ITERATOR_FOREACH(it, p) { if (!p->bin_saved) { int len = 0; sprintf(pname, SHADER_PROG_NAME_FMT, p->flags); eet_read_direct(ef, pname, &len); if (len > 0) p->bin_saved = 1; // assume bin data is correct else _evas_gl_common_shader_program_binary_save(p, ef); } } eina_iterator_free(it); if (shared->shaders_cache) { eet_close(shared->shaders_cache); shared->shaders_cache = NULL; eet_shutdown(); } if (eet_close(ef) != EET_ERROR_NONE) goto destroyed; if (rename(tmp_file_path, bin_file_path) < 0) goto destroyed; eina_tmpstr_del(tmp_file_path); close(tmpfd); eet_shutdown(); shared->needs_shaders_flush = 0; return 1; destroyed: ef = NULL; error: if (tmpfd >= 0) close(tmpfd); if (ef) eet_close(ef); if (evas_gl_common_file_cache_file_exists(tmp_file_path)) unlink(tmp_file_path); eina_tmpstr_del(tmp_file_path); eet_shutdown(); return 0; }