sc_time &tdma_bus::get_CurrentP2Pdelay(phy_link_t &plink, unsigned int msg_size ) { std::string msg; unsigned int slots_allocated, first_slot; sc_time current_offset_delay, data_tx_delay; link_info_t *plink_info_p; // retrieve properties stored (by the base comm_res) plink_info_p = get_properties(plink, msg_size); if(plink_info_p==NULL) { // property for the link-msg_size combination not found this->set_CurrentP2Pdelay(plink,msg_size); // refer to plinks info // retrieve the properties again plink_info_p = get_properties(plink, msg_size); // ... and it should not fail again if(plink_info_p==NULL) { std::string rpt_msg; std::ostringstream os; rpt_msg = "Setting properties of link "; os << plink; rpt_msg += os.str(); rpt_msg += " in TDMA bus "; rpt_msg += name(); rpt_msg += " failed."; SC_REPORT_ERROR("KisTA",rpt_msg.c_str()); } } data_tx_delay = plink_info_p->getMaxP2Pdelay(msg_size); // NOTE: // Notice that in the CurrentP2P call, only the time invariant component // was cached. // Now, the time dependent component is added. // A faster alternative is to use the L1 accuracy level, which provides // a random offset bounded by the maximum offset switch(accuracy_level) { case 0: first_slot = first_slot_allocation_table[plink.src]; current_offset_delay = current_offset_delay_L0(sc_time_stamp(),first_slot); break; case 1: slots_allocated = channel_allocation_table[plink.src]; current_offset_delay = current_offset_delay_L1(slots_allocated); break; default: msg = "TDMA bus "; msg += name(); msg += ": unknown accuracy level calculating Current P2P delay. Supported ones range 0(most accurate, slower) to 1(faster-less accurate)"; SC_REPORT_ERROR("KisTA",msg.c_str()); } current_tx_delay = current_offset_delay + data_tx_delay; // Note that we use a member variable of tdma_bus class (instead a local variable) // to enable the return of a refernce return current_tx_delay; }
std::string get_name( t_artifact_type artifact, bool include_article ) { assert( !is_cut( artifact ) ); if (include_article) return get_properties( artifact ).name_with_article; return get_properties( artifact ).name; }
sc_time &tdma_bus::get_MaxP2Pdelay(phy_link_t &plink, unsigned int msg_size ) { link_info_t *plink_info_p; // retrieve properties stored (by the base comm_res) plink_info_p = get_properties(plink, msg_size); if(plink_info_p==NULL) { // property for the link-msg_size combination not found this->set_MaxP2Pdelay(plink,msg_size); // refer to plinks info // retrieve the properties again plink_info_p = get_properties(plink, msg_size); // ... and it should not fail again if(plink_info_p==NULL) { std::string rpt_msg; std::ostringstream os; rpt_msg = "Setting properties of link "; os << plink; rpt_msg += os.str(); rpt_msg += " in TDMA bus "; rpt_msg += name(); rpt_msg += " failed."; SC_REPORT_ERROR("KisTA",rpt_msg.c_str()); } } return plink_info_p->getMaxP2Pdelay(msg_size); }
int main(int argc, char *argv[]) { DBusConnection *conn; struct ADAPTER_PROPERTIES *p; conn = init_dbus(); p = (struct ADAPTER_PROPERTIES *)malloc(sizeof(struct ADAPTER_PROPERTIES)); p->DiscoverableTimeout = 0; p->PairableTimeout = 0; p->Pairable = true; p->Discoverable = true; set_property(conn, "DiscoverableTimeout", p); set_property(conn, "PairableTimeout", p); set_property(conn, "Pairable", p); set_property(conn, "Discoverable", p); free(p); get_properties(conn); printf("%s %d\n", __func__, __LINE__); start_discovery(conn); printf("%s %d\n", __func__, __LINE__); return 0; }
gboolean gst_vaapiencode_init_properties (GstVaapiEncode * encode) { GPtrArray *const props = get_properties (GST_VAAPIENCODE_GET_CLASS (encode)); guint i; /* XXX: use base_init()/base_finalize() to avoid multiple initializations */ if (!props) return FALSE; encode->prop_values = g_ptr_array_new_full (props->len, (GDestroyNotify) prop_value_free); if (!encode->prop_values) { g_ptr_array_unref (props); return FALSE; } for (i = 0; i < props->len; i++) { PropValue *const prop_value = prop_value_new ((GstVaapiEncoderPropInfo *) g_ptr_array_index (props, i)); if (!prop_value) return FALSE; g_ptr_array_add (encode->prop_values, prop_value); } return TRUE; }
std::unique_ptr<n0::NodeComp> CompLight::Clone(const n0::SceneNode& node) const { auto comp = std::make_unique<CompLight>(); if (!m_light) { return comp; } auto type = m_light->get_type(); auto ctor = type.get_constructor(); auto var = ctor.invoke(); auto dst = var.get_value<std::shared_ptr<pt3::Light>>(); comp->SetLight(dst); for (auto& prop : type.get_properties()) { if (prop.get_metadata(js::RTTR::NoSerializeTag())) { continue; } rttr::variant prop_value = prop.get_value(m_light); if (!prop_value) { continue; } prop.set_value(dst, prop_value); } return comp; }
void BuyChipLayer::click_btn_sub(Ref* sender) { if(amount_ <= 0){ return; } auto user = static_pointer_cast<user_texas>( GetRoom()->get_user(GDM->get_user_id())); int buyin_min = GetRoom()->get_buyin_min(); int buyin_max = GetRoom()->get_buyin_max(); bool need_credit = false;//permission_.needcredit(); if (need_credit) { uint32_t credit = permission_.credit(); if (credit < buyin_max) buyin_max = credit; } int min_chip = buyin_min - user->get_properties()->chips(); int max_chip = buyin_max - user->get_properties()->chips(); uint32_t unit = GetRoom()->get_buy_min_unit(); uint32_t sub = max_chip - std::max(min_chip, 0); int32_t value = amount_ - unit; if(value >= min_chip && value <= max_chip) { float percent = (value - std::max(0, min_chip)) * 100.0f / sub; slider_chip_->setPercent(percent); amount_ = value; text_buy_number_->setString(tools::to_string(amount_)); } }
int main(int argc, char **argv) { GLFWwindow *window; t_properties *properties; properties = get_properties(); properties->map = (argc > 1 ? argv[1] : NULL); window = setup_program(properties); properties->ires = glGetUniformLocation(properties->program, "iResolution"); properties->itime = glGetUniformLocation(properties->program, "iGlobalTime"); glfwSetCursorPosCallback(window, cursor_position_callback); glfwSetWindowSizeCallback(window, window_size_callback); main_loop(window, properties); ft_putnbr(glGetError()); ft_putendl(" 2"); glDeleteShader(properties->shaders[0]); glDeleteShader(properties->shaders[1]); glDeleteProgram(properties->program); glDeleteVertexArrays(1, &(properties->model)); glDeleteBuffers(1, &(properties->verts)); glDeleteBuffers(1, &(properties->indices)); glfwTerminate(); return (0); }
XBT_ATTRIB_DEPRECATED_v323("Please use Actor::get_properties()") std::map<std::string, std::string>* getProperties() { std::map<std::string, std::string>* res = new std::map<std::string, std::string>(); std::unordered_map<std::string, std::string>* props = get_properties(); for (auto const& kv : *props) res->insert(kv); return res; }
GlslManager::GlslManager() : Mlt::Filter( mlt_filter_new() ) , pbo(0) , initEvent(0) , closeEvent(0) { mlt_filter filter = get_filter(); if ( filter ) { // Set the mlt_filter child in case we choose to override virtual functions. filter->child = this; mlt_properties_set_data(mlt_global_properties(), "glslManager", this, 0, (mlt_destructor) deleteManager, NULL); mlt_events_register( get_properties(), "init glsl", NULL ); mlt_events_register( get_properties(), "close glsl", NULL ); initEvent = listen("init glsl", this, (mlt_listener) GlslManager::onInit); closeEvent = listen("close glsl", this, (mlt_listener) GlslManager::onClose); } }
QStringList GumboInterface::get_all_properties() { QStringList properties; if (!m_source.isEmpty()) { if (m_output == NULL) { parse(); } properties = get_properties(m_output->root); } return properties; }
/** * Read the next rule from the input data * @param data the CSS data to read from * @param offset VAR param of the offset into data to read from * @return the rule or NULL */ static css_rule *get_css_rule( const char *data, int *offset ) { int pos = *offset; int state = 0; int bodyStart=-1,bodyEnd=-1; css_rule *rule = NULL; while ( state >= 0 && data[pos] != 0 ) { switch ( state ) { case 0: // collecting selector if ( data[pos] == '{' ) { bodyStart = pos; state = 1; } pos++; break; case 1: // collecting body if ( data[pos] == '}' ) { bodyEnd = pos; state = -1; } pos++; break; } } if ( (bodyStart == -1 || bodyEnd == -1)&&state!=0 ) { warning("failed to find css rule body", 0 ); return NULL; } else { rule = css_rule_create(); if ( rule != NULL ) { int res = get_selectors( data, *offset, bodyStart-(*offset), rule ); if ( res ) res = get_properties( &data[bodyStart+1], (bodyEnd-bodyStart), rule ); } // update pos even if rule-reading fails *offset = pos; if ( css_rule_valid(rule) ) return rule; else if ( rule != NULL ) css_rule_dispose( rule ); return NULL; } }
// ------------------------------------------------------------------------- // get properties for a given artifact image // ------------------------------------------------------------------------- t_bitmap_layer_ptr get_icon( t_artifact_type artifact ) { assert( !is_cut( artifact ) ); static bool initialized = false; static t_bitmap_pool k_artifact_icons; static int icon_ids[ k_artifact_type_count ]; static t_bitmap_group_cache caches[] = { "icons.artifacts.armor", "icons.artifacts.item", "icons.artifacts.special", "icons.artifacts.weapon" }; if (!initialized) { std::vector<t_string_pair> layer_names( k_artifact_type_count ); t_artifact_type artifact; initialized = true; for (artifact = t_artifact_type(0); artifact < k_artifact_type_count; enum_incr(artifact)) { t_string_pair & layer_name = layer_names[ artifact ]; t_artifact_properties const & properties = get_properties( artifact ); if ( !properties.cut ) { layer_name.value = get_properties( artifact ).file_id; layer_name.keyword = get_keyword( artifact ); } else layer_name.value = 0; } k_artifact_icons = t_bitmap_pool( caches, &(*layer_names.begin()), layer_names.size() ); } return k_artifact_icons.get( artifact ); }
void RectangularMesh:: write_binary_files_in_cells(const std::string &prop_filename, std::vector<std::string> &filenames_out) const { std::cout << "Writing binary files in cells..." << std::endl; double t_begin = get_wall_time(); // Create the map between the material IDs and the media properties. The // material IDs must exactly the same as in the given triangular mesh. std::map<int, std::vector<double> > properties; get_properties(prop_filename, properties); const int n_properties = properties.begin()->second.size(); filenames_out.resize(n_properties); std::ofstream *out = new std::ofstream[n_properties]; for (int i = 0; i < n_properties; ++i) { filenames_out[i] = "property" + d2s(i) + "_cells.bin"; out[i].open(filenames_out[i].c_str(), std::ios::binary); require(out[i], "File '" + filenames_out[i] + "' can't be opened"); } for (int i = 0; i < _n_elements_x*_n_elements_z; ++i) { const int matID = _cells_ID[i]; std::map<int, std::vector<double> >::const_iterator iter = properties.find(matID); require(iter != properties.end(), "The material ID " + d2s(matID) + " wasn't found in the properties file"); const std::vector<double> values = iter->second; for (int p = 0; p < n_properties; ++p) { OUT_FLOAT_TYPE val = values[p]; out[p].write(reinterpret_cast<char*>(&val), sizeof(OUT_FLOAT_TYPE)); } } for (int i = 0; i < n_properties; ++i) out[i].close(); delete[] out; std::cout << "Writing binary files in cells is done. Time = " << get_wall_time() - t_begin << std::endl; }
static void get_device_list_cb (DBusPendingCall *pending, void *user_data) { DBusMessage *reply = NULL; gchar **devices = NULL; int n_devices = 0; (void) user_data; if (pending == NULL) goto error; reply = dbus_pending_call_steal_reply(pending); dbus_pending_call_unref(pending); pending = NULL; if (reply == NULL) { goto error; } if (dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_ERROR) { goto error; } if (!dbus_message_get_args (reply, NULL, DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &devices, &n_devices, DBUS_TYPE_INVALID)) { goto error; } /* ok, then ask the adapter (whose object path we now know) about * the listed devices */ for (; n_devices > 0; n_devices--) { OHM_DEBUG(DBG_BT, "getting properties of device '%s'\n", devices[n_devices-1]); get_properties(devices[n_devices-1], BT_INTERFACE_DEVICE, get_properties_cb); } dbus_free_string_array(devices); return; error: if (reply) dbus_message_unref (reply); return; }
QStringList GumboInterface::get_properties(GumboNode* node) { if (node->type != GUMBO_NODE_ELEMENT) { return QStringList(); } QStringList properties; std::string tagname = get_tag_name(node); if (in_set(manifest_properties, tagname)) { properties.append(QString::fromStdString(tagname)); } GumboVector* children = &node->v.element.children; for (unsigned int i = 0; i < children->length; ++i) { properties.append(get_properties(static_cast<GumboNode*>(children->data[i]))); } return properties; }
gboolean gst_vaapiencode_class_init_properties (GstVaapiEncodeClass * klass) { GObjectClass *const object_class = G_OBJECT_CLASS (klass); GPtrArray *const props = get_properties (klass); guint i; if (!props) return FALSE; for (i = 0; i < props->len; i++) { GstVaapiEncoderPropInfo *const prop = g_ptr_array_index (props, i); g_object_class_install_property (object_class, PROP_BASE + i, prop->pspec); } g_ptr_array_unref (props); return TRUE; }
void BuyChipLayer::slider_slider_chip(Ref* sender, Slider::EventType event) { auto user = static_pointer_cast<user_texas>(GetRoom()->get_user(GDM->get_user_id())); // int min = PDM->get_room()->get_buyin_min() - user->get_chip_amount(); // int max = PDM->get_room()->get_buyin_max() - user->get_chip_amount(); // int amount = max - min; // int buy_count = min + amount * slider_chip_->getPercent() / 100.0f; // text_buy_number_->setString(tools::to_string(buy_count)); int buyin_min = GetRoom()->get_buyin_min(); int buyin_max = GetRoom()->get_buyin_max(); if (need_credit_) { uint32_t credit = permission_.credit(); if (credit < buyin_max) buyin_max = credit; } int min_chip = buyin_min - user->get_properties()->chips(); int max_chip = buyin_max - user->get_properties()->chips(); if (min_chip < 0) { min_chip = 0; } int count = (max_chip - min_chip) * slider_chip_->getPercent() / 100.0f + min_chip; if(count % GetRoom()->get_buy_min_unit() != 0) { count = count / GetRoom()->get_buy_min_unit() * GetRoom()->get_buy_min_unit() + GetRoom()->get_buy_min_unit(); } if(count <= min_chip) { count = min_chip; } if(count >= max_chip) { count = max_chip; } amount_ = count; text_buy_number_->setString(tools::to_string(count)); //cocos2d::log("BuyChipLayer:slider_chip min:%d,max:%d,count:%d", min_chip, max_chip, count); }
void RectangularMesh:: write_ASCII_files_at_nodes(const std::string &prop_filename) const { std::cout << "Writing ASCII files at nodes..." << std::endl; double t_begin = get_wall_time(); // Create the map between the material IDs and the media properties. The // material IDs must exactly the same as in the given triangular mesh. std::map<int, std::vector<double> > properties; get_properties(prop_filename, properties); const int n_properties = properties.begin()->second.size(); std::vector<std::string> filenames_out(n_properties); std::ofstream *out = new std::ofstream[n_properties]; for (int i = 0; i < n_properties; ++i) { filenames_out[i] = "property" + d2s(i) + "_nodes.txt"; out[i].open(filenames_out[i].c_str(), std::ios::binary); require(out[i], "File '" + filenames_out[i] + "' can't be opened"); } for (int i = 0; i < (_n_elements_x+1)*(_n_elements_z+1); ++i) { const int matID = _verts_ID[i]; std::map<int, std::vector<double> >::const_iterator iter = properties.find(matID); require(iter != properties.end(), "The material ID " + d2s(matID) + " wasn't found in the properties file"); const std::vector<double> values = iter->second; for (int p = 0; p < n_properties; ++p) out[p] << values[p] << "\n"; } for (int i = 0; i < n_properties; ++i) out[i].close(); delete[] out; std::cout << "Writing ASCII files at nodes is done. Time = " << get_wall_time() - t_begin << std::endl; }
std::string get_defs(GType gtype, GTypeIsAPointerFunc is_a_pointer_func) { std::string strObjectName = g_type_name(gtype); std::string strDefs; if (G_TYPE_IS_OBJECT(gtype) || G_TYPE_IS_INTERFACE(gtype)) { strDefs = ";; From " + strObjectName + "\n\n"; strDefs += get_signals(gtype, is_a_pointer_func); strDefs += get_properties(gtype); } else strDefs = ";; " + strObjectName + " is neither a GObject nor a GInterface. Not checked for signals and properties.\n\n"; return strDefs; }
bool RH_RF24::printRegisters() { #ifdef RH_HAVE_SERIAL uint8_t i; // First print the commands that return interesting data for (i = 0; i < NUM_COMMAND_INFO; i++) { CommandInfo cmd; memcpy_P(&cmd, &commands[i], sizeof(cmd)); uint8_t buf[10]; // Big enough for the biggest command reply if (command(cmd.cmd, NULL, 0, buf, cmd.replyLen)) { // Print the results: Serial.print("cmd: "); Serial.print(cmd.cmd, HEX); Serial.print(" : "); uint8_t j; for (j = 0; j < cmd.replyLen; j++) { Serial.print(buf[j], HEX); Serial.print(" "); } Serial.println(""); } } // Now print the properties for (i = 0; i < NUM_PROPERTIES; i++) { uint16_t prop; memcpy_P(&prop, &properties[i], sizeof(prop)); uint8_t result; get_properties(prop, &result, 1); Serial.print("prop: "); Serial.print(prop, HEX); Serial.print(": "); Serial.print(result, HEX); Serial.println(""); } #endif return true; }
QStringList GumboInterface::get_properties(GumboNode* node) { if (node->type != GUMBO_NODE_ELEMENT) { return QStringList(); } QStringList properties; std::string tagname = get_tag_name(node); if (in_set(manifest_properties, tagname)) { properties.append(QString::fromStdString(tagname)); } GumboAttribute* attr = gumbo_get_attribute(&node->v.element.attributes, "src"); if (attr && !QUrl(QString::fromUtf8(attr->value)).isRelative()) { properties.append(QString("remote-resources")); } GumboVector* children = &node->v.element.children; for (unsigned int i = 0; i < children->length; ++i) { properties.append(get_properties(static_cast<GumboNode*>(children->data[i]))); } return properties; }
static GList *mate_mplayer_properties_get_pages(NemoPropertyPageProvider * provider, GList * files) { GList *pages = NULL; NemoFileInfo *file; GtkWidget *page, *label; NemoPropertyPage *property_page; guint i; gboolean found = FALSE; gchar *uri; /* only add properties page if a single file is selected */ if (files == NULL || files->next != NULL) return pages; file = files->data; /* only add the properties page to these mime types */ for (i = 0; i < G_N_ELEMENTS(mime_types); i++) { if (nemo_file_info_is_mime_type(file, mime_types[i])) { found = TRUE; break; } } if (found) { uri = nemo_file_info_get_uri(file); label = gtk_label_new(dgettext(GETTEXT_PACKAGE, "Audio/Video")); page = gtk_table_new(20, 2, FALSE); gtk_container_set_border_width(GTK_CONTAINER(page), 6); if (get_properties(page, uri)) { gtk_widget_show_all(page); property_page = nemo_property_page_new("video-properties", label, page); pages = g_list_prepend(pages, property_page); } g_free(uri); } return pages; }
static void remote_device_properties_callback(bt_status_t status, bt_bdaddr_t *bd_addr, int num_properties, bt_property_t *properties) { if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } ALOGV("%s: Status is: %d, Properties: %d", __FUNCTION__, status, num_properties); if (status != BT_STATUS_SUCCESS) { ALOGE("%s: Status %d is incorrect", __FUNCTION__, status); return; } callbackEnv->PushLocalFrame(ADDITIONAL_NREFS); jobjectArray props; jbyteArray addr; jintArray types; jbyteArray val; jclass mclass; val = (jbyteArray) callbackEnv->NewByteArray(num_properties); if (val == NULL) { ALOGE("%s: Error allocating byteArray", __FUNCTION__); return; } mclass = callbackEnv->GetObjectClass(val); /* Initialize the jobjectArray and jintArray here itself and send the initialized array pointers alone to get_properties */ props = callbackEnv->NewObjectArray(num_properties, mclass, NULL); if (props == NULL) { ALOGE("%s: Error allocating object Array for properties", __FUNCTION__); return; } types = (jintArray)callbackEnv->NewIntArray(num_properties); if (types == NULL) { ALOGE("%s: Error allocating int Array for values", __FUNCTION__); return; } // Delete the reference to val and mclass callbackEnv->DeleteLocalRef(mclass); callbackEnv->DeleteLocalRef(val); addr = callbackEnv->NewByteArray(sizeof(bt_bdaddr_t)); if (addr == NULL) goto Fail; if (addr) callbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t), (jbyte*)bd_addr); if (get_properties(num_properties, properties, &types, &props) < 0) { if (props) callbackEnv->DeleteLocalRef(props); if (types) callbackEnv->DeleteLocalRef(types); callbackEnv->PopLocalFrame(NULL); return; } callbackEnv->CallVoidMethod(sJniCallbacksObj, method_devicePropertyChangedCallback, addr, types, props); checkAndClearExceptionFromCallback(callbackEnv, __FUNCTION__); callbackEnv->DeleteLocalRef(props); callbackEnv->DeleteLocalRef(types); callbackEnv->DeleteLocalRef(addr); callbackEnv->PopLocalFrame(NULL); return; Fail: ALOGE("Error while allocation byte array in %s", __FUNCTION__); }
static void adapter_properties_callback(bt_status_t status, int num_properties, bt_property_t *properties) { jobjectArray props; jintArray types; jbyteArray val; jclass mclass; if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } ALOGV("%s: Status is: %d, Properties: %d", __FUNCTION__, status, num_properties); if (status != BT_STATUS_SUCCESS) { ALOGE("%s: Status %d is incorrect", __FUNCTION__, status); return; } val = (jbyteArray) callbackEnv->NewByteArray(num_properties); if (val == NULL) { ALOGE("%s: Error allocating byteArray", __FUNCTION__); return; } mclass = callbackEnv->GetObjectClass(val); /* (BT) Initialize the jobjectArray and jintArray here itself and send the initialized array pointers alone to get_properties */ props = callbackEnv->NewObjectArray(num_properties, mclass, NULL); if (props == NULL) { ALOGE("%s: Error allocating object Array for properties", __FUNCTION__); return; } types = (jintArray)callbackEnv->NewIntArray(num_properties); if (types == NULL) { ALOGE("%s: Error allocating int Array for values", __FUNCTION__); return; } // Delete the reference to val and mclass callbackEnv->DeleteLocalRef(mclass); callbackEnv->DeleteLocalRef(val); if (get_properties(num_properties, properties, &types, &props) < 0) { if (props) callbackEnv->DeleteLocalRef(props); if (types) callbackEnv->DeleteLocalRef(types); return; } callbackEnv->CallVoidMethod(sJniCallbacksObj, method_adapterPropertyChangedCallback, types, props); checkAndClearExceptionFromCallback(callbackEnv, __FUNCTION__); callbackEnv->DeleteLocalRef(props); callbackEnv->DeleteLocalRef(types); return; }
mapping get_all() { return get_properties(); }
// Implementation of "agent_properties" command. static jint get_agent_properties(AttachOperation* op, outputStream* out) { return get_properties(op, out, vmSymbols::serializeAgentPropertiesToByteArray_name()); }
static void scan_results_reply(DBusPendingCall *call, void *user_data) { struct supplicant_task *task = user_data; DBusMessage *reply; DBusError error; char **results; int i, num_results; _DBG_SUPPLICANT("task %p", task); reply = dbus_pending_call_steal_reply(call); if (reply == NULL) goto noscan; if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) goto done; dbus_error_init(&error); if (dbus_message_get_args(reply, &error, DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &results, &num_results, 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 scan result"); goto done; } if (num_results == 0) goto done; task->scangen++; for (i = 0; i < num_results; i++) { char *path = g_strdup(results[i]); if (path == NULL) continue; task->scan_results = g_slist_append(task->scan_results, path); } g_strfreev(results); dbus_message_unref(reply); get_properties(task); return; done: dbus_message_unref(reply); noscan: task->result_call = NULL; if (task->scanning == TRUE) { connman_device_set_scanning(task->device, FALSE); task->scanning = FALSE; } }
SEXP Riproc_recv_model(SEXP ytime, SEXP ysender, SEXP yreceiver, SEXP xtime, SEXP xsender, SEXP xreceiver, SEXP factors, SEXP variables, SEXP nsend, SEXP nrecv, SEXP loops) { struct properties p; struct history hx, hy; struct design s, r; struct design2 d; struct terms_object tm; const struct message *msgs; size_t nmsg; size_t iter, dim, nc, ntot, rank; size_t ncextra; struct recv_fit fit; const struct recv_loglik *ll; const struct recv_model *model; const struct constr *constr; const double *beta, *nu; double dev; SEXP names; SEXP ret = NULL_USER_OBJECT; int k; int err = 0; err = get_properties(nsend, nrecv, loops, &p); if (err < 0) goto properties_fail; history_init(&hy, p.nsend, p.nrecv); err = get_history(ytime, ysender, yreceiver, &hy); if (err < 0) goto yhistory_fail; history_init(&hx, p.nsend, p.nrecv); err = get_history(xtime, xsender, xreceiver, &hx); if (err < 0) goto xhistory_fail; design_init(&s, &hx, p.nsend); design_init(&r, &hx, p.nrecv); design2_init(&d, &hx, p.nsend, p.nrecv); err = get_terms_object(factors, variables, &s, &r, &d, &tm); if (err < 0) goto terms_fail; history_get_messages(&hy, &msgs, &nmsg); recv_fit_init(&fit, &r, &d, p.exclude_loops, msgs, nmsg, NULL, NULL); ncextra = recv_fit_extra_constr_count(&fit); if (ncextra) warning("adding %zd %s to make parameters identifiable\n", ncextra, ncextra == 1 ? "constraint" : "constraints"); err = do_fit(&fit, NULL, NULL, &iter); if (err < 0) goto fit_fail; constr = recv_fit_constr(&fit); nc = constr_count(constr); ll = recv_fit_loglik(&fit); ntot = recv_loglik_count(ll); model = recv_loglik_model(ll); beta = (recv_model_params(model))->recv.traits; /* HACK */ nu = recv_fit_duals(&fit); dim = recv_model_dim(model); rank = dim - nc; dev = recv_loglik_dev(ll); PROTECT(ret = NEW_LIST(16)); PROTECT(names = NEW_CHARACTER(16)); SET_NAMES(ret, names); k = 0; SET_STRING_ELT(names, k, COPY_TO_USER_STRING("coefficients")); SET_VECTOR_ELT(ret, k, alloc_vector_copy(beta, dim)); k++; SET_STRING_ELT(names, k, COPY_TO_USER_STRING("duals")); SET_VECTOR_ELT(ret, k, alloc_vector_copy(nu, nc)); k++; SET_STRING_ELT(names, k, COPY_TO_USER_STRING("constraints")); SET_VECTOR_ELT(ret, k, alloc_matrix_copy(constr_all_wts(constr), nc, dim)); k++; SET_STRING_ELT(names, k, COPY_TO_USER_STRING("constraint.values")); SET_VECTOR_ELT(ret, k, alloc_vector_copy(constr_all_vals(constr), nc)); k++; SET_STRING_ELT(names, k, COPY_TO_USER_STRING("rank")); SET_VECTOR_ELT(ret, k, ScalarInteger((int)rank)); k++; SET_STRING_ELT(names, k, COPY_TO_USER_STRING("deviance")); SET_VECTOR_ELT(ret, k, ScalarReal(dev)); k++; SET_STRING_ELT(names, k, COPY_TO_USER_STRING("aic")); SET_VECTOR_ELT(ret, k, ScalarReal(dev + (double) 2 * rank)); k++; SET_STRING_ELT(names, k, COPY_TO_USER_STRING("null.deviance")); SET_VECTOR_ELT(ret, k, ScalarReal(recv_fit_dev0(&fit))); k++; SET_STRING_ELT(names, k, COPY_TO_USER_STRING("iter")); SET_VECTOR_ELT(ret, k, ScalarInteger((int)iter)); k++; SET_STRING_ELT(names, k, COPY_TO_USER_STRING("df.residual")); SET_VECTOR_ELT(ret, k, ScalarReal((double)(ntot - rank))); k++; SET_STRING_ELT(names, k, COPY_TO_USER_STRING("df.null")); SET_VECTOR_ELT(ret, k, ScalarReal((double)ntot)); k++; SET_STRING_ELT(names, k, COPY_TO_USER_STRING("converged")); SET_VECTOR_ELT(ret, k, ScalarLogical(TRUE)); k++; SET_STRING_ELT(names, k, COPY_TO_USER_STRING("names")); SET_VECTOR_ELT(ret, k, alloc_term_labels(&tm.terms)); k++; SET_STRING_ELT(names, k, COPY_TO_USER_STRING("perm")); SET_VECTOR_ELT(ret, k, alloc_terms_permute(&tm.terms, &r, &d)); k++; SET_STRING_ELT(names, k, COPY_TO_USER_STRING("score")); SET_VECTOR_ELT(ret, k, alloc_score(ll)); k++; SET_STRING_ELT(names, k, COPY_TO_USER_STRING("imat")); SET_VECTOR_ELT(ret, k, alloc_imat(&fit)); k++; UNPROTECT(2); fit_fail: recv_fit_deinit(&fit); terms_fail: design2_deinit(&d); design_deinit(&r); design_deinit(&s); xhistory_fail: history_deinit(&hx); yhistory_fail: history_deinit(&hy); properties_fail: return ret; }
void save_properties(GtkWidget *widget, FileProps *props) { get_properties(props, props->current); }