/* 判断janson的类型 */ int my_json_type(json_t *value) { if(json_is_object(value)) { printf("json_is_object\n"); return JSON_OBJECT; } if(json_is_array(value)) { printf("json_is_array\n"); return JSON_ARRAY; } if(json_is_string(value)) { printf("json_is_string\n"); return JSON_STRING; } if(json_is_integer(value)) { printf("json_is_integer\n"); return JSON_INTEGER; } if(json_is_real(value)) { printf("json_is_real\n"); return JSON_REAL; } if(json_is_number(value)) { printf("json_is_number\n"); } if(json_is_boolean(value)) { printf("json_is_boolean\n"); } if(json_is_null(value)) { printf("json_is_null\n"); return JSON_NULL; } if(json_is_true(value)) { printf("json_boolean(1)\n"); return JSON_TRUE; } if(json_is_false(value)) { printf("json_boolean(0)\n"); return JSON_FALSE; } }
static QList<QVariant> listFromJSON(json_t *array) { QList<QVariant> ret; size_t array_size = json_array_size(array); json_t *value; for(size_t index = 0; index < array_size && (value = json_array_get(array, index)); ++index) { /* block of code that uses index and value */ QVariant v; if (json_is_object(value)) { v = mapFromJSON(value, NULL); } else if (json_is_array(value)) { v = listFromJSON(value); } else if (json_is_string(value)) { v = QString::fromUtf8(json_string_value(value)); } else if (json_is_integer(value)) { v = json_integer_value(value); } else if (json_is_real(value)) { v = json_real_value(value); } else if (json_is_boolean(value)) { v = json_is_true(value); } if (v.isValid()) { ret.push_back(v); } } return ret; }
tABC_CC ABC_LoginServerOtpStatus(const Lobby &lobby, tABC_U08Buf LP1, bool *on, long *timeout, tABC_Error *pError) { tABC_CC cc = ABC_CC_Ok; json_t *pJSON_Value = NULL; JsonPtr reply; std::string url = ABC_SERVER_ROOT "/otp/status"; ABC_CHECK_RET(ABC_LoginServerOtpRequest(url.c_str(), lobby, LP1, &reply, pError)); pJSON_Value = json_object_get(reply.get(), ABC_SERVER_JSON_OTP_ON); ABC_CHECK_ASSERT((pJSON_Value && json_is_boolean(pJSON_Value)), ABC_CC_JSONError, "Error otp/on JSON"); *on = json_is_true(pJSON_Value); if (*on) { pJSON_Value = json_object_get(reply.get(), ABC_SERVER_JSON_OTP_TIMEOUT); ABC_CHECK_ASSERT((pJSON_Value && json_is_integer(pJSON_Value)), ABC_CC_JSONError, "Error otp/timeout JSON"); *timeout = json_integer_value(pJSON_Value); } exit: return cc; }
static kbool_t GetJsonBoolean(KonohaContext *kctx, struct JsonBuf *jsonbuf, const char *key, size_t keylen_or_zero, kbool_t defval) { json_t* obj = (key != NULL) ? json_object_get(jsonbuf->jsonobj, key) : jsonbuf->jsonobj; if(json_is_boolean(obj)) { return (kbool_t)json_is_true(obj); } return defval; }
static inline bool get_bool_val(json_t *service, const char *key) { json_t *bool_val = json_object_get(service, key); if (!bool_val || !json_is_boolean(bool_val)) return false; return json_is_true(bool_val); }
// Compute the effective value of the root_files configuration and // return a json reference. The caller must decref the ref when done // (we may synthesize this value). Sets enforcing to indicate whether // we will only allow watches on the root_files. // The array returned by this function (if not NULL) is guaranteed to // list .watchmanconfig as its zeroth element. json_t *cfg_compute_root_files(bool *enforcing) { json_t *ref; // This is completely undocumented and will go away soon. Do not document or // use! bool ignore_watchmanconfig = cfg_get_bool(NULL, "_ignore_watchmanconfig", false); *enforcing = false; ref = cfg_get_json(NULL, "enforce_root_files"); if (ref) { if (!json_is_boolean(ref)) { w_log(W_LOG_FATAL, "Expected config value enforce_root_files to be boolean\n"); } *enforcing = json_is_true(ref); } ref = cfg_get_json(NULL, "root_files"); if (ref) { if (!is_array_of_strings(ref)) { w_log(W_LOG_FATAL, "global config root_files must be an array of strings\n"); *enforcing = false; return NULL; } prepend_watchmanconfig_to_array(ref); json_incref(ref); return ref; } // Try legacy root_restrict_files configuration ref = cfg_get_json(NULL, "root_restrict_files"); if (ref) { if (!is_array_of_strings(ref)) { w_log(W_LOG_FATAL, "deprecated global config root_restrict_files " "must be an array of strings\n"); *enforcing = false; return NULL; } if (!ignore_watchmanconfig) { prepend_watchmanconfig_to_array(ref); } json_incref(ref); *enforcing = true; return ref; } // Synthesize our conservative default value. // .watchmanconfig MUST be first if (!ignore_watchmanconfig) { return json_pack("[ssss]", ".watchmanconfig", ".hg", ".git", ".svn"); } else { return json_pack("[sss]", ".hg", ".git", ".svn"); } }
Value NDKHelper::getValueFromJson(json_t *obj) { if (obj == NULL) { return Value::Null; } if (json_is_object(obj)) { ValueMap valueMap; const char *key; json_t *value; void *iter = json_object_iter(obj); while (iter) { key = json_object_iter_key(iter); value = json_object_iter_value(iter); valueMap[key] = NDKHelper::getValueFromJson(value); iter = json_object_iter_next(obj, iter); } return Value(valueMap); } else if (json_is_array(obj)) { ValueVector valueVector; size_t sizeArray = json_array_size(obj); for (unsigned int i = 0; i < sizeArray; i++) { valueVector.push_back(NDKHelper::getValueFromJson(json_array_get(obj, i))); } return Value(valueVector); } else if (json_is_boolean(obj)) { if (json_is_true(obj)) { return Value(true); } else { return Value(false); } } else if (json_is_integer(obj)) { int value = (int) json_integer_value(obj); return Value(value); } else if (json_is_real(obj)) { double value = json_real_value(obj); return Value(value); } else if (json_is_string(obj)) { std::string value = json_string_value(obj); return Value(value); } return Value::Null; }
bool json_get_bool_key(const json_t* obj, const char* key) { json_t* value = json_object_get(obj, key); if (value == NULL) { fprintf(stderr, "error: missing required \"%s\" key\n", key); exit(1); } if (!json_is_boolean(value)) { fprintf(stderr, "error: \"%s\" key must be a boolean, got %s\n", key, json_strof(value)); exit(1); } return json_is_true(value); }
int jansson_to_val(pv_value_t* val, char** freeme, json_t* v) { val->flags = 0; if(json_is_object(v) || json_is_array(v)) { const char* value = json_dumps(v, JSON_COMPACT|JSON_PRESERVE_ORDER); *freeme = (char*)value; val->rs.s = (char*)value; val->rs.len = strlen(value); val->flags = PV_VAL_STR; }else if(json_is_string(v)) { const char* value = json_string_value(v); val->rs.s = (char*)value; val->rs.len = strlen(value); val->flags = PV_VAL_STR; }else if(json_is_boolean(v)) { val->ri = json_is_true(v) ? 0 : 1; val->flags = PV_TYPE_INT|PV_VAL_INT; }else if(json_is_real(v)) { char* value = NULL; if(asprintf(&value, "%.15g", json_real_value(v))<0) { ERR("asprintf failed\n"); return -1; } *freeme = value; val->rs.s = value; val->rs.len = strlen(value); val->flags = PV_VAL_STR; }else if(json_is_integer(v)) { long long value = json_integer_value(v); if ((value > INT_MAX) || (value < INT_MIN)) { char* svalue = NULL; if (asprintf(&svalue, "%"JSON_INTEGER_FORMAT, value) < 0) { ERR("asprintf failed\n"); return -1; } *freeme = svalue; val->rs.s = svalue; val->rs.len = strlen(svalue); val->flags = PV_VAL_STR; } else { val->ri = (int)value; val->flags = PV_TYPE_INT|PV_VAL_INT; } }else if(json_is_null(v)) { val->flags = PV_VAL_NULL; }else { ERR("unrecognized json type: %d\n", json_typeof(v)); return -1; } return 0; }
Status loginServerOtpPending(std::list<DataChunk> users, std::list<bool> &isPending) { const auto url = ABC_SERVER_ROOT "/v1/otp/pending/check"; std::string param; std::map<std::string, bool> userMap; std::list<std::string> usersEncoded; for (const auto &u : users) { std::string username = base64Encode(u); param += (username + ","); userMap[username] = false; usersEncoded.push_back(username); } JsonObject json; ABC_CHECK(json.set("l1s", param)); HttpReply reply; ABC_CHECK(AirbitzRequest().post(reply, url, json.encode())); ServerReplyJson replyJson; ABC_CHECK(replyJson.decode(reply)); JsonArray arrayJson = replyJson.results(); size_t size = arrayJson.size(); for (size_t i = 0; i < size; i++) { json_t *pJSON_Row = arrayJson[i].get(); if (!pJSON_Row || !json_is_object(pJSON_Row)) return ABC_ERROR(ABC_CC_JSONError, "Error parsing JSON array element object"); json_t *pJSON_Value = json_object_get(pJSON_Row, "login"); if (!pJSON_Value || !json_is_string(pJSON_Value)) return ABC_ERROR(ABC_CC_JSONError, "Error otp/pending/login JSON"); std::string username(json_string_value(pJSON_Value)); pJSON_Value = json_object_get(pJSON_Row, ABC_SERVER_JSON_OTP_PENDING); if (!pJSON_Value || !json_is_boolean(pJSON_Value)) return ABC_ERROR(ABC_CC_JSONError, "Error otp/pending/pending JSON"); if (json_is_true(pJSON_Value)) { userMap[username] = json_is_true(pJSON_Value); } } isPending.clear(); for (auto &username: usersEncoded) { isPending.push_back(userMap[username]); } return Status(); }
bool cfg_get_bool(w_root_t *root, const char *name, bool defval) { json_t *val = cfg_get_json(root, name); if (val) { if (!json_is_boolean(val)) { w_log(W_LOG_FATAL, "Expected config value %s to be a boolean\n", name); } return json_is_true(val); } return defval; }
json_t* OBSAPIMessageHandler::HandleSetVolume(OBSAPIMessageHandler* handler, json_t* message) { json_t* channel = json_object_get(message, "channel"); json_t* volume = json_object_get(message, "volume"); json_t* finalValue = json_object_get(message, "final"); if(volume == NULL) { return GetErrorResponse("Volume not specified."); } if(!json_is_number(volume)) { return GetErrorResponse("Volume not number."); } float val = (float) json_number_value(volume); val = min(1.0f, max(0.0f, val)); if(finalValue == NULL) { return GetErrorResponse("Final not specified."); } if(!json_is_boolean(finalValue)) { return GetErrorResponse("Final is not a boolean."); } if(channel != NULL && json_typeof(channel) == JSON_STRING) { const char* channelVal = json_string_value(channel); if(stricmp(channelVal, "desktop") == 0) { OBSSetDesktopVolume(val, json_is_true(finalValue)); } else if(stricmp(channelVal, "microphone") == 0) { OBSSetMicVolume(val, json_is_true(finalValue)); } else { return GetErrorResponse("Invalid channel specified."); } } else { return GetErrorResponse("Channel not specified."); } return GetOkResponse(); }
static kbool_t IsJsonType(struct JsonBuf *jsonbuf, KJSONTYPE type) { switch(type) { case KJSON_OBJECT: return json_is_object(jsonbuf->jsonobj); case KJSON_ARRAY: return json_is_array(jsonbuf->jsonobj); case KJSON_STRING: return json_is_string(jsonbuf->jsonobj); case KJSON_INT: return json_is_integer(jsonbuf->jsonobj); case KJSON_DOUBLE: return json_is_real(jsonbuf->jsonobj); case KJSON_BOOLEAN: return json_is_boolean(jsonbuf->jsonobj); case KJSON_NULL: return json_is_null(jsonbuf->jsonobj); case KJSON_INT64: return json_is_integer(jsonbuf->jsonobj); case KJSON_LONG: return json_is_integer(jsonbuf->jsonobj); } return false; }
bool JSON::getArrayBoolean(int index) { if (!isArray()) { return false; } json_t *jobject = json_array_get(_json, index); if (!jobject || !json_is_boolean(jobject)) { return false; } return json_is_true(jobject); }
bool JSON::getBoolean(const char *key) { if (!_json) { return false; } json_t *jbool = json_object_get(_json, key); if (!jbool || !json_is_boolean(jbool)) { return false; } return json_is_true(jbool); }
// Compute the effective value of the root_files configuration and // return a json reference. The caller must decref the ref when done // (we may synthesize this value). Sets enforcing to indicate whether // we will only allow watches on the root_files. // The array returned by this function (if not NULL) is guaranteed to // list .watchmanconfig as its zeroth element. json_t *cfg_compute_root_files(bool *enforcing) { json_t *ref; *enforcing = false; ref = cfg_get_json(NULL, "enforce_root_files"); if (ref) { if (!json_is_boolean(ref)) { w_log(W_LOG_FATAL, "Expected config value enforce_root_files to be boolean\n"); } *enforcing = json_is_true(ref); } ref = cfg_get_json(NULL, "root_files"); if (ref) { if (!is_array_of_strings(ref)) { w_log(W_LOG_FATAL, "global config root_files must be an array of strings\n"); *enforcing = false; return NULL; } prepend_watchmanconfig_to_array(ref); json_incref(ref); return ref; } // Try legacy root_restrict_files configuration ref = cfg_get_json(NULL, "root_restrict_files"); if (ref) { if (!is_array_of_strings(ref)) { w_log(W_LOG_FATAL, "deprecated global config root_restrict_files " "must be an array of strings\n"); *enforcing = false; return NULL; } prepend_watchmanconfig_to_array(ref); json_incref(ref); *enforcing = true; return ref; } // Synthesize our conservative default value. // .watchmanconfig MUST be first return json_pack("[ssss]", ".watchmanconfig", ".hg", ".git", ".svn"); }
int read_cfg_bool(json_t *root, const char *key, bool *val, bool required, bool default_val) { json_t *node = json_object_get(root, key); if (!node) { if (required) { return -__LINE__; } else { *val = default_val; return 0; } } if (!json_is_boolean(node)) return -__LINE__; *val = json_boolean_value(node); return 0; }
static qeo_retcode_t object_add_member(const qeo_factory_t *factory, qeocore_type_t *type, const char *member_name, json_t *member) { qeo_retcode_t result = QEO_EFAIL; qeocore_type_t *qeoType = NULL; qeocore_member_id_t qeo_member_id = QEOCORE_MEMBER_ID_DEFAULT; json_t *member_key = json_object_get(member, KEY_KEY); // optional => BOOLEAN json_t *member_id = json_object_get(member, KEY_ID); // optional => INTxx assert(factory != NULL); if (((NULL != member_key) && !json_is_boolean(member_key)) || ((NULL != member_id) && !json_is_integer(member_id)) || (NULL == member_name)) { // syntax error return QEO_EINVAL; } qeo_log_d("Processing %s", member_name); qeoType = build_member_type(factory, member); if (NULL == qeoType) { qeo_log_e("Could not build member_type"); return result; } bool is_key = (member_key && json_is_true(member_key)); do { result = qeocore_type_struct_add(type, // container qeoType, // new member to add member_name, // name of member &qeo_member_id, // member id is_key ? QEOCORE_FLAG_KEY : 0); // flag if (QEO_OK != result) { qeo_log_e("qeocore_type_struct_add failed for member %s", member_name); break; } qeocore_type_free(qeoType); // Modify the json member to add/update the qeo member id json_object_set_new(member, KEY_ID, json_integer(qeo_member_id)); } while (0); return result; }
static int json_t_to_avro_value_helper( const avro_schema_t schema, const json_t *json, avro_datum_t datum) { switch (schema->type) { case AVRO_BOOLEAN: check_param(EINVAL, json_is_boolean(json), "JSON boolean"); if (avro_boolean_set(datum, json_is_true(json))) return EINVAL; return 0; case AVRO_DOUBLE: check_param(EINVAL, json_is_real(json), "JSON float"); if (avro_double_set(datum, json_real_value(json))) return EINVAL; return 0; case AVRO_FLOAT: check_param(EINVAL, json_is_real(json), "JSON float"); if (avro_float_set(datum, json_real_value(json))) return EINVAL; return 0; case AVRO_INT32: check_param(EINVAL, json_is_integer(json), "JSON integer"); if (avro_int32_set(datum, json_integer_value(json))) return EINVAL; return 0; case AVRO_INT64: check_param(EINVAL, json_is_integer(json), "JSON integer"); if (avro_int64_set(datum, json_integer_value(json))) return EINVAL; return 0; case AVRO_NULL: check_param(EINVAL, json_is_null(json), "JSON null"); return 0; case AVRO_STRING: { check_param(EINVAL, json_is_string(json), "JSON string"); if (avro_string_set(datum, json_string_value(json))) return EINVAL; return 0; } case AVRO_BYTES: case AVRO_ARRAY: case AVRO_ENUM: case AVRO_FIXED: case AVRO_MAP: case AVRO_RECORD: case AVRO_UNION: default: // TODO avro_set_error("json_t_to_avro_value: unimplemented type"); return EINVAL; } }
static cxConstChars jsonToConstChars(json_t *v) { CX_RETURN(v == NULL, NULL); cxConstChars str = NULL; v = jsonParseRegisterValue(v); if(json_is_string(v)){ str = json_string_value(v); }else if(json_is_integer(v)){ str = cxConstStr("%"JSON_INTEGER_FORMAT,json_integer_value(v)); }else if(json_is_real(v)){ str = cxConstStr("%f",json_real_value(v)); }else if(json_is_boolean(v)){ str = cxConstStr("%s",json_is_true(v)?"true":"false"); }else if(json_is_object(v)){ str = jsonStrConvert(v); } return str; }
QMap<QString, QVariant> mapFromJSON(json_t *json, json_error_t *error) { QMap<QString, QVariant> dict; void *member; const char *key; json_t *value; for (member = json_object_iter(json); member; member = json_object_iter_next(json, member)) { key = json_object_iter_key(member); value = json_object_iter_value(member); QString k = QString::fromUtf8(key); QVariant v; // json_is_object(const json_t *json) // json_is_array(const json_t *json) // json_is_string(const json_t *json) // json_is_integer(const json_t *json) // json_is_real(const json_t *json) // json_is_true(const json_t *json) // json_is_false(const json_t *json) // json_is_null(const json_t *json) if (json_is_object(value)) { v = mapFromJSON(json, NULL); } else if (json_is_array(value)) { v = listFromJSON(value); } else if (json_is_string(value)) { v = QString::fromUtf8(json_string_value(value)); } else if (json_is_integer(value)) { v = json_integer_value(value); } else if (json_is_real(value)) { v = json_real_value(value); } else if (json_is_boolean(value)) { v = json_is_true(value); } if (v.isValid()) { dict[k] = v; } } return dict; }
static inline int device_set_boolean(setter_boolean fn, struct Device *device, json_t *value, const char *context, struct MbDeviceJsonError *error) { int ret; if (!json_is_boolean(value)) { json_error_set_mismatched_type( error, context, value->type, JSON_BOOLEAN); return -1; } ret = fn(device, json_boolean_value(value)); if (ret < 0) { json_error_set_standard_error(error, ret); return -1; } return 0; }
static void cmd_debug_set_subscriptions_paused( struct watchman_client* clientbase, const json_ref& args) { auto client = (struct watchman_user_client*)clientbase; const auto& paused = args.at(1); auto& paused_map = paused.object(); for (auto& it : paused_map) { auto sub_iter = client->subscriptions.find(it.first); if (sub_iter == client->subscriptions.end()) { send_error_response( client, "this client does not have a subscription named '%s'", it.first.c_str()); return; } if (!json_is_boolean(it.second)) { send_error_response( client, "new value for subscription '%s' not a boolean", it.first.c_str()); return; } } auto states = json_object(); for (auto& it : paused_map) { auto sub_iter = client->subscriptions.find(it.first); bool old_paused = sub_iter->second->debug_paused; bool new_paused = json_is_true(it.second); sub_iter->second->debug_paused = new_paused; states.set( it.first, json_object({{"old", json_boolean(old_paused)}, {"new", it.second}})); } auto resp = make_response(); resp.set("paused", std::move(states)); send_and_dispose_response(clientbase, std::move(resp)); }
void Config::load(const char *path) { json_error_t error; json_t* json = json_load_file(path, 0, &error); this->useAuth = false; this->authHash = ""; this->authSalt = ""; if(!json) { /* didn't find config file, setup default password */ setAuth(true, OBS_REMOTE_DEFAULT_PASSWORD); save(path); return; } json_t* jUseAuth = json_object_get(json, "useAuth"); json_t* jAuthHash = json_object_get(json, "authHash"); json_t* jAuthSalt = json_object_get(json, "authSalt"); if(jUseAuth == NULL || !json_is_boolean(jUseAuth)) { return; } if(json_typeof(jUseAuth) == JSON_FALSE) { return; } if(jAuthHash == NULL || !json_is_string(jAuthHash) || jAuthSalt == NULL || !json_is_string(jAuthSalt)) { /* couldn't get auth parameters */ return; } this->useAuth = true; this->authHash = json_string_value(jAuthHash); this->authSalt = json_string_value(jAuthSalt); }
/** * Parse a boolean * * If the key does not exist in the src object, returns success but does fill in *dest. * * @param src JSON object to pull a value from * @param key key to pull * @param dest (output) pointer to an allocated integer * @return TR_CFG_SUCCESS or an error code */ static TR_CFG_RC tr_cfg_parse_boolean(json_t *src, const char *key, int *dest) { json_t *jtmp; /* Validate parameters */ if ((src == NULL) || (key == NULL) || (dest == NULL)) return TR_CFG_BAD_PARAMS; /* See if we have a value for this key; do nothing if not */ jtmp = json_object_get(src, key); if (jtmp) { if (json_is_boolean(jtmp)) { *dest = json_is_true(jtmp); } else { tr_debug("tr_cfg_parse_unsigned: Parsing error, %s is not a boolean.", key); return TR_CFG_NOPARSE; } } return TR_CFG_SUCCESS; }
json_t* OBSAPIMessageHandler::HandleSetSourceRender(OBSAPIMessageHandler *handler, json_t* message) { StringList sceneNames; json_t* source = json_object_get(message, "source"); if(source == NULL || json_typeof(source) != JSON_STRING) { return GetErrorResponse("No source specified"); } json_t* sourceRender = json_object_get(message, "render"); if(source == NULL || !json_is_boolean(sourceRender)) { return GetErrorResponse("No render specified"); } json_t* ret = GetOkResponse(); String sourceName = json_string_value(source); OBSSetSourceRender(sourceName.Array(), json_typeof(sourceRender) == JSON_TRUE); return ret; }
/** * Convert JSON object to PyObject * @param JSONObject * @return PyObject */ static PyObject* convert(json_t *json) { PyObject* object = NULL; json_t* val; int result = 0; if (json_is_object(json)) { object = PyDict_New(); char* key; json_object_foreach(json, key, val) { if (json_is_object(val) || json_is_array(val)) { result = PyDict_SetItemString(object, key, convert(val)); } else if(json_is_string(val)) { const char *str = json_string_value(val); result = PyDict_SetItemString(object, key, PyString_DecodeEscape(str, str ? strlen(str) : 0, NULL, 0, NULL)); } else if(json_is_boolean(val)) { result = PyDict_SetItemString(object, key, json_is_true(val) ? Py_True : Py_False); } else if(json_is_integer(val)) { result = PyDict_SetItemString(object, key, PyInt_FromLong(json_integer_value(val))); } else if(json_is_real(val)) { result = PyDict_SetItemString(object, key, PyFloat_FromDouble(json_real_value(val))); } else { result = PyDict_SetItemString(object, key, Py_None); } if (result == -1) goto failure; } } else if (json_is_array(json)) {
GratingParams parse_grating_info(const json_t * const root) { GratingParams result; json_t *data_json; data_json = json_object_get(root, "reset_phase_position"); flyvr_assert(data_json != NULL); flyvr_assert(json_is_boolean(data_json)); result.reset_phase_position = json_is_true( data_json ); data_json = json_object_get(root, "phase_position"); flyvr_assert(data_json != NULL); flyvr_assert(json_is_real(data_json)); result.phase_position = json_real_value( data_json ); data_json = json_object_get(root, "phase_velocity"); flyvr_assert(data_json != NULL); flyvr_assert(json_is_real(data_json)); result.phase_velocity = json_real_value( data_json ); data_json = json_object_get(root, "wavelength"); flyvr_assert(data_json != NULL); flyvr_assert(json_is_real(data_json)); result.wavelength = json_real_value( data_json ); data_json = json_object_get(root, "contrast"); flyvr_assert(data_json != NULL); flyvr_assert(json_is_real(data_json)); result.contrast = json_real_value( data_json ); data_json = json_object_get(root, "orientation"); flyvr_assert(data_json != NULL); flyvr_assert(json_is_real(data_json)); result.orientation = json_real_value( data_json ); return result; }
static bool load_content_from_config_file(json_t *config_json, const char *config_file) { bool return_value = false; jid = get_str_value(config_json, "jid"); werr2(jid == NULL, goto _finish, "There is no jid entry in %s", config_file); password = get_str_value(config_json, "password"); werr2(password == NULL, goto _finish, "There is no password entry in %s", config_file); owner = get_str_value(config_json, "owner"); werr2(owner == NULL, goto _finish, "There is no owner entry in %s", config_file); ssid = get_str_value(config_json, "ssid"); psk = get_str_value(config_json, "psk"); /* Set privacy based on privacy value from wyliodrin.json (if exists) */ json_t *privacy_json = json_object_get(config_json, "privacy"); if (privacy_json != NULL && json_is_boolean(privacy_json) && json_is_true(privacy_json)) { privacy = true; } const char *pong_timeout_str = get_str_value(config_json, "pong_timeout"); if (pong_timeout_str != NULL) { char *pEnd; pong_timeout = strtol(pong_timeout_str, &pEnd, 10); if (pong_timeout == 0) { pong_timeout = DEFAULT_PONG_TIMEOUT; } } /* Success */ return_value = true; _finish: ; return return_value; }
/* Call the simple functions not covered by other tests of the public API */ int main() { json_t *value; value = json_integer(1); if(json_typeof(value) != JSON_INTEGER) fail("json_typeof failed"); if(json_is_object(value)) fail("json_is_object failed"); if(json_is_array(value)) fail("json_is_array failed"); if(json_is_string(value)) fail("json_is_string failed"); if(!json_is_integer(value)) fail("json_is_integer failed"); if(json_is_real(value)) fail("json_is_real failed"); if(!json_is_number(value)) fail("json_is_number failed"); if(json_is_true(value)) fail("json_is_true failed"); if(json_is_false(value)) fail("json_is_false failed"); if(json_is_boolean(value)) fail("json_is_boolean failed"); if(json_is_null(value)) fail("json_is_null failed"); json_decref(value); value = json_string("foo"); if(!value) fail("json_string failed"); if(strcmp(json_string_value(value), "foo")) fail("invalid string value"); if(json_string_set(value, "bar")) fail("json_string_set failed"); if(strcmp(json_string_value(value), "bar")) fail("invalid string value"); json_decref(value); value = json_string(NULL); if(value) fail("json_string(NULL) failed"); /* invalid UTF-8 */ value = json_string("a\xefz"); if(value) fail("json_string(<invalid utf-8>) failed"); value = json_string_nocheck("foo"); if(!value) fail("json_string_nocheck failed"); if(strcmp(json_string_value(value), "foo")) fail("invalid string value"); if(json_string_set_nocheck(value, "bar")) fail("json_string_set_nocheck failed"); if(strcmp(json_string_value(value), "bar")) fail("invalid string value"); json_decref(value); /* invalid UTF-8 */ value = json_string_nocheck("qu\xff"); if(!value) fail("json_string_nocheck failed"); if(strcmp(json_string_value(value), "qu\xff")) fail("invalid string value"); if(json_string_set_nocheck(value, "\xfd\xfe\xff")) fail("json_string_set_nocheck failed"); if(strcmp(json_string_value(value), "\xfd\xfe\xff")) fail("invalid string value"); json_decref(value); value = json_integer(123); if(!value) fail("json_integer failed"); if(json_integer_value(value) != 123) fail("invalid integer value"); if(json_number_value(value) != 123.0) fail("invalid number value"); if(json_integer_set(value, 321)) fail("json_integer_set failed"); if(json_integer_value(value) != 321) fail("invalid integer value"); if(json_number_value(value) != 321.0) fail("invalid number value"); json_decref(value); value = json_real(123.123); if(!value) fail("json_real failed"); if(json_real_value(value) != 123.123) fail("invalid integer value"); if(json_number_value(value) != 123.123) fail("invalid number value"); if(json_real_set(value, 321.321)) fail("json_real_set failed"); if(json_real_value(value) != 321.321) fail("invalid real value"); if(json_number_value(value) != 321.321) fail("invalid number value"); json_decref(value); value = json_true(); if(!value) fail("json_true failed"); json_decref(value); value = json_false(); if(!value) fail("json_false failed"); json_decref(value); value = json_null(); if(!value) fail("json_null failed"); json_decref(value); /* Test reference counting on singletons (true, false, null) */ value = json_true(); if(value->refcount != (size_t)-1) fail("refcounting true works incorrectly"); json_decref(value); if(value->refcount != (size_t)-1) fail("refcounting true works incorrectly"); json_incref(value); if(value->refcount != (size_t)-1) fail("refcounting true works incorrectly"); value = json_false(); if(value->refcount != (size_t)-1) fail("refcounting false works incorrectly"); json_decref(value); if(value->refcount != (size_t)-1) fail("refcounting false works incorrectly"); json_incref(value); if(value->refcount != (size_t)-1) fail("refcounting false works incorrectly"); value = json_null(); if(value->refcount != (size_t)-1) fail("refcounting null works incorrectly"); json_decref(value); if(value->refcount != (size_t)-1) fail("refcounting null works incorrectly"); json_incref(value); if(value->refcount != (size_t)-1) fail("refcounting null works incorrectly"); return 0; }