class_builder(detail::extension_class<OtherT, OtherU>* cls, const char* name) : m_class(new detail::extension_class<T, U>(name)) { cls->set_attribute(name, ref(as_object(m_class.get()), ref::increment_count)); }
xbox_live_result<multiplayer_role_type> multiplayer_role_type::_Deserialize( _In_ const web::json::value& json ) { if (json.is_null()) return xbox_live_result<multiplayer_role_type>(); multiplayer_role_type returnResult; std::error_code errc = xbox_live_error_code::no_error; returnResult.m_ownerManaged = utils::extract_json_bool(json, _T("ownerManaged"), errc, false); returnResult.m_mutableRoleSettings = _Convert_string_vector_to_mutable_role_settings( utils::extract_json_vector<string_t>(utils::json_string_extractor, json, _T("mutableRoleSettings"), errc, false) ); auto rolesJson = utils::extract_json_field(json, _T("roles"), errc, false); if (!rolesJson.is_null() && rolesJson.is_object()) { web::json::object rolesObj = rolesJson.as_object(); for (const auto& role : rolesObj) { auto roleInfoResult = multiplayer_role_info::_Deserialize(role.second); if (roleInfoResult.err()) { errc = roleInfoResult.err(); } returnResult.m_roles[role.first] = roleInfoResult.payload(); } } return xbox_live_result<multiplayer_role_type>(returnResult, errc); }
bool runtime_config_t::ensure_parsed() { pal::string_t retval; if (!pal::file_exists(m_path)) { // Not existing is not an error. return true; } pal::ifstream_t file(m_path); if (!file.good()) { trace::verbose(_X("File stream not good %s"), m_path.c_str()); return false; } try { const auto root = json_value::parse(file); const auto& json = root.as_object(); const auto iter = json.find(_X("runtimeOptions")); if (iter != json.end()) { parse_opts(iter->second); } } catch (const web::json::json_exception& je) { pal::string_t jes = pal::to_palstring(je.what()); trace::error(_X("A JSON parsing exception occurred: %s"), jes.c_str()); return false; } return true; }
void free() { if( data_ == nullptr ){ return; } switch( type_ ) { default: break; case object_type: delete as_object(); break; case array_type: delete as_array(); break; case string_type: delete as_string(); break; case int_type: delete as_int(); break; case number_type: delete as_number(); break; case bool_type: delete as_bool(); break; } }
void JSON::convertToObject() { if (m_type != e_object) { JSON obj = as_object(); (*this) = obj; } }
Object * Hash_keys(Object *self) { GList *keys_list = g_hash_table_get_keys(as_hash(self)->hash); Object *keys = Array_new(); while (keys_list) { Array_push(keys, as_object(keys_list->data)); keys_list = keys_list->next; } return keys; }
X X::from_json(JSON::Value const& v) { X result; auto& o = as_object(as_array(v)[0]); result.var1 = as_string(o["var1"]); result.var2 = as_double(o["var2"]); return result; }
pal::string_t fx_muxer_t::resolve_cli_version(const pal::string_t& global_json) { trace::verbose(_X("--- Resolving CLI version from global json [%s]"), global_json.c_str()); pal::string_t retval; if (!pal::file_exists(global_json)) { trace::verbose(_X("[%s] does not exist"), global_json.c_str()); return retval; } pal::ifstream_t file(global_json); if (!file.good()) { trace::verbose(_X("[%s] could not be opened"), global_json.c_str()); return retval; } if (skip_utf8_bom(&file)) { trace::verbose(_X("UTF-8 BOM skipped while reading [%s]"), global_json.c_str()); } try { const auto root = json_value::parse(file); const auto& json = root.as_object(); const auto sdk_iter = json.find(_X("sdk")); if (sdk_iter == json.end() || sdk_iter->second.is_null()) { trace::verbose(_X("CLI '/sdk/version' field not present/null in [%s]"), global_json.c_str()); return retval; } const auto& sdk_obj = sdk_iter->second.as_object(); const auto ver_iter = sdk_obj.find(_X("version")); if (ver_iter == sdk_obj.end() || ver_iter->second.is_null()) { trace::verbose(_X("CLI 'sdk/version' field not present/null in [%s]"), global_json.c_str()); return retval; } retval = ver_iter->second.as_string(); } catch (const std::exception& je) { pal::string_t jes; (void) pal::utf8_palstring(je.what(), &jes); trace::error(_X("A JSON parsing exception occurred in [%s]: %s"), global_json.c_str(), jes.c_str()); } trace::verbose(_X("CLI version is [%s] in global json file [%s]"), retval.c_str(), global_json.c_str()); return retval; }
track track::find_by_id(const std::string& id) { auto data = kvstore_->get(id); if ( !data.is_null() ) { return track(std::move(data.as_object())); } else { return track(); } }
/** * Resolve the hostpolicy version from deps. * - Scan the deps file's libraries section and find the hostpolicy version in the file. */ pal::string_t resolve_hostpolicy_version_from_deps(const pal::string_t& deps_json) { trace::verbose(_X("--- Resolving %s version from deps json [%s]"), LIBHOSTPOLICY_NAME, deps_json.c_str()); pal::string_t retval; if (!pal::file_exists(deps_json)) { trace::verbose(_X("Dependency manifest [%s] does not exist"), deps_json.c_str()); return retval; } pal::ifstream_t file(deps_json); if (!file.good()) { trace::verbose(_X("Dependency manifest [%s] could not be opened"), deps_json.c_str()); return retval; } if (skip_utf8_bom(&file)) { trace::verbose(_X("UTF-8 BOM skipped while reading [%s]"), deps_json.c_str()); } try { const auto root = json_value::parse(file); const auto& json = root.as_object(); const auto& libraries = json.at(_X("libraries")).as_object(); // Look up the root package instead of the "runtime" package because we can't do a full rid resolution. // i.e., look for "Microsoft.NETCore.DotNetHostPolicy/" followed by version. pal::string_t prefix = _X("Microsoft.NETCore.DotNetHostPolicy/"); for (const auto& library : libraries) { if (starts_with(library.first, prefix, false)) { // Extract the version information that occurs after '/' retval = library.first.substr(prefix.size()); break; } } } catch (const std::exception& je) { pal::string_t jes; (void)pal::utf8_palstring(je.what(), &jes); trace::error(_X("A JSON parsing exception occurred in [%s]: %s"), deps_json.c_str(), jes.c_str()); } trace::verbose(_X("Resolved version %s from dependency manifest file [%s]"), retval.c_str(), deps_json.c_str()); return retval; }
static void test_check_initial_config(session &sess) { auto &node = get_setup()->nodes.back(); static const uint32_t backend_id = 4; ELLIPTICS_REQUIRE(result, sess.monitor_stat(node.remote(), DNET_MONITOR_BACKEND)); BOOST_REQUIRE_EQUAL(result.get().size(), 1); auto monitor_initial_config = [&] () { std::istringstream stream(result.get().front().statistics()); auto monitor_statistics = kora::dynamic::read_json(stream); return monitor_statistics.as_object()["backends"] .as_object()[std::to_string(backend_id)] .as_object()["backend"] .as_object()["initial_config"]; } (); auto config_initial_config = [&] () { std::ifstream stream(node.config_path()); auto config = kora::dynamic::read_json(stream); return config.as_object()["backends"].as_array()[backend_id]; } (); BOOST_REQUIRE_EQUAL(monitor_initial_config, config_initial_config); }
ListSessionsReply::ListSessionsReply(const JSONMessagePtr& message) { // now walk the parse tree and dig out the properties web::json::value sessionList = message->GetObjectValue(gSessionListKey); for (auto iter = sessionList.as_array().begin(); iter != sessionList.as_array().end(); ++iter) { if (!iter->is_null()) { SessionDescriptorImpl* session; session = SessionDescriptorImpl::FromJSON(iter->as_object()); m_sessions.push_back(session); } } }
int main() { auto doc = as_object(JSON::parse( "{\n" " // some values\n" " \"mykey\": [\n" " {\n" " \"var1\": \"value1_str\",\n" " \"var2\" : 3.14\n" " }\n" " ]\n" " // some other values\n" "}\n" )); if (doc.has_key("mykey")) { X data = X::from_json(doc["mykey"]); std::cout << "X.var1: " << data.var1 << "\n"; std::cout << "X.var2: " << data.var2 << "\n"; } }
class_builder(class_builder<OtherT, OtherU>& cls, const char* name) : m_class(new detail::extension_class<T, U>(name)) { cls.add(ref(as_object(m_class.get()), ref::increment_count), name); }
class_builder(module_builder& module, const char* name) : m_class(new detail::extension_class<T, U>(name)) { module.add(ref(as_object(m_class.get()), ref::increment_count), name); }
void Oop::print_process_or_nil(Printer* p) { as_object()->print_process_or_nil(p); }
void Oop::print(Printer* p) { if (is_int()) p->printf("%d", integerValue()); else as_object()->print(p); }
Object * Hash_new() { Hash *self = xmalloc(sizeof(Hash)); set_type(self, Hash); Hash__INIT(as_object(self)); return as_object(self); }
static guint hash_func(gconstpointer obj) { // FIXME: we need some reasonable hashing mechanism return as_object(obj)->type; }
/* * Implements GEqualFunc, used for comparing keys in the hash. */ static gboolean equal_func(gconstpointer a, gconstpointer b) { return boolean_value( ( (Object*(*)(Object*,Object*)) find_method(as_object(a)->type, l_classes_dictionary, _EQ__EQ__id, "==", 2))(as_object(a), as_object(b))); }
void module_builder_base::add(PyTypeObject* x, const char* name /*= 0*/) { this->add(ref(as_object(x)), name ? name : x->tp_name); }