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);
}
