void read_counts(Tree &T, Counts &data, std::string fname, long nalpha) { int i; unsigned int j; long id; State sta, sta2; std::string str; std::vector<long> d; // The number of letters is fixed to 4 in read_fasta. if (nalpha != 4) { std::cout << "Reading counts only implemented for 4 letters." << std::endl; } // reads in the alignment. The data is in _orbits and _couts. read_alignment(fname); // Now we fill in the Counts structure. data.nalpha = 4; data.nspecies = g_numSpecies; data.nstates = 1; // calculate the power: for (i=0; i < data.nspecies; i++) { data.nstates = data.nstates*data.nalpha; } // Creates a state of a given dimension create_state(sta, data.nspecies, data.nalpha); create_state(sta2, data.nspecies, data.nalpha); // Matches the species in the fasta with the ones in the tree. if (!match_species(T, g_nameSpecies, g_numSpecies, d)) { throw std::length_error( "Could not match species in tree with species in fasta." ); } // Stores the counts in the Counts structure. data.c.resize(data.nstates); data.N = 0; for (j=0; j < _orbitals.size(); j++) { str = transform_adn_chain_val_to_string(_orbitals[j]); string2state(str, sta); permute_state(d, sta, sta2); id = state2index(sta2); data.c[id] = (double) _counts[j]; data.N = data.N + data.c[id]; } // Stores the species names data.species.resize(data.nspecies); for (i=0; i < T.nleaves; i++) { data.species[i] = T.names[i]; } }
static DBusMessage *notify_update(DBusConnection *conn, DBusMessage *msg, void *user_data) { struct test_session *session = user_data; struct test_session_info *info = session->info; DBusMessageIter iter, array; GSList *allowed_bearers; LOG("session %p notify %s", session, session->notify_path); dbus_message_iter_init(msg, &iter); dbus_message_iter_recurse(&iter, &array); while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) { DBusMessageIter entry, value; const char *key; dbus_message_iter_recurse(&array, &entry); dbus_message_iter_get_basic(&entry, &key); dbus_message_iter_next(&entry); dbus_message_iter_recurse(&entry, &value); switch (dbus_message_iter_get_arg_type(&value)) { case DBUS_TYPE_ARRAY: if (g_str_equal(key, "AllowedBearers") == TRUE) { allowed_bearers = session_parse_allowed_bearers(&value); g_slist_foreach(info->allowed_bearers, bearer_info_cleanup, NULL); g_slist_free(info->allowed_bearers); info->allowed_bearers = allowed_bearers; } else if (g_str_equal(key, "IPv4") == TRUE) { /* XXX */ } else if (g_str_equal(key, "IPv6") == TRUE) { /* XXX */ } else { g_assert(FALSE); return __connman_error_invalid_arguments(msg); } break; case DBUS_TYPE_BOOLEAN: if (g_str_equal(key, "Priority") == TRUE) { dbus_message_iter_get_basic(&value, &info->priority); } else if (g_str_equal(key, "AvoidHandover") == TRUE) { dbus_message_iter_get_basic(&value, &info->avoid_handover); } else if (g_str_equal(key, "StayConnected") == TRUE) { dbus_message_iter_get_basic(&value, &info->stay_connected); } else if (g_str_equal(key, "EmergencyCall") == TRUE) { dbus_message_iter_get_basic(&value, &info->ecall); } else { g_assert(FALSE); return __connman_error_invalid_arguments(msg); } break; case DBUS_TYPE_UINT32: if (g_str_equal(key, "PeriodicConnect") == TRUE) { dbus_message_iter_get_basic(&value, &info->periodic_connect); } else if (g_str_equal(key, "IdleTimeout") == TRUE) { dbus_message_iter_get_basic(&value, &info->idle_timeout); } else if (g_str_equal(key, "SessionMarker") == TRUE) { dbus_message_iter_get_basic(&value, &info->marker); } else { g_assert(FALSE); return __connman_error_invalid_arguments(msg); } break; case DBUS_TYPE_STRING: if (g_str_equal(key, "State") == TRUE) { const char *val; dbus_message_iter_get_basic(&value, &val); info->state = string2state(val); } else if (g_str_equal(key, "Bearer") == TRUE) { const char *val; dbus_message_iter_get_basic(&value, &val); if (info->bearer != NULL) g_free(info->bearer); info->bearer = g_strdup(val); } else if (g_str_equal(key, "Name") == TRUE) { const char *val; dbus_message_iter_get_basic(&value, &val); if (info->name != NULL) g_free(info->name); info->name = g_strdup(val); } else if (g_str_equal(key, "RoamingPolicy") == TRUE) { const char *val; dbus_message_iter_get_basic(&value, &val); info->roaming_policy = string2roamingpolicy(val); } else if (g_str_equal(key, "Interface") == TRUE) { const char *val; dbus_message_iter_get_basic(&value, &val); if (info->interface != NULL) g_free(info->interface); info->interface = g_strdup(val); } else if (g_str_equal(key, "ConnectionType") == TRUE) { const char *val; dbus_message_iter_get_basic(&value, &val); info->type = string2type(val); } else { g_assert(FALSE); return __connman_error_invalid_arguments(msg); } break; default: g_assert(FALSE); return __connman_error_invalid_arguments(msg); } dbus_message_iter_next(&array); } if (session->notify != NULL) session->notify(session); return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); }
static void state_change(struct supplicant_task *task, DBusMessage *msg) { DBusError error; const char *newstate, *oldstate; unsigned char bssid[ETH_ALEN]; unsigned int bssid_len; enum supplicant_state state, ostate; dbus_error_init(&error); if (dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &newstate, DBUS_TYPE_STRING, &oldstate, DBUS_TYPE_INVALID) == FALSE) { if (dbus_error_is_set(&error) == TRUE) { connman_error("%s", error.message); dbus_error_free(&error); } else connman_error("Wrong arguments for state change"); return; } connman_info("%s state change %s -> %s%s", task->ifname, oldstate, newstate, task->scanning == TRUE ? " (scanning)" : ""); state = string2state(newstate); if (state == WPA_INVALID) return; if (task->scanning == TRUE && state != WPA_SCANNING) { connman_device_set_scanning(task->device, FALSE); task->scanning = FALSE; } ostate = task->state; task->state = state; if (task->network == NULL) return; switch (task->state) { case WPA_COMPLETED: if (ostate != WPA_ASSOCIATED && ostate != WPA_GROUP_HANDSHAKE) goto badstate; /* reset bg scan reschedule */ connman_device_reset_scan(task->device); if (get_bssid(task->device, bssid, &bssid_len) == 0) connman_network_set_address(task->network, bssid, bssid_len); /* carrier on */ connman_network_set_connected(task->network, TRUE); break; case WPA_ASSOCIATING: if (ostate != WPA_SCANNING && ostate != WPA_COMPLETED) goto badstate; if (ostate == WPA_SCANNING) connman_network_set_associating(task->network, TRUE); break; case WPA_INACTIVE: if (ostate != WPA_SCANNING && ostate != WPA_DISCONNECTED) goto badstate; /* fall thru... */ case WPA_DISCONNECTED: /* carrier off */ connman_network_set_connected(task->network, FALSE); if (task->disconnecting == TRUE) { connman_network_unref(task->network); task->disconnecting = FALSE; if (task->pending_network != NULL) { task->network = task->pending_network; task->pending_network = NULL; task_connect(task); } else task->network = NULL; } break; default: connman_network_set_associating(task->network, FALSE); break; } return; badstate: connman_error("%s invalid state change %s -> %s%s", task->ifname, oldstate, newstate, task->scanning == TRUE ? " (scanning)" : ""); }