static void replace_word(GtkWidget *menuitem, GtkSpell *spell) { char *oldword; const char *newword; GtkTextIter start, end; GtkTextBuffer *buffer; buffer = gtk_text_view_get_buffer(spell->view); get_cur_word_extents(buffer, &start, &end); oldword = gtk_text_buffer_get_text(buffer, &start, &end, FALSE); newword = gtk_label_get_text(GTK_LABEL(GTK_BIN(menuitem)->child)); if (debug) { g_print("old word: '%s'\n", oldword); print_iter("s", &start); print_iter("e", &end); g_print("\nnew word: '%s'\n", newword); } gtk_text_buffer_delete(buffer, &start, &end); gtk_text_buffer_insert(buffer, &start, newword, -1); aspell_speller_store_replacement(spell->speller, oldword, strlen(oldword), newword, strlen(newword)); g_free(oldword); }
static void iterate (ClutterModel *model) { ClutterModelIter *iter; iter = clutter_model_get_first_iter (model); while (!clutter_model_iter_is_last (iter)) { print_iter (iter, "Forward Iteration"); iter = clutter_model_iter_next (iter); } g_object_unref (iter); iter = clutter_model_get_last_iter (model); do { print_iter (iter, "Reverse Iteration"); iter = clutter_model_iter_prev (iter); } while (!clutter_model_iter_is_first (iter)); print_iter (iter, "Reverse Iteration"); g_object_unref (iter); filter_model (model); }
static void check_range(GtkSpell *spell, GtkTextBuffer *buffer, GtkTextIter start, GtkTextIter end) { /* we need to "split" on word boundaries. * luckily, pango knows what "words" are * so we don't have to figure it out. */ GtkTextIter wstart, wend; if (debug) { g_print("check_range: "); print_iter("s", &start); print_iter("e", &end); g_print(" -> "); } if (gtk_text_iter_inside_word(&end)) gtk_text_iter_forward_word_end(&end); if (!gtk_text_iter_starts_word(&start)) { if (gtk_text_iter_inside_word(&start) || gtk_text_iter_ends_word(&start)) { gtk_text_iter_backward_word_start(&start); } else { /* if we're neither at the beginning nor inside a word, * me must be in some spaces. * skip forward to the beginning of the next word. */ //gtk_text_buffer_remove_tag(buffer, tag_highlight, &start, &end); if (gtk_text_iter_forward_word_end(&start)) gtk_text_iter_backward_word_start(&start); } } gtk_text_buffer_remove_tag(buffer, spell->tag_highlight, &start, &end); if (debug) {print_iter("s", &start); print_iter("e", &end); g_print("\n");} wstart = start; while (gtk_text_iter_compare(&wstart, &end) < 0) { /* move wend to the end of the current word. */ wend = wstart; gtk_text_iter_forward_word_end(&wend); check_word(spell, buffer, &wstart, &wend); /* now move wend to the beginning of the next word, */ gtk_text_iter_forward_word_end(&wend); gtk_text_iter_backward_word_start(&wend); /* make sure we've actually advanced * (we don't advance in some corner cases), */ if (gtk_text_iter_equal(&wstart, &wend)) break; /* we're done in these cases.. */ /* and then pick this as the new next word beginning. */ wstart = wend; } }
static void on_row_removed (ClutterModel *model, ClutterModelIter *iter, gpointer dummy) { print_iter (iter, "Removed"); }
void cb_reply(void *data, DBusMessage *reply, DBusError *error) { DBusMessageIter subiter; DBusMessageIter iter; dbus_message_iter_init (reply, &iter); print_iter(&iter,1); }
static void print_property(GDBusProxy *proxy, const char *name) { DBusMessageIter iter; if (g_dbus_proxy_get_property(proxy, name, &iter) == FALSE) return; print_iter("\t", name, &iter); }
static void item_property_changed(GDBusProxy *proxy, const char *name, DBusMessageIter *iter) { char *str; str = proxy_description(proxy, "Item", COLORED_CHG); print_iter(str, name, iter); g_free(str); }
void print_message (DBusMessage *message, dbus_bool_t literal) { DBusMessageIter iter; const char *sender; const char *destination; int message_type; message_type = dbus_message_get_type (message); sender = dbus_message_get_sender (message); destination = dbus_message_get_destination (message); if (!literal) { printf ("%s sender=%s -> dest=%s", type_to_name (message_type), sender ? sender : "(null sender)", destination ? destination : "(null destination)"); switch (message_type) { case DBUS_MESSAGE_TYPE_METHOD_CALL: case DBUS_MESSAGE_TYPE_SIGNAL: printf (" serial=%u path=%s; interface=%s; member=%s\n", dbus_message_get_serial (message), dbus_message_get_path (message), dbus_message_get_interface (message), dbus_message_get_member (message)); break; case DBUS_MESSAGE_TYPE_METHOD_RETURN: printf (" reply_serial=%u\n", dbus_message_get_reply_serial (message)); break; case DBUS_MESSAGE_TYPE_ERROR: printf (" error_name=%s reply_serial=%u\n", dbus_message_get_error_name (message), dbus_message_get_reply_serial (message)); break; default: printf ("\n"); break; } } dbus_message_iter_init (message, &iter); print_iter (&iter, literal, 1); fflush (stdout); }
static void filter_model (ClutterModel *model) { ClutterModelIter *iter; g_print ("\n* Filter function: even rows\n"); clutter_model_set_filter (model, filter_func, NULL, NULL); iter = clutter_model_get_first_iter (model); while (!clutter_model_iter_is_last (iter)) { print_iter (iter, "Filtered Forward Iteration"); iter = clutter_model_iter_next (iter); } g_object_unref (iter); g_print ("\n* Sorting function: reverse alpha\n"); clutter_model_set_sort (model, COLUMN_BAR, sort_func, NULL, NULL); g_signal_connect (model, "row-changed", G_CALLBACK (on_row_changed), NULL); iter = clutter_model_get_iter_at_row (model, 0); clutter_model_iter_set (iter, COLUMN_BAR, "Changed string of 0th row, " "automatically gets sorted", -1); g_object_unref (iter); clutter_model_foreach (model, foreach_func, NULL); g_print ("\n* Unset filter\n"); clutter_model_set_filter (model, NULL, NULL, NULL); while (clutter_model_get_n_rows (model)) clutter_model_remove (model, 0); clutter_main_quit (); }
void test() { testtype::verbose = false; printf("sizeof(int) %lu, sizeof(void *) %lu, sizeof list<int> %lu, sizeof(iterator) %lu, sizeof(*iterator) %lu\n", (unsigned long)sizeof(int), (unsigned long)sizeof(void *), (unsigned long)sizeof(ttl::list<int>), (unsigned long)sizeof(ttl::list<int>().begin()), (unsigned long)sizeof(*ttl::list<int>().begin())); const testtype nine(9); ttl::list<testtype> dl(10, nine); assert(dl.size() < dl.max_size()); assert(dl.front() == constify(dl).front() && dl.front() == nine); assert(dl.back() == constify(dl).back() && dl.back() == nine); assert(ttl::count(dl.begin(), dl.end(), dl.front()) == 10 && ttl::count(dl.begin(), dl.end(), dl.back()) == 10 && ttl::count(dl.begin(), dl.end(), nine) == 10 && ttl::count(dl.begin(), dl.end(), nine) == (int)dl.size()); assert(ttl::count(dl.cbegin(), dl.cend(), nine) == 10); assert(ttl::count(constify(dl).begin(), constify(dl).end(), nine) == 10); { ttl::list<testtype> dl1 = dl; ttl::list<testtype> dl2 = dl; assert(dl1 == dl); assert(!(dl2 != dl1)); dl1.clear(); assert(dl1.empty()); dl1.swap(dl2); // case 1 assert(dl2.empty()); assert(ttl::count(dl1.cbegin(), dl1.cend(), nine) == 10); dl1.swap(dl2); // case 2 assert(dl1.empty()); assert(ttl::count(dl2.cbegin(), dl2.cend(), nine) == 10); dl1.push_back(testtype(0xfeed)); dl1.swap(dl2); // case 3 assert(ttl::count(dl1.cbegin(), dl1.cend(), nine) == 10); assert(dl2.front() == testtype(0xfeed) && dl2.front() == dl2.back() && ++dl2.begin() == dl2.end()); } int c = 0; for (ttl::list<testtype>::iterator i = dl.begin(); i != dl.end(); ++i) { assert(*i == nine); i->value = c++; } for (ttl::list<testtype>::iterator i = dl.end(); i-- != dl.begin();) { assert(i->value == --c); *i = testtype(c); } dl.erase(++dl.begin(), advanceIt(dl.begin(), 9)); // dl = [0, 8, 9] print_iter("after erase(from, to), dl:", dl.cbegin(), dl.cend()); assert(dl.front() == testtype(0)); assert(*++dl.cbegin() == testtype(8)); assert(dl.back() == testtype(9)); assert(dl.size() == 3); dl.push_front(testtype(999)); // dl = [999, 0, 8, 9] assert(dl.front() == testtype(999)); assert(*++dl.cbegin() == testtype(0)); assert(dl.back() == testtype(9)); assert(dl.size() == 4); dl.push_front(testtype(1000)); // dl = [1000, 999, 0, 8, 9] assert(dl.front() == testtype(1000)); assert(dl.size() == 5); dl.pop_front(); // dl = [999, 0, 9] assert(dl.front() == testtype(999)); assert(dl.size() == 4); dl.push_back(testtype(1000)); // dl = [999, 0, 8, 9, 1000] assert(dl.back() == testtype(1000)); assert(dl.size() == 5); dl.pop_front(); // dl = [0, 8, 9, 1000] assert(dl.front() == testtype(0)); assert(dl.size() == 4); dl.pop_back(); // dl = [0, 8, 9] assert(dl.back() == testtype(9)); dl.pop_back(); // dl = [0, 8] assert(dl.back() == testtype(8)); assert(dl.size() == 2); dl.insert(dl.begin(), testtype(1001)); // dl = [1001, 0, 8] assert(dl.front() == testtype(1001)); assert(dl.size() == 3); dl.insert(++dl.begin(), testtype(1002)); // dl = [1001, 1002, 0, 8] dl.insert(++ ++dl.begin(), testtype(1003)); // dl = [1001, 1002, 1003, 0, 8] assert(dl.size() == 5); dl.erase(dl.cbegin()); // dl = [1002, 1003, 0, 8] assert(dl.front() == testtype(1002)); assert(dl.size() == 4); print_iter("after erase(at):", dl.cbegin(), dl.cend()); static const int data[] = {'0','1','2','3'}; static const int ascii[] = {'A','B','C','D'}; dl.insert(dl.begin(), data, data + countof(data)); print_iter("after insert<>(at, from, to):", dl.cbegin(), dl.cend()); assert(dl.size() == 8); { ttl::list<testtype> dl1, dl2; dl1.assign(data, data + countof(data)); dl2.assign(data, data + countof(data)); print_iter("after assign dl1:", dl1.cbegin(), dl1.cend()); print_iter("after assign dl2:", dl2.cbegin(), dl2.cend()); assert(ttl::equal(dl1.cbegin(), dl1.cend(), data)); assert(ttl::equal(dl1.cbegin(), dl1.cend(), dl2.begin())); assert(dl1.size() == dl2.size()); } { ttl::list<testtype> dl1, dl2; dl1.assign(data, data + countof(data)); dl2.assign(data, data + countof(data)); dl1.splice(dl1.begin(), dl2); print_iter("after splice dl1:", dl1.cbegin(), dl1.cend()); dl2.assign(ascii, ascii + countof(ascii)); dl1.splice(dl1.begin(), dl2, dl2.begin()); print_iter("after splice(from) dl1:", dl1.cbegin(), dl1.cend()); print_iter(" dl2:", dl2.cbegin(), dl2.cend()); dl1.splice(dl1.begin(), dl2, dl2.begin(), ++ ++dl2.begin()); print_iter("after splice(from,to) dl1:", dl1.cbegin(), dl1.cend()); print_iter(" dl2:", dl2.cbegin(), dl2.cend()); } print_iter("before reverse, dl:", dl.cbegin(), dl.cend()); dl.reverse(); print_iter("after reverse, dl :", dl.cbegin(), dl.cend()); dl.remove(testtype(1003)); print_iter("after remove, dl :", dl.cbegin(), dl.cend()); assert(ttl::count_if(dl.begin(), dl.end(), t::equal_to<testtype>(1003)) == 0); dl.remove_if(t::equal_to<testtype>(testtype(1002))); print_iter("after remove, dl :", dl.cbegin(), dl.cend()); assert(ttl::count_if(dl.begin(), dl.end(), t::equal_to<testtype>(1002)) == 0); dl.insert(dl.end(), 10, nine); print_iter_ptr("before unique, dl :", dl.cbegin(), dl.cend()); dl.unique(); print_iter_ptr("after unique, dl :", dl.cbegin(), dl.cend()); assert(ttl::count_if(dl.begin(), dl.end(), t::equal_to<testtype>(nine)) == 1); dl.insert(dl.end(), 10, nine); print_iter_ptr("before unique(pred), dl :", dl.cbegin(), dl.cend()); dl.unique(ttl::equal_to<testtype>()); // binary predicate print_iter_ptr("after unique(pred), dl :", dl.cbegin(), dl.cend()); assert(ttl::count_if(dl.begin(), dl.end(), t::equal_to<testtype>(nine)) == 1); { ttl::list<testtype> dl1, dl2; dl1.assign(data, data + countof(data)); dl1.push_back(testtype('a')); dl2.assign(ascii, ascii + countof(ascii)); dl2.push_back(testtype('b')); print_iter("dl1:", dl1.cbegin(), dl1.cend()); print_iter("dl2:", dl2.cbegin(), dl2.cend()); ttl::list<testtype> dl1copy = dl1; ttl::list<testtype> dl2copy = dl2; dl1.merge(dl2copy); print_iter("after merge, dl1:", dl1.cbegin(), dl1.cend()); dl2.merge(dl1copy, ttl::less<testtype>()); print_iter("after merge, dl2:", dl1.cbegin(), dl1.cend()); assert(dl1copy.empty()); assert(dl2copy.empty()); assert(ttl::equal(dl1.cbegin(), dl1.cend(), dl2.cbegin())); dl2copy.merge(dl2); // merge into empty list assert(ttl::equal(dl1.cbegin(), dl1.cend(), dl2copy.cbegin())); dl2copy.merge(dl1copy); // merge an empty list assert(ttl::equal(dl1.cbegin(), dl1.cend(), dl2copy.cbegin())); } dl.resize(40); assert(dl.size() == 40); dl.resize(4); assert(dl.size() == 4); dl.resize(30, nine); assert(dl.size() == 30); assert(ttl::count(dl.begin(), dl.end(), nine) == 26); printf("dtors\n"); }
static void on_row_changed (ClutterModel *model, ClutterModelIter *iter) { print_iter (iter, "Changed"); }
static void print_iter (DBusMessageIter *iter, dbus_bool_t literal, int depth) { do { int type = dbus_message_iter_get_arg_type (iter); if (type == DBUS_TYPE_INVALID) break; indent(depth); switch (type) { case DBUS_TYPE_STRING: { char *val; dbus_message_iter_get_basic (iter, &val); if (!literal) printf ("string \""); printf ("%s", val); if (!literal) printf ("\"\n"); break; } case DBUS_TYPE_SIGNATURE: { char *val; dbus_message_iter_get_basic (iter, &val); if (!literal) printf ("signature \""); printf ("%s", val); if (!literal) printf ("\"\n"); break; } case DBUS_TYPE_OBJECT_PATH: { char *val; dbus_message_iter_get_basic (iter, &val); if (!literal) printf ("object path \""); printf ("%s", val); if (!literal) printf ("\"\n"); break; } case DBUS_TYPE_INT16: { dbus_int16_t val; dbus_message_iter_get_basic (iter, &val); printf ("int16 %d\n", val); break; } case DBUS_TYPE_UINT16: { dbus_uint16_t val; dbus_message_iter_get_basic (iter, &val); printf ("uint16 %u\n", val); break; } case DBUS_TYPE_INT32: { dbus_int32_t val; dbus_message_iter_get_basic (iter, &val); printf ("int32 %d\n", val); break; } case DBUS_TYPE_UINT32: { dbus_uint32_t val; dbus_message_iter_get_basic (iter, &val); printf ("uint32 %u\n", val); break; } case DBUS_TYPE_INT64: { dbus_int64_t val; dbus_message_iter_get_basic (iter, &val); #ifdef DBUS_INT64_PRINTF_MODIFIER printf ("int64 %" DBUS_INT64_PRINTF_MODIFIER "d\n", val); #else printf ("int64 (omitted)\n"); #endif break; } case DBUS_TYPE_UINT64: { dbus_uint64_t val; dbus_message_iter_get_basic (iter, &val); #ifdef DBUS_INT64_PRINTF_MODIFIER printf ("uint64 %" DBUS_INT64_PRINTF_MODIFIER "u\n", val); #else printf ("uint64 (omitted)\n"); #endif break; } case DBUS_TYPE_DOUBLE: { double val; dbus_message_iter_get_basic (iter, &val); printf ("double %g\n", val); break; } case DBUS_TYPE_BYTE: { unsigned char val; dbus_message_iter_get_basic (iter, &val); printf ("byte %d\n", val); break; } case DBUS_TYPE_BOOLEAN: { dbus_bool_t val; dbus_message_iter_get_basic (iter, &val); printf ("boolean %s\n", val ? "true" : "false"); break; } case DBUS_TYPE_VARIANT: { DBusMessageIter subiter; dbus_message_iter_recurse (iter, &subiter); printf ("variant "); print_iter (&subiter, literal, depth+1); break; } case DBUS_TYPE_ARRAY: { int current_type; DBusMessageIter subiter; dbus_message_iter_recurse (iter, &subiter); current_type = dbus_message_iter_get_arg_type (&subiter); if (current_type == DBUS_TYPE_BYTE) { print_ay (&subiter, depth); break; } printf("array [\n"); while (current_type != DBUS_TYPE_INVALID) { print_iter (&subiter, literal, depth+1); dbus_message_iter_next (&subiter); current_type = dbus_message_iter_get_arg_type (&subiter); if (current_type != DBUS_TYPE_INVALID) printf (","); } indent(depth); printf("]\n"); break; } case DBUS_TYPE_DICT_ENTRY: { DBusMessageIter subiter; dbus_message_iter_recurse (iter, &subiter); printf("dict entry(\n"); print_iter (&subiter, literal, depth+1); dbus_message_iter_next (&subiter); print_iter (&subiter, literal, depth+1); indent(depth); printf(")\n"); break; } case DBUS_TYPE_STRUCT: { int current_type; DBusMessageIter subiter; dbus_message_iter_recurse (iter, &subiter); printf("struct {\n"); while ((current_type = dbus_message_iter_get_arg_type (&subiter)) != DBUS_TYPE_INVALID) { print_iter (&subiter, literal, depth+1); dbus_message_iter_next (&subiter); if (dbus_message_iter_get_arg_type (&subiter) != DBUS_TYPE_INVALID) printf (","); } indent(depth); printf("}\n"); break; } case DBUS_TYPE_UNIX_FD: { int fd; dbus_message_iter_get_basic (iter, &fd); print_fd (fd, depth+1); /* dbus_message_iter_get_basic() duplicated the fd, we need to * close it after use. The original fd will be closed when the * DBusMessage is released. */ close (fd); break; } default: printf (" (dbus-monitor too dumb to decipher arg type '%c')\n", type); break; } } while (dbus_message_iter_next (iter)); }
int main(int argc, char *argv[]) { enum user_action action; int c; cs_error_t err; cmap_handle_t handle; int i; size_t value_len; cmap_value_types_t type; int track_prefix; int no_retries; char * settings_file = NULL; action = ACTION_PRINT_PREFIX; track_prefix = 1; while ((c = getopt(argc, argv, "hgsdDtTbp:")) != -1) { switch (c) { case 'h': return print_help(); break; case 'b': show_binary++; break; case 'g': action = ACTION_GET; break; case 's': action = ACTION_SET; break; case 'd': action = ACTION_DELETE; break; case 'D': action = ACTION_DELETE_PREFIX; break; case 'p': settings_file = optarg; action = ACTION_LOAD; break; case 't': action = ACTION_TRACK; track_prefix = 0; break; case 'T': action = ACTION_TRACK; break; case '?': return (EXIT_FAILURE); break; default: action = ACTION_PRINT_PREFIX; break; } } if (argc == 1 || (argc == 2 && show_binary)) { action = ACTION_PRINT_ALL; } argc -= optind; argv += optind; if (argc == 0 && action != ACTION_LOAD && action != ACTION_PRINT_ALL) { fprintf(stderr, "Expected key after options\n"); return (EXIT_FAILURE); } no_retries = 0; while ((err = cmap_initialize(&handle)) == CS_ERR_TRY_AGAIN && no_retries++ < MAX_TRY_AGAIN) { sleep(1); } if (err != CS_OK) { fprintf (stderr, "Failed to initialize the cmap API. Error %s\n", cs_strerror(err)); exit (EXIT_FAILURE); } switch (action) { case ACTION_PRINT_ALL: print_iter(handle, NULL); break; case ACTION_PRINT_PREFIX: for (i = 0; i < argc; i++) { print_iter(handle, argv[i]); } break; case ACTION_GET: for (i = 0; i < argc; i++) { err = cmap_get(handle, argv[i], NULL, &value_len, &type); if (err == CS_OK) { print_key(handle, argv[i], value_len, NULL, type); } else { fprintf(stderr, "Can't get key %s. Error %s\n", argv[i], cs_strerror(err)); } } break; case ACTION_DELETE: for (i = 0; i < argc; i++) { err = cmap_delete(handle, argv[i]); if (err != CS_OK) { fprintf(stderr, "Can't delete key %s. Error %s\n", argv[i], cs_strerror(err)); } } break; case ACTION_DELETE_PREFIX: for (i = 0; i < argc; i++) { delete_with_prefix(handle, argv[i]); } break; case ACTION_LOAD: read_in_config_file(handle, settings_file); break; case ACTION_TRACK: for (i = 0; i < argc; i++) { add_track(handle, argv[i], track_prefix); } track_changes(handle); break; case ACTION_SET: if (argc < 3) { fprintf(stderr, "At least 3 parameters are expected for set\n"); return (EXIT_FAILURE); } set_key(handle, argv[0], argv[1], argv[2]); break; } err = cmap_finalize(handle); if (err != CS_OK) { fprintf (stderr, "Failed to finalize the cmap API. Error %s\n", cs_strerror(err)); exit (EXIT_FAILURE); } return (0); }
static void print_iter (DBusMessageIter *iter, dbus_bool_t literal, int depth) { do { int type = dbus_message_iter_get_arg_type (iter); const char *str; dbus_uint32_t uint32; dbus_int32_t int32; double d; unsigned char byte; dbus_bool_t boolean; if (type == DBUS_TYPE_INVALID) break; while (depth-- > 0) putc (' ', stdout); switch (type) { case DBUS_TYPE_STRING: dbus_message_iter_get_basic (iter, &str); if (!literal) printf ("string \""); printf ("%s", str); if (!literal) printf ("\"\n"); break; case DBUS_TYPE_INT32: dbus_message_iter_get_basic (iter, &int32); printf ("int32 %d\n", int32); break; case DBUS_TYPE_UINT32: dbus_message_iter_get_basic (iter, &uint32); printf ("uint32 %u\n", uint32); break; case DBUS_TYPE_DOUBLE: dbus_message_iter_get_basic (iter, &d); printf ("double %g\n", d); break; case DBUS_TYPE_BYTE: dbus_message_iter_get_basic (iter, &byte); printf ("byte %d\n", byte); break; case DBUS_TYPE_BOOLEAN: dbus_message_iter_get_basic (iter, &boolean); printf ("boolean %s\n", boolean ? "true" : "false"); break; case DBUS_TYPE_VARIANT: { DBusMessageIter subiter; dbus_message_iter_recurse (iter, &subiter); printf ("variant:"); print_iter (&subiter, literal, depth); break; } case DBUS_TYPE_ARRAY: { int current_type; DBusMessageIter subiter; dbus_message_iter_recurse (iter, &subiter); printf("["); while ((current_type = dbus_message_iter_get_arg_type (&subiter)) != DBUS_TYPE_INVALID) { print_iter (&subiter, literal, depth); dbus_message_iter_next (&subiter); if (dbus_message_iter_get_arg_type (&subiter) != DBUS_TYPE_INVALID) printf (","); } printf("]"); break; } case DBUS_TYPE_DICT_ENTRY: { DBusMessageIter subiter; dbus_message_iter_recurse (iter, &subiter); printf("{"); print_iter (&subiter, literal, depth); dbus_message_iter_next (&subiter); print_iter (&subiter, literal, depth); printf("}"); break; } default: printf (" (dbus-monitor too dumb to decipher arg type '%c')\n", type); break; } } while (dbus_message_iter_next (iter)); }
static void print_iter(const char *label, const char *name, DBusMessageIter *iter) { dbus_bool_t valbool; dbus_uint32_t valu32; dbus_uint16_t valu16; dbus_int16_t vals16; const char *valstr; DBusMessageIter subiter; if (iter == NULL) { bt_shell_printf("%s%s is nil\n", label, name); return; } switch (dbus_message_iter_get_arg_type(iter)) { case DBUS_TYPE_INVALID: bt_shell_printf("%s%s is invalid\n", label, name); break; case DBUS_TYPE_STRING: case DBUS_TYPE_OBJECT_PATH: dbus_message_iter_get_basic(iter, &valstr); bt_shell_printf("%s%s: %s\n", label, name, valstr); break; case DBUS_TYPE_BOOLEAN: dbus_message_iter_get_basic(iter, &valbool); bt_shell_printf("%s%s: %s\n", label, name, valbool == TRUE ? "yes" : "no"); break; case DBUS_TYPE_UINT32: dbus_message_iter_get_basic(iter, &valu32); bt_shell_printf("%s%s: 0x%06x\n", label, name, valu32); break; case DBUS_TYPE_UINT16: dbus_message_iter_get_basic(iter, &valu16); bt_shell_printf("%s%s: 0x%04x\n", label, name, valu16); break; case DBUS_TYPE_INT16: dbus_message_iter_get_basic(iter, &vals16); bt_shell_printf("%s%s: %d\n", label, name, vals16); break; case DBUS_TYPE_VARIANT: dbus_message_iter_recurse(iter, &subiter); print_iter(label, name, &subiter); break; case DBUS_TYPE_ARRAY: dbus_message_iter_recurse(iter, &subiter); while (dbus_message_iter_get_arg_type(&subiter) != DBUS_TYPE_INVALID) { print_iter(label, name, &subiter); dbus_message_iter_next(&subiter); } break; case DBUS_TYPE_DICT_ENTRY: dbus_message_iter_recurse(iter, &subiter); dbus_message_iter_get_basic(&subiter, &valstr); dbus_message_iter_next(&subiter); print_iter(label, valstr, &subiter); break; default: bt_shell_printf("%s%s has unsupported type\n", label, name); break; } }
static void print_iter (DBusMessageIter *iter, dbus_bool_t literal, int depth) { do { int type = dbus_message_iter_get_arg_type (iter); if (type == DBUS_TYPE_INVALID) break; indent(depth); switch (type) { case DBUS_TYPE_STRING: { char *val; dbus_message_iter_get_basic (iter, &val); if (!literal) printf ("string \""); printf ("%s", val); if (!literal) printf ("\"\n"); break; } case DBUS_TYPE_SIGNATURE: { char *val; dbus_message_iter_get_basic (iter, &val); if (!literal) printf ("signature \""); printf ("%s", val); if (!literal) printf ("\"\n"); break; } case DBUS_TYPE_OBJECT_PATH: { char *val; dbus_message_iter_get_basic (iter, &val); if (!literal) printf ("object path \""); printf ("%s", val); if (!literal) printf ("\"\n"); break; } case DBUS_TYPE_INT16: { dbus_int16_t val; dbus_message_iter_get_basic (iter, &val); printf ("int16 %d\n", val); break; } case DBUS_TYPE_UINT16: { dbus_uint16_t val; dbus_message_iter_get_basic (iter, &val); printf ("uint16 %u\n", val); break; } case DBUS_TYPE_INT32: { dbus_int32_t val; dbus_message_iter_get_basic (iter, &val); printf ("int32 %d\n", val); break; } case DBUS_TYPE_UINT32: { dbus_uint32_t val; dbus_message_iter_get_basic (iter, &val); printf ("uint32 %u\n", val); break; } case DBUS_TYPE_INT64: { dbus_int64_t val; dbus_message_iter_get_basic (iter, &val); printf ("int64 %lld\n", val); break; } case DBUS_TYPE_UINT64: { dbus_uint64_t val; dbus_message_iter_get_basic (iter, &val); printf ("uint64 %llu\n", val); break; } case DBUS_TYPE_DOUBLE: { double val; dbus_message_iter_get_basic (iter, &val); printf ("double %g\n", val); break; } case DBUS_TYPE_BYTE: { unsigned char val; dbus_message_iter_get_basic (iter, &val); printf ("byte %d\n", val); break; } case DBUS_TYPE_BOOLEAN: { dbus_bool_t val; dbus_message_iter_get_basic (iter, &val); printf ("boolean %s\n", val ? "true" : "false"); break; } case DBUS_TYPE_VARIANT: { DBusMessageIter subiter; dbus_message_iter_recurse (iter, &subiter); printf ("variant "); print_iter (&subiter, literal, depth+1); break; } case DBUS_TYPE_ARRAY: { int current_type; DBusMessageIter subiter; dbus_message_iter_recurse (iter, &subiter); printf("array [\n"); while ((current_type = dbus_message_iter_get_arg_type (&subiter)) != DBUS_TYPE_INVALID) { print_iter (&subiter, literal, depth+1); dbus_message_iter_next (&subiter); if (dbus_message_iter_get_arg_type (&subiter) != DBUS_TYPE_INVALID) printf (","); } indent(depth); printf("]\n"); break; } case DBUS_TYPE_DICT_ENTRY: { DBusMessageIter subiter; dbus_message_iter_recurse (iter, &subiter); printf("dict entry(\n"); print_iter (&subiter, literal, depth+1); dbus_message_iter_next (&subiter); print_iter (&subiter, literal, depth+1); indent(depth); printf(")\n"); break; } case DBUS_TYPE_STRUCT: { int current_type; DBusMessageIter subiter; dbus_message_iter_recurse (iter, &subiter); printf("struct {\n"); while ((current_type = dbus_message_iter_get_arg_type (&subiter)) != DBUS_TYPE_INVALID) { print_iter (&subiter, literal, depth+1); dbus_message_iter_next (&subiter); if (dbus_message_iter_get_arg_type (&subiter) != DBUS_TYPE_INVALID) printf (","); } indent(depth); printf("}\n"); break; } default: printf (" (dbus-monitor too dumb to decipher arg type '%c')\n", type); break; } } while (dbus_message_iter_next (iter)); }
void test() { ttl::lazy_queue<testtype> lq; printf("lazy_queue %s\n", lq.empty() ? "empty": "not empty"); lq.push_front(1); print_iter("lazy_queue: push_front: ", lq.cbegin(), lq.cend()); printf("lazy_queue: front %d\n", lq.front().value); printf("lazy_queue: back %d\n", lq.back().value); lq.pop_front(); printf("lazy_queue: pop_front: %s\n", lq.empty() ? "empty": "not empty"); lq.push_back(2); lq.push_back(999); print_iter("lazy_queue: push_back: ", lq.cbegin(), lq.cend()); lq.pop_front(); static const int nums[] = { 1, 2,3,4,5,}; lq.insert_after(lq.cbefore_end(), nums, nums + countof(nums)); print_iter("lazy_queue: insert_after(pos, first, last):", lq.cbegin(), lq.cend()); lq.roll_head(); print_iter("lazy_queue: roll_head:", lq.cbegin(), lq.cend()); ttl::lazy_queue<testtype> lq1, lq2; lq1 = lq; print_iter("lazy_queue: operator=:", lq1.cbegin(), lq1.cend()); lq2.swap(lq1); print_iter("lazy_queue: swap:", lq2.cbegin(), lq2.cend()); lq2.erase_after(lq2.cbegin()); print_iter("lazy_queue: erase_after(pos):", lq2.cbegin(), lq2.cend()); lq2.erase_after(lq2.cbegin(), ++ ++ ++ ++ lq2.cbegin()); print_iter("lazy_queue: erase_after(first, last):", lq2.cbegin(), lq2.cend()); #if 0 ttl::lazy_queue<SIZE_TEST_TYPE> lqi_t; lqi_t.push_back(1); lqi_t.push_back(2); lqi_t.push_back(3); lqi_t.push_back(4); lqi_t.pop_front(); lqi_t.pop_front(); lqi_t.pop_front(); lqi_t.pop_front(); lqi_t.push_back(3); lqi_t.push_back(4); lqi_t.push_back(4); lqi_t.push_back(4); lqi_t.push_back(4); #endif #if 1 lazy_queue_int lqi_p; lqi_p.push_back(1); lqi_p.push_back(2); lqi_p.push_back(3); lqi_p.push_back(4); lqi_p.pop_front(); lqi_p.pop_front(); lqi_p.pop_front(); lqi_p.pop_front(); lqi_p.push_back(3); lqi_p.push_back(4); lqi_p.push_back(4); lqi_p.push_back(4); lqi_p.push_back(4); #endif }