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
}
