static void format_line(void *ptr, int level, const char *fmt, va_list vl, AVBPrint part[3], int *print_prefix, int type[2]) { AVClass* avc = ptr ? *(AVClass **) ptr : NULL; av_bprint_init(part+0, 0, 1); av_bprint_init(part+1, 0, 1); av_bprint_init(part+2, 0, 65536); if(type) type[0] = type[1] = AV_CLASS_CATEGORY_NA + 16; if (*print_prefix && avc) { if (avc->parent_log_context_offset) { AVClass** parent = *(AVClass ***) (((uint8_t *) ptr) + avc->parent_log_context_offset); if (parent && *parent) { av_bprintf(part+0, "[%s @ %p] ", (*parent)->item_name(parent), parent); if(type) type[0] = get_category(parent); } } av_bprintf(part+1, "[%s @ %p] ", avc->item_name(ptr), ptr); if(type) type[1] = get_category(ptr); } av_vbprintf(part+2, fmt, vl); if(*part[0].str || *part[1].str || *part[2].str) { char lastc = part[2].len ? part[2].str[part[2].len - 1] : 0; *print_prefix = lastc == '\n' || lastc == '\r'; } }
static void format_line(void *ptr, int level, const char *fmt, va_list vl, char part[3][LINE_SZ], int part_size, int *print_prefix, int type[2]) { AVClass* avc = ptr ? *(AVClass **) ptr : NULL; part[0][0] = part[1][0] = part[2][0] = 0; if(type) type[0] = type[1] = AV_CLASS_CATEGORY_NA + 16; if (*print_prefix && avc) { if (avc->parent_log_context_offset) { AVClass** parent = *(AVClass ***) (((uint8_t *) ptr) + avc->parent_log_context_offset); if (parent && *parent) { snprintf(part[0], part_size, "[%s @ %p] ", (*parent)->item_name(parent), parent); if(type) type[0] = get_category(parent); } } snprintf(part[1], part_size, "[%s @ %p] ", avc->item_name(ptr), ptr); if(type) type[1] = get_category(ptr); } vsnprintf(part[2], part_size, fmt, vl); if(*part[0] || *part[1] || *part[2]) { char lastc = strlen(part[2]) ? part[2][strlen(part[2]) - 1] : 0; *print_prefix = lastc == '\n' || lastc == '\r'; } }
int main(int argc, char* argv []) { boost::log::add_file_log("cli.log"); boost::log::core::get()->set_filter( xiv::utils::log::severity_level >= xiv::utils::log::Severity::trace ); auto game_data = xiv::dat::GameData("G:/SquareEnix/FINAL FANTASY XIV - A Realm Reborn/game/sqpack/ffxiv/"); if (false) { for (auto cat_nb : game_data.get_cat_nbs()) { auto& cat = game_data.get_category(cat_nb); for (auto& hash_table_entry : cat.get_index().get_hash_table()) { for (auto& dir_hash_table_entry : hash_table_entry.second) { auto file = cat.get_file(hash_table_entry.first, dir_hash_table_entry.first); if (file->get_type() == xiv::dat::FileType::model) { //xiv::mdl::Model aModel(game_data, *file); } } } } } else if (true) { search_models(game_data); } else if (true) { std::string model_strings [] = { "chara/equipment/e0044/model/c0101e0044_top.mdl" }; for (auto& model_string : model_strings) { xiv::mdl::Model aModel(game_data, model_string); aModel.export_as_json("G:/projects/output_mv"); } } else { std::string file_strings [] = { "chara/monster/m0096/obj/body/b0001/material/v0001/mt_m0096b0001_b.mtrl" }; for (auto& file_string : file_strings) { auto file = game_data.get_file(file_string); file->export_as_bin("G:/test.bin"); } } return 0; }
const char * category_name(void) { switch (get_category()) { case T_CHARMAP: return ("CHARMAP"); case T_WIDTH: return ("WIDTH"); case T_COLLATE: return ("LC_COLLATE"); case T_CTYPE: return ("LC_CTYPE"); case T_MESSAGES: return ("LC_MESSAGES"); case T_MONETARY: return ("LC_MONETARY"); case T_NUMERIC: return ("LC_NUMERIC"); case T_TIME: return ("LC_TIME"); default: INTERR; return (NULL); } }
bool auth_attr_addr::deserialize_body(NetMsg &msg, coding_t coding, uint16 body_length, IEErrorList &err, uint32 &bytes_read, bool skip) { uint32 start_pos = msg.get_pos(); // Error: Message is shorter than the length field makes us believe. if ( msg.get_bytes_left() < body_length ) { catch_bad_alloc( err.put(new IEMsgTooShort(coding, category, start_pos)) ); msg.set_pos(start_pos); return false; } if(sub_type==IPV4_ADDRESS){ struct in_addr tmp_ip; msg.decode(tmp_ip); ip.set_ip(tmp_ip); bytes_read = 4; }else{ struct in6_addr tmp_ip; msg.decode(tmp_ip); ip.set_ip(tmp_ip); bytes_read = 16; } // Error: We expected the length field to be different. if ( (body_length + HEADER_LENGTH) !=(uint32) get_serialized_size_nopadding(coding) || body_length!= bytes_read) { catch_bad_alloc( err.put( new IEWrongLength(coding, get_category(), get_xtype(), get_subtype(), msg.get_pos())) ); msg.set_pos(start_pos); return false; } return true; }
//categorize images using nearest centroid and generate confusion table void LocalDescriptorAndBagOfFeature::test_category(std::vector<Histogram> &feature_vectors, std::vector<double> &confusion_table, std::vector<std::string> &category_labels, std::vector<std::vector<double>> &category_centroids){ for(Histogram &feature_vector : feature_vectors){ int cat = get_category(feature_vector, category_centroids); //std::cout << "image " << i << " of " << bikes.size() << ": " << cat << "-" << category_labels[cat] << std::endl; confusion_table[cat]++; } }
static PyObject * warnings_warn_impl(PyObject *module, PyObject *message, PyObject *category, Py_ssize_t stacklevel, PyObject *source) /*[clinic end generated code: output=31ed5ab7d8d760b2 input=bfdf5cf99f6c4edd]*/ { category = get_category(message, category); if (category == NULL) return NULL; return do_warn(message, category, stacklevel, source); }
static PyObject * warnings_warn(PyObject *self, PyObject *args, PyObject *kwds) { static char *kw_list[] = { "message", "category", "stacklevel", 0 }; PyObject *message, *category = NULL; Py_ssize_t stack_level = 1; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|On:warn", kw_list, &message, &category, &stack_level)) return NULL; category = get_category(message, category); if (category == NULL) return NULL; return do_warn(message, category, stack_level); }
void send_to_downstream(Node *store, int sock_fd, BankConfig config) { pthread_mutex_lock(&sending_lock); PointerContainer *head = NULL, *temp = NULL; head = withdraw(store, config.bank_max_msg_length); int i = 0; int l = 0; int hash = 0; while (head != NULL ) { temp = head; head = head->next; l = strlen((char*) (temp->contained)); log_debug("Send %d char! %s", l, (char*) (temp->contained)); if (config._downstream_consistent_hashing == 0) { for (i = 0; i < config.destiny_host_count; i++) { if (config.downstream_sockaddr[i] != NULL && (config._destiny_health_check == 0 || config.downstream_error_count[i] <= DOWN_STREAM_ERROR_THRESHOLD)) { sendto(sock_fd, (char*) (temp->contained), l, 0, (struct sockaddr *) (config.downstream_sockaddr[i]), config.sockaddr_len); } } } else { hash = (int) get_hash(temp->label, strlen(temp->label), config.downstream_hash_ring_length); i = get_category(hash, config.downstream_hash_ring, config.downstream_error_count, DOWN_STREAM_ERROR_THRESHOLD, config.destiny_host_count, config.downstream_consistent_hash_replica); log_debug("Consistent hashing shows we send it to %d.", i); if (i < 0) { log_warning("No downstream end-point is available."); continue; } if (config.downstream_sockaddr[i] != NULL ) { sendto(sock_fd, (char*) (temp->contained), l, 0, (struct sockaddr *) (config.downstream_sockaddr[i]), config.sockaddr_len); } } free((char*) (temp->contained)); delete_container(&temp); } pthread_mutex_unlock(&sending_lock); }
static int intl_ctl(ErlDrvData drv_data, unsigned int command, char *buf, int len, char **rbuf, int rlen) { void* d = (void*)drv_data; char* aptr = buf; int alen = len; char* str1; char* str2; char* str3; int int1; int int2; unsigned int uint1; switch(command) { case INTL_GETTEXT: /* arguments: string msgid */ if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(gettext(str1), rbuf, rlen); case INTL_NGETTEXT: /* arguments: string msgid, string msgid_plural, int n */ if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str2) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_uinteger(&aptr, &alen, &uint1) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(ngettext(str1,str2,uint1), rbuf, rlen); case INTL_DGETTEXT: /* arguments: string domain, string msgid */ if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str2) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(dgettext(str1,str2), rbuf, rlen); case INTL_DNGETTEXT: /* arguments: string domain, string msgid, string msgid_plural, integer n */ if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str2) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str3) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_uinteger(&aptr, &alen, &uint1) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(dngettext(str1,str2,str3,uint1), rbuf, rlen); case INTL_DCGETTEXT: /* arguments: string domain, string msgid, int category */ if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str2) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_integer(&aptr,&alen, &int1) < 0) return ret_code(EINVAL, rbuf, rlen); if ((int1 = get_category(int1)) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(dcgettext(str1,str2,int1),rbuf,rlen); case INTL_DCNGETTEXT: /* arguments: string domain, string msgid, strinf msgid_plural, unsigned n, int category */ if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str2) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str3) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_uinteger(&aptr,&alen, &uint1) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_integer(&aptr,&alen, &int1) < 0) return ret_code(EINVAL, rbuf, rlen); if ((int1 = get_category(int1)) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(dcngettext(str1,str2,str3,uint1,int1),rbuf,rlen); case INTL_TEXTDOMAIN: /* arguments: string domainname */ if (len == 0) return ret_string(textdomain(NULL), rbuf, rlen); if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(textdomain(str1), rbuf, rlen); case INTL_BINDTEXTDOMAIN: /* arguments: string domainname, string dirname */ if (len == 0) return ret_string(textdomain(NULL), rbuf, rlen); if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str2) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(bindtextdomain(str1,str2), rbuf, rlen); case INTL_BIND_TEXTDOMAIN_CODESET: /* arguments: string domainname, string dirname */ if (len == 0) return ret_string(textdomain(NULL), rbuf, rlen); if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str2) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(bind_textdomain_codeset(str1,str2), rbuf, rlen); case INTL_SETLOCALE: if (get_integer(&aptr,&alen, &int1) < 0) return ret_code(EINVAL, rbuf, rlen); if ((int1 = get_category(int1)) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(setlocale(int1,str1), rbuf, rlen); } return -1; }
long pdf_defineresource (const char *category, const char *resname, pdf_obj *object, int flags) { int res_id; struct res_cache *rc; int cat_id; pdf_res *res = NULL; ASSERT(category && object); cat_id = get_category(category); if (cat_id < 0) { ERROR("Unknown resource category: %s", category); return -1; } rc = &resources[cat_id]; if (resname) { for (res_id = 0; res_id < rc->count; res_id++) { res = &rc->resources[res_id]; if (!strcmp(resname, res->ident)) { WARN("Resource %s (category: %s) already defined...", resname, category); pdf_flush_resource(res); res->flags = flags; if (flags & PDF_RES_FLUSH_IMMEDIATE) { res->reference = pdf_ref_obj(object); pdf_release_obj(object); } else { res->object = object; } return (long) ((cat_id << 16)|(res_id)); } } } else { res_id = rc->count; } if (res_id == rc->count) { if (rc->count >= rc->capacity) { rc->capacity += CACHE_ALLOC_SIZE; rc->resources = RENEW(rc->resources, rc->capacity, pdf_res); } res = &rc->resources[res_id]; pdf_init_resource(res); if (resname && resname[0] != '\0') { res->ident = NEW(strlen(resname) + 1, char); strcpy(res->ident, resname); } res->category = cat_id; res->flags = flags; if (flags & PDF_RES_FLUSH_IMMEDIATE) { res->reference = pdf_ref_obj(object); pdf_release_obj(object); } else { res->object = object; } rc->count++; }
/// create an error code with the given value and the asio transport category inline lib::error_code make_error_code(error::value e) { return lib::error_code(static_cast<int>(e), get_category()); }
void SingleAvroFile::initialize_categories() { for (std::map<std::string, std::vector<RMF_avro_backend::Data > >::const_iterator it = all_.category.begin(); it != all_.category.end(); ++it) { get_category(it->first); } }
// make json formated description void Property::make_description() { if (nullptr == property_) { g_warning("%s: cannot make description from a nullptr property", __PRETTY_FUNCTION__); return; } GValue value = G_VALUE_INIT; g_value_init(&value, property_->value_type); g_object_get_property(object_, property_->name, &value); json_description_->reset(); json_description_->begin_object(); // long name json_description_->add_string_member("name", long_name_.c_str()); // name json_description_->add_string_member("id", name_.c_str()); // nickname // json_description_->add_string_member ("nickname", g_param_spec_get_nick (property_)); // short description json_description_->add_string_member("description", g_param_spec_get_blurb(property_)); json_description_->add_string_member("parent", get_category().c_str()); json_description_->add_int_member("order", get_position_weight()); // name // json_description_->add_string_member ("internal name", g_param_spec_get_name (property_)); if (property_->flags &G_PARAM_WRITABLE) json_description_->add_string_member("writable", "true"); else json_description_->add_string_member("writable", "false"); switch (G_VALUE_TYPE(&value)) { case G_TYPE_STRING: { const char *string_val = g_value_get_string(&value); json_description_->add_string_member("type", "string"); if (string_val == nullptr) json_description_->add_string_member("default value", ""); else json_description_->add_string_member("default value", string_val); break; } case G_TYPE_BOOLEAN: { gboolean bool_val = g_value_get_boolean(&value); json_description_->add_string_member("type", "boolean"); if (bool_val) json_description_->add_string_member("default value", "true"); else json_description_->add_string_member("default value", "false"); break; } case G_TYPE_ULONG: { GParamSpecULong *pulong = G_PARAM_SPEC_ULONG(property_); json_description_->add_string_member("type", "ulong"); gchar *min = g_strdup_printf("%lu", pulong->minimum); gchar *max = g_strdup_printf("%lu", pulong->maximum); gchar *default_value = g_strdup_printf("%lu", g_value_get_ulong(&value)); json_description_->add_string_member("minimum", min); json_description_->add_string_member("maximum", max); json_description_->add_string_member("default value", default_value); g_free(min); g_free(max); g_free(default_value); break; } case G_TYPE_LONG: { GParamSpecLong *plong = G_PARAM_SPEC_LONG(property_); gchar *min = g_strdup_printf("%ld", plong->minimum); gchar *max = g_strdup_printf("%ld", plong->maximum); gchar *default_value = g_strdup_printf("%ld", g_value_get_ulong(&value)); json_description_->add_string_member("type", "long"); json_description_->add_string_member("minimum", min); json_description_->add_string_member("maximum", max); json_description_->add_string_member("default value", default_value); g_free(min); g_free(max); g_free(default_value); break; } case G_TYPE_UINT: { GParamSpecUInt *puint = G_PARAM_SPEC_UINT(property_); gchar *min = g_strdup_printf("%u", puint->minimum); gchar *max = g_strdup_printf("%u", puint->maximum); gchar *default_value = g_strdup_printf("%u", g_value_get_uint(&value)); json_description_->add_string_member("type", "uint"); json_description_->add_string_member("minimum", min); json_description_->add_string_member("maximum", max); json_description_->add_string_member("default value", default_value); g_free(min); g_free(max); g_free(default_value); break; } case G_TYPE_INT: { GParamSpecInt *pint = G_PARAM_SPEC_INT(property_); gchar *min = g_strdup_printf("%d", pint->minimum); gchar *max = g_strdup_printf("%d", pint->maximum); gchar *default_value = g_strdup_printf("%d", g_value_get_int(&value)); json_description_->add_string_member("type", "int"); json_description_->add_string_member("minimum", min); json_description_->add_string_member("maximum", max); json_description_->add_string_member("default value", default_value); g_free(min); g_free(max); g_free(default_value); break; } case G_TYPE_UINT64: { GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64(property_); gchar *min = g_strdup_printf("%" G_GUINT64_FORMAT, puint64->minimum); gchar *max = g_strdup_printf("%" G_GUINT64_FORMAT, puint64->maximum); gchar *default_value = g_strdup_printf("%" G_GUINT64_FORMAT, g_value_get_uint64(&value)); json_description_->add_string_member("type", "uint64"); json_description_->add_string_member("minimum", min); json_description_->add_string_member("maximum", max); json_description_->add_string_member("default value", default_value); g_free(min); g_free(max); g_free(default_value); break; } case G_TYPE_INT64: { GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64(property_); gchar *min = g_strdup_printf("%" G_GINT64_FORMAT, pint64->minimum); gchar *max = g_strdup_printf("%" G_GINT64_FORMAT, pint64->maximum); gchar *default_value = g_strdup_printf("%" G_GINT64_FORMAT, g_value_get_int64(&value)); json_description_->add_string_member("type", "int64"); json_description_->add_string_member("minimum", min); json_description_->add_string_member("maximum", max); json_description_->add_string_member("default value", default_value); g_free(min); g_free(max); g_free(default_value); break; } case G_TYPE_FLOAT: { GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT(property_); gchar *min = g_strdup_printf("%.7g", pfloat->minimum); gchar *max = g_strdup_printf("%.7g", pfloat->maximum); gchar *default_value = g_strdup_printf("%.7g", g_value_get_float(&value)); json_description_->add_string_member("type", "float"); json_description_->add_string_member("minimum", min); json_description_->add_string_member("maximum", max); json_description_->add_string_member("default value", default_value); g_free(min); g_free(max); g_free(default_value); break; } case G_TYPE_DOUBLE: { GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE(property_); gchar *min = g_strdup_printf("%.7g", pdouble->minimum); gchar *max = g_strdup_printf("%.7g", pdouble->maximum); gchar *default_value = g_strdup_printf("%.7g", g_value_get_double(&value)); json_description_->add_string_member("type", "double"); json_description_->add_string_member("minimum", min); json_description_->add_string_member("maximum", max); json_description_->add_string_member("default value", default_value); g_free(min); g_free(max); g_free(default_value); break; } default: if (property_->value_type == GST_TYPE_CAPS) { const GstCaps *caps = gst_value_get_caps(&value); json_description_->add_string_member("type", "caps"); if (!caps) json_description_->add_string_member("default value", ""); else json_description_->add_string_member("default value", gst_caps_to_string(caps)); } else if (G_IS_PARAM_SPEC_ENUM(property_)) { GEnumValue *values; guint j = 0; gint enum_value; const gchar *value_nick = ""; const gchar *value_name = ""; json_description_->add_string_member("type", "enum"); values = G_ENUM_CLASS(g_type_class_ref(property_->value_type))->values; enum_value = g_value_get_enum(&value); while (values[j].value_name) { if (values[j].value == enum_value) { value_nick = values[j].value_nick; value_name = values[j].value_name; } j++; } json_description_->set_member_name("default value"); json_description_->begin_object(); gchar *value = g_strdup_printf("%d", enum_value); json_description_->add_string_member("value", value); g_free(value); json_description_->add_string_member("nick", value_nick); json_description_->add_string_member("name", value_name); json_description_->end_object(); // g_debug ("Enum \"%s\" Default: %d, \"%s\" \"%s\"", // g_type_name (G_VALUE_TYPE (&value)), // enum_value, // value_nick, // value_name); j = 0; json_description_->set_member_name("values"); json_description_->begin_array(); while (values[j].value_name) { json_description_->begin_object(); json_description_->add_string_member("name", values[j].value_name); json_description_->add_string_member("nick", values[j].value_nick); gchar *values_value = g_strdup_printf("%d", values[j].value); json_description_->add_string_member("value", values_value); g_free(values_value); json_description_->end_object(); j++; } json_description_->end_array(); /* g_type_class_unref (ec); */ } else if (G_IS_PARAM_SPEC_FLAGS(property_)) { g_debug("warning: param spec flags not handled"); // GParamSpecFlags *pflags = G_PARAM_SPEC_FLAGS (property_); // GFlagsValue *vals; // gchar *cur; // vals = pflags->flags_class->values; // cur = flags_to_string (vals, g_value_get_flags (&value)); // g_debug ("%-23.23s Flags \"%s\" Default: 0x%08x, \"%s\"", "", // g_type_name (G_VALUE_TYPE (&value)), // g_value_get_flags (&value), cur); // while (vals[0].value_name) { // g_debug (""); // if (_name) // g_debug ("%s", _name); // g_debug ("%-23.23s (0x%08x): %-16s - %s", "", // vals[0].value, vals[0].value_nick, vals[0].value_name); // ++vals; // } // g_free (cur); } else if (G_IS_PARAM_SPEC_OBJECT(property_)) { g_debug("warning: param spec object not handled"); // g_debug ("%-23.23s Object of type \"%s\"", "", // g_type_name (property_->value_type)); } else if (G_IS_PARAM_SPEC_BOXED(property_)) { g_debug("warning: param spec boxed not handled"); // g_debug ("%-23.23s Boxed pointer of type \"%s\"", "", // g_type_name (property_->value_type)); } else if (G_IS_PARAM_SPEC_POINTER(property_)) { g_debug("warning: param spec pointer not handled"); // if (property_->value_type != G_TYPE_POINTER) { // g_debug ("%-23.23s Pointer of type \"%s\".", "", // g_type_name (property_->value_type)); // } else if (property_->value_type == G_TYPE_VALUE_ARRAY) { // GParamSpecValueArray *pvarray = G_PARAM_SPEC_VALUE_ARRAY (property_); // g_debug ("warning: array not handled"); // if (pvarray->element_spec) { // g_debug ("%-23.23s Array of GValues of type \"%s\"", "", // g_type_name (pvarray->element_spec->value_type)); // } else { // g_debug ("%-23.23s Array of GValues", ""); // } } else if (GST_IS_PARAM_SPEC_FRACTION(property_)) { GstParamSpecFraction *pfraction = GST_PARAM_SPEC_FRACTION(property_); json_description_->add_string_member("type", "fraction"); gchar *minnum = g_strdup_printf("%d", pfraction->min_num); gchar *minden = g_strdup_printf("%d", pfraction->min_den); gchar *maxnum = g_strdup_printf("%d", pfraction->max_num); gchar *maxden = g_strdup_printf("%d", pfraction->max_den); gchar *defaultnum = g_strdup_printf("%d", gst_value_get_fraction_numerator (&value)); gchar *defaultden = g_strdup_printf("%d", gst_value_get_fraction_denominator (&value)); json_description_->add_string_member("minimum numerator", minnum); json_description_->add_string_member("maximum numerator", minden); json_description_->add_string_member("minimum denominator", maxnum); json_description_->add_string_member("maximum denominator", maxden); json_description_->add_string_member("default numerator", defaultnum); json_description_->add_string_member("default denominator", defaultden); g_free(minnum); g_free(minden); g_free(maxnum); g_free(maxden); g_free(defaultnum); g_free(defaultden); // g_debug ("Range: %d/%d - %d/%d Default: %d/%d ", // pfraction->min_num, pfraction->min_den, // pfraction->max_num, pfraction->max_den, // gst_value_get_fraction_numerator (&value), // gst_value_get_fraction_denominator (&value)); } else { g_warning("warning: unknown type"); // g_debug ("%-23.23s Unknown type %ld \"%s\"", "", property_->value_type, // g_type_name (property_->value_type)); } break; } g_value_reset(&value); json_description_->end_object(); }
void Item_factory::load_basic_info(JsonObject& jo, itype* new_item_template) { std::string new_id = jo.get_string("id"); new_item_template->id = new_id; if(m_templates.count(new_id) > 0) { // New item already exists. Because mods are loaded after // core data, we override it. This allows mods to change // item from core data. delete m_templates[new_id]; } m_templates[new_id] = new_item_template; itypes[new_id] = new_item_template; standard_itype_ids.push_back(new_id); // And then proceed to assign the correct field new_item_template->price = jo.get_int("price"); new_item_template->name = _(jo.get_string("name").c_str()); new_item_template->sym = jo.get_string("symbol")[0]; new_item_template->color = color_from_string(jo.get_string("color")); new_item_template->description = _(jo.get_string("description").c_str()); if(jo.has_member("material")){ set_material_from_json(jo, "material", new_item_template); } else { new_item_template->m1 = "null"; new_item_template->m2 = "null"; } Item_tag new_phase = "solid"; if(jo.has_member("phase")){ new_phase = jo.get_string("phase"); } new_item_template->phase = phase_from_tag(new_phase); new_item_template->volume = jo.get_int("volume"); new_item_template->weight = jo.get_int("weight"); new_item_template->melee_dam = jo.get_int("bashing"); new_item_template->melee_cut = jo.get_int("cutting"); new_item_template->m_to_hit = jo.get_int("to_hit"); new_item_template->light_emission = 0; /* List of current flags FIT - Reduces encumbrance by one SKINTIGHT - Reduces layer penalty VARSIZE - Can be made to fit via tailoring OVERSIZE - Can always be worn no matter encumbrance/mutations/bionics/etc POCKETS - Will increase warmth for hands if hands are cold and the player is wielding nothing HOOD - Will increase warmth for head if head is cold and player's head isn't encumbered RAINPROOF - Works like a raincoat to protect from rain effects WATCH - Shows the current time, instead of sun/moon position ALARMCLOCK - Has an alarmclock feature FANCY - Less than practical clothing meant primarily to convey a certain image. SUPER_FANCY - Clothing suitable for the most posh of events. LIGHT_* - light emission, sets cached int light_emission USE_EAT_VERB - Use the eat verb, even if it's a liquid(soup, jam etc.) STURDY - Clothing is made to be armor. Prevents damage to armor unless it is penetrated. SWIM_GOGGLES - Allows you to see much further under water. REBREATHER - Works with an active UPS to supply you with oxygen while underwater. Container-only flags: SEALS RIGID WATERTIGHT */ new_item_template->item_tags = jo.get_tags("flags"); if ( new_item_template->item_tags.size() > 0 ) { for( std::set<std::string>::const_iterator it = new_item_template->item_tags.begin(); it != new_item_template->item_tags.end(); ++it ) { set_intvar(std::string(*it), new_item_template->light_emission, 1, 10000); } } if( jo.has_member("qualities") ){ set_qualities_from_json(jo, "qualities", new_item_template); } new_item_template->techniques = jo.get_tags("techniques"); new_item_template->use = (!jo.has_member("use_action") ? &iuse::none : use_from_string(jo.get_string("use_action"))); if(jo.has_member("category")) { new_item_template->category = get_category(jo.get_string("category")); } else { new_item_template->category = get_category(calc_category(new_item_template)); } }