60 C++ code examples are found related to "
parse json
".
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
Example 1
Oomd::Config2::IR::DetectorGroup parseDetectorGroup(
const Json::Value& detector_group) {
Oomd::Config2::IR::DetectorGroup ir_detectorgroup;
if (!detector_group.isArray()) {
return {};
for (Json::ArrayIndex i = 0; i < detector_group.size(); ++i) {
if (i == 0 && detector_group[i].isString()) {
ir_detectorgroup.name = detector_group[i].asString();
continue;
// else: all other indicies (ie detectors)
const auto& detector = detector_group[i];
ir_detectorgroup.detectors.emplace_back(
parsePlugin<Oomd::Config2::IR::Detector>(detector));
return ir_detectorgroup;
Example 2
Oomd::Config2::IR::Ruleset parseRuleset(const Json::Value& ruleset) {
Oomd::Config2::IR::Ruleset ir_ruleset;
ir_ruleset.name = ruleset.get("name", "").asString();
ir_ruleset.dropin = parseDropIn(ruleset.get("drop-in", {}));
ir_ruleset.silence_logs = ruleset.get("silence-logs", {}).asString();
for (const auto& detector_group : ruleset.get("detectors", {})) {
ir_ruleset.dgs.emplace_back(parseDetectorGroup(detector_group));
for (const auto& action : ruleset.get("actions", {})) {
ir_ruleset.acts.emplace_back(
parsePlugin<Oomd::Config2::IR::Action>(action));
return ir_ruleset;
void xmrig::Config::parseJSON(const rapidjson::Document &doc)
CommonConfig::parseJSON(doc);
const rapidjson::Value &threads = doc["threads"];
if (threads.IsArray()) {
for (const rapidjson::Value &value : threads.GetArray()) {
if (!value.IsObject()) {
continue;
if (value.HasMember("intensity")) {
parseThread(value);
Example 4
void xmrig::ConfigLoader::parseJSON(xmrig::IConfig *config, const struct option *option, const rapidjson::Value &object)
if (!option->name || !object.HasMember(option->name)) {
return;
const rapidjson::Value &value = object[option->name];
if (option->has_arg) {
if (value.IsString()) {
config->parseString(option->val, value.GetString());
else if (value.IsInt64()) {
config->parseUint64(option->val, value.GetUint64());
else if
// Valid
BOOST_CHECK_EQUAL(read_string(std::string("1.0"), value), true);
// Valid, with trailing whitespace
BOOST_CHECK_EQUAL(read_string(std::string("1.0 "), value), true);
// Invalid, initial garbage
BOOST_CHECK_EQUAL(read_string(std::string("[1.0"), value), false);
BOOST_CHECK_EQUAL(read_string(std::string("a1.0"), value), false);
// Invalid, trailing garbage
BOOST_CHECK_EQUAL(read_string(std::string("1.0sds"), value), false);
BOOST_CHECK_EQUAL(read_string(std::string("1.0]"), value), false);
// BTC addresses should fail parsing
BOOST_CHECK_EQUAL(read_string(std::string("175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W"), value), false);
BOOST_CHECK_EQUAL(read_string(std::string("3J98t1WpEZ73CNmQviecrnyiWrnqRhWNL"), value), false);
Example 6
// Valid
BOOST_CHECK_EQUAL(ParseNonRFCJSONValue("1.0").get_real(), 1.0);
// Valid, with leading or trailing whitespace
BOOST_CHECK_EQUAL(ParseNonRFCJSONValue(" 1.0").get_real(), 1.0);
BOOST_CHECK_EQUAL(ParseNonRFCJSONValue("1.0 ").get_real(), 1.0);
// Invalid, initial garbage
BOOST_CHECK_THROW(ParseNonRFCJSONValue("[1.0"), std::runtime_error);
BOOST_CHECK_THROW(ParseNonRFCJSONValue("a1.0"), std::runtime_error);
// Invalid, trailing garbage
BOOST_CHECK_THROW(ParseNonRFCJSONValue("1.0sds"), std::runtime_error);
BOOST_CHECK_THROW(ParseNonRFCJSONValue("1.0]"), std::runtime_error);
// BTC addresses should fail parsing
BOOST_CHECK_THROW(ParseNonRFCJSONValue("175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W"), std::runtime_error);
BOOST_CHECK_THROW(ParseNonRFCJSONValue("3J98t1WpEZ73CNmQviecrnyiWrnqRhWNL"), std::runtime_error);
Example 7
if(json_scanf(json, len, "{name: %Q}", &m_Name) == 1)
if(strlen(m_Name) > OMNI_MAX_NAME_LENGTH)
LOG << F("ERROR: name=") << m_Name << F(" exceeds max length of ")
<< OMNI_MAX_NAME_LENGTH << Logger::endl;
delete m_Name;
return false;
LOG << F("Naming device: ") << m_Name << Logger::endl;
Example 8
rapidjson::Document NetworkResult::parseRapidJson() const
rapidjson::Document ret(rapidjson::kObjectType);
rapidjson::ParseResult result =
ret.Parse(this->data_.data(), this->data_.length());
if (result.Code() != rapidjson::kParseErrorNone)
qDebug() << "JSON parse error:"
<< rapidjson::GetParseError_En(result.Code()) << "("
<< result.Offset() << ")";
return ret;
return ret;
Example 9
bool DBusGatewayParser::parseDBusConfig(const json_t *element,
const char *key,
json_t *config)
log_debug() << "Parsing element for " << key;
json_t *configExists = json_object_get(element, key);
if (nullptr == configExists) {
// This is not a fatal error - not providing the key for one of the buses is OK.
log_warning() << key << " was not found in config.";
return false;
if (!json_is_array(configExists)) {
throwWithLog(logging::StringBuilder() << "Value for " << key << " is not an array");
for (unsigned int i = 0; i < json_array_size(configExists); i++) {
json_t *child = json_array_get(configExists, i);
if (!json_is_object(child)) {
throwWithLog("JSON array element is not an object!");
} else {
json_array_append(config, json_deep_copy(child));
util::Status JsonStringToMessage(const string& input, Message* message,
const JsonParseOptions& options) {
const DescriptorPool* pool = message->GetDescriptor()->file()->pool();
TypeResolver* resolver =
pool == DescriptorPool::generated_pool()
? GetGeneratedTypeResolver()
: NewTypeResolverForDescriptorPool(kTypeUrlPrefix, pool);
string binary;
util::Status result = JsonToBinaryString(
resolver, GetTypeUrl(*message), input, &binary, options);
if (result.ok() && !message->ParseFromString(binary)) {
result =
util::Status(util::error::INVALID_ARGUMENT,
"JSON transcoder produced invalid protobuf output.");
if (pool != DescriptorPool::generated_pool()) {
delete resolver;
return result;
Example 11
BulbId RgbCctPacketFormatter::parsePacket(const uint8_t *packet, JsonObject result) {
uint8_t packetCopy[V2_PACKET_LEN];
memcpy(packetCopy, packet, V2_PACKET_LEN);
V2RFEncoding::decodeV2Packet(packetCopy);
BulbId bulbId(
(packetCopy[2] << 8) | packetCopy[3],
packetCopy[7],
REMOTE_TYPE_RGB_CCT
uint8_t command = (packetCopy[V2_COMMAND_INDEX] & 0x7F);
uint8_t arg = packetCopy[V2_ARGUMENT_INDEX];
if (command == RGB_CCT_ON) {
if ((packetCopy[V2_COMMAND_INDEX] & 0x80) == 0x80) {
result[GroupStateFieldNames::COMMAND] = MiLightCommandNames::NIGHT_MODE;
} else if (arg == RGB_CCT_MODE_SPEED_DOWN) {
result[GroupStateFieldNames::COMMAND] = MiLightCommandNames::MODE_SPEED_DOWN;
} else if
Example 12
nmos::fields::id(data),
value_of({
{ nmos::fields::registration_heartbeat_interval, nmos::fields::heartbeat_interval(is04) },
{ nmos::fields::ptp_announce_receipt_timeout, nmos::fields::announce_receipt_timeout(ptp) },
{ nmos::fields::ptp_domain_number, nmos::fields::domain_number(ptp) }
Example 13
int character = readNext();
if (index==29 || character == '}' || character==-1) {
result = false;
break;
if(character == ',' || character==':') // end of value
break;
if(character == ' ' || character == '"'){
; // skip spaces and apostrophes
val[index++] = character;
Example 14
bool CNModuleConfig::ParseByJSONStr(const std::string& jstr) {
rapidjson::Document doc;
if (doc.Parse<rapidjson::kParseCommentsFlag>(jstr.c_str()).HasParseError()) {
LOG(ERROR) << "Parse module configuration failed. Error code [" << std::to_string(doc.GetParseError()) << "]"
<< " Offset [" << std::to_string(doc.GetErrorOffset()) << "]. JSON:" << jstr;
return false;
/* get members */
const auto end = doc.MemberEnd();
// className
if (end == doc.FindMember("class_name")) {
LOG(ERROR) << "Module has to have a class_name.";
return false;
} else {
Example 15
BulbId FUT091PacketFormatter::parsePacket(const uint8_t *packet, JsonObject result) {
uint8_t packetCopy[V2_PACKET_LEN];
memcpy(packetCopy, packet, V2_PACKET_LEN);
V2RFEncoding::decodeV2Packet(packetCopy);
BulbId bulbId(
(packetCopy[2] << 8) | packetCopy[3],
packetCopy[7],
REMOTE_TYPE_FUT091
uint8_t command = (packetCopy[V2_COMMAND_INDEX] & 0x7F);
uint8_t arg = packetCopy[V2_ARGUMENT_INDEX];
if (command == (uint8_t)FUT091Command::ON_OFF) {
if ((packetCopy[V2_COMMAND_INDEX] & 0x80) == 0x80) {
result[GroupStateFieldNames::COMMAND] = MiLightCommandNames::NIGHT_MODE;
} else if (arg < 5) { // Group is not reliably encoded in group byte. Extract from arg byte
result[GroupStateFieldNames::STATE] = "ON";
bulbId.groupId = arg;
} else {
BulbId RgbwPacketFormatter::parsePacket(const uint8_t* packet, JsonObject result) {
uint8_t command = packet[RGBW_COMMAND_INDEX] & 0x7F;
BulbId bulbId(
(packet[1] << 8) | packet[2],
packet[RGBW_BRIGHTNESS_GROUP_INDEX] & 0x7,
REMOTE_TYPE_RGBW
if (command >= RGBW_ALL_ON && command <= RGBW_GROUP_4_OFF) {
result[GroupStateFieldNames::STATE] = (STATUS_FOR_COMMAND(command) == ON) ? "ON" : "OFF";
// Determine group ID from button ID for on/off. The remote's state is from
// the last packet sent, not the current one, and that can be wrong for
// on/off commands.
bulbId.groupId = GROUP_FOR_STATUS_COMMAND(command);
} else if
Example 17
int parseConfig(const char *json_string, AOEModelOption *option)
cJSON *cjson = cJSON_Parse(json_string);
if (NULL == cjson)
return -1;
SqueezeModelOption *squeezeOption = (SqueezeModelOption *)option;
strcpy(squeezeOption->runtime, cJSON_GetObjectItem(cjson, "runtime")->valuestring);
strcpy(squeezeOption->tag, cJSON_GetObjectItem(cjson, "tag")->valuestring);
strcpy(squeezeOption->version, cJSON_GetObjectItem(cjson, "version")->valuestring);
strcpy(squeezeOption->modelDir, cJSON_GetObjectItem(cjson, "modelDir")->valuestring);
strcpy(squeezeOption->modelFileName, cJSON_GetObjectItem(cjson, "modelFileName")->valuestring);
strcpy(squeezeOption->modelParamFileName, cJSON_GetObjectItem(cjson, "modelParamFileName")->valuestring);
cJSON_Delete(cjson);
return 0;
Example 18
// Valid
BOOST_CHECK_EQUAL(ParseNonRFCJSONValue("1.0").get_real(), 1.0);
// Valid, with leading or trailing whitespace
BOOST_CHECK_EQUAL(ParseNonRFCJSONValue(" 1.0").get_real(), 1.0);
BOOST_CHECK_EQUAL(ParseNonRFCJSONValue("1.0 ").get_real(), 1.0);
BOOST_CHECK_THROW(AmountFromValue(ParseNonRFCJSONValue(".19e-6")), std::runtime_error); //should fail, missing leading 0, therefore invalid JSON
BOOST_CHECK_EQUAL(AmountFromValue(ParseNonRFCJSONValue("0.00000000000000000000000000000000000001e+30 ")), 1);
// Invalid, initial garbage
BOOST_CHECK_THROW(ParseNonRFCJSONValue("[1.0"), std::runtime_error);
BOOST_CHECK_THROW(ParseNonRFCJSONValue("a1.0"), std::runtime_error);
// Invalid, trailing garbage
BOOST_CHECK_THROW(ParseNonRFCJSONValue("1.0sds"), std::runtime_error);
BOOST_CHECK_THROW(ParseNonRFCJSONValue("1.0]"), std::runtime_error);
// RDC addresses should fail parsing
BOOST_CHECK_THROW(ParseNonRFCJSONValue("175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W"), std::runtime_error);
BOOST_CHECK_THROW(ParseNonRFCJSONValue("3J98t1WpEZ73CNmQviecrnyiWrnqRhWNL"), std::runtime_error);
Example 19
static grpc_json* parse_json_part_from_jwt(const char* str, size_t len,
char** scratchpad) {
grpc_core::ExecCtx exec_ctx;
char* b64;
char* decoded;
grpc_json* json;
grpc_slice slice;
b64 = static_cast<char*>(gpr_malloc(len + 1));
strncpy(b64, str, len);
b64[len] = '\0';
slice = grpc_base64_decode(b64, 1);
GPR_ASSERT(!GRPC_SLICE_IS_EMPTY(slice));
decoded = static_cast<char*>(gpr_malloc(GRPC_SLICE_LENGTH(slice) + 1));
strncpy(decoded, reinterpret_cast<const char*> GRPC_SLICE_START_PTR(slice),
GRPC_SLICE_LENGTH(slice));
decoded[GRPC_SLICE_LENGTH(slice)] = '\0';
json = grpc_json_parse_string(decoded);
gpr_free(b64);
*scratchpad = decoded;
grpc_slice_unref(slice);
return json;
Example 20
// HACK: Message block is string data (not a proper json tree)
Json::Value& value = get_value();
Json::Value message = value.get(json::message, Json::Value::null);
if (!message.empty())
Json::Value node;
Json::Reader reader;
if (!reader.parse(message.asCString(), node))
throw std::runtime_error(reader.getFormattedErrorMessages());
value[json::message] = node;
Example 21
TEST_UNIT(test_json_parse_error_commit_badcase) {
const char* path = "../test/test_data/json/browser_relative2.json";
simcc::DataStream buf;
H_TEST_ASSERT(buf.ReadFile(path));
simcc::json::JSONObject jo0;
H_TEST_ASSERT(jo0.Parse(buf.data(), buf.size()));
std::string serialize4 = jo0.ToString(1);
simcc::json::JSONObject jo4;
H_TEST_ASSERT(jo4.Parse(serialize4.data(), serialize4.size()));
H_TEST_ASSERT(jo4.Equals(jo0));
std::string serialize5 = jo4.ToString(1);
simcc::json::JSONObject jo5;
H_TEST_ASSERT(jo5.Parse(serialize5.data(), serialize5.size()));
H_TEST_ASSERT(jo5.Equals(jo0));
H_TEST_ASSERT(jo5.Equals(jo4));
H_TEST_ASSERT(serialize5 == serialize4);
Example 22
bool servlet_parse_params(HttpRequest &request, HttpResponse &response, Json::Value ¶ms)
try {
if (request.method != "POST")
throw ::Exception("Expecting POST method");
Json::Reader reader;
if (!reader.parse(request.body, params))
throw Exception("Cannot parse JSON body");
return true;
} catch (const Exception &e) {
LogStream::sendError() << "Servlet " << request.uri << ":" << e.what() << endl;
response.status = 500;
response.message = "Command failed";
response.body = e.what();
return false;
Example 23
// Valid
BOOST_CHECK_EQUAL(ParseNonRFCJSONValue("1.0").get_real(), 1.0);
// Valid, with leading or trailing whitespace
BOOST_CHECK_EQUAL(ParseNonRFCJSONValue(" 1.0").get_real(), 1.0);
BOOST_CHECK_EQUAL(ParseNonRFCJSONValue("1.0 ").get_real(), 1.0);
BOOST_CHECK_THROW(AmountFromValue(ParseNonRFCJSONValue(".19e-6")), std::runtime_error); //should fail, missing leading 0, therefore invalid JSON
BOOST_CHECK_EQUAL(AmountFromValue(ParseNonRFCJSONValue("0.00000000000000000000000000000000000001e+30 ")), 1);
// Invalid, initial garbage
BOOST_CHECK_THROW(ParseNonRFCJSONValue("[1.0"), std::runtime_error);
BOOST_CHECK_THROW(ParseNonRFCJSONValue("a1.0"), std::runtime_error);
// Invalid, trailing garbage
BOOST_CHECK_THROW(ParseNonRFCJSONValue("1.0sds"), std::runtime_error);
BOOST_CHECK_THROW(ParseNonRFCJSONValue("1.0]"), std::runtime_error);
// BTC addresses should fail parsing
BOOST_CHECK_THROW(ParseNonRFCJSONValue("175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W"), std::runtime_error);
BOOST_CHECK_THROW(ParseNonRFCJSONValue("3J98t1WpEZ73CNmQviecrnyiWrnqRhWNL"), std::runtime_error);
Example 24
flatbuffers::DetachedBuffer BlueprintFromJsonCompiler::ParseJson(
string_view json_contents) {
flatbuffers::DetachedBuffer empty;
rapidjson::Document json;
json.Parse(json_contents.data(), json_contents.size());
if (json.HasParseError()) {
PrintJsonError(std::string(json_contents), json);
return empty;
if (!json.IsObject()) {
LOG(ERROR) << "Not a json object.";
return empty;
if (!ParseJsonEntity(json)) {
return empty;
return blueprint_builder_.Finish();
Example 25
bool Contract::ParseAsJson(chain::Transaction const &tx, variant::Variant &output)
bool success{false};
json::JSONDocument document;
// parse the data of the transaction
document.Parse(tx.data());
success = true;
catch (json::JSONParseException const &)
if (success)
output = document.root();
return success;
Example 26
util::Status JsonStreamParser::Parse(StringPiece json) {
StringPiece chunk = json;
// If we have leftovers from a previous chunk, append the new chunk to it
// and create a new StringPiece pointing at the string's data. This could
// be large but we rely on the chunks to be small, assuming they are
// fragments of a Cord.
if (!leftover_.empty()) {
// Don't point chunk to leftover_ because leftover_ will be updated in
// ParseChunk(chunk).
chunk_storage_.swap(leftover_);
json.AppendToString(&chunk_storage_);
chunk = StringPiece(chunk_storage_);
// Find the structurally valid UTF8 prefix and parse only that.
int n = internal::UTF8SpnStructurallyValid(chunk);
if (n > 0) {
util::Status status = ParseChunk(chunk.substr(0, n));
// Any leftover characters are stashed in leftover_ for later parsing when
// there is more data available.
chunk.substr(n).AppendToString(&leftover_);
return status;
} else {
Example 27
// HACK: Message block is string data (not a proper json tree)
Json::Value& value = get_value();
Json::Value message = value.get(json::message, Json::Value::null);
if (!message.empty())
Json::Value node;
Json::Reader reader;
if (!reader.parse(message.asCString(), node))
throw std::runtime_error(reader.getFormattedErrorMessages());
value[json::message] = node;
Example 28
void xmrig::Config::parseJSON(const rapidjson::Document &doc)
CommonConfig::parseJSON(doc);
const rapidjson::Value &threads = doc["threads"];
if (threads.IsArray()) {
for (const rapidjson::Value &value : threads.GetArray()) {
if (!value.IsObject()) {
continue;
if (value.HasMember("threads")) {
parseThread(value);
Example 29
bool ScillaTestUtil::ParseJsonFile(Json::Value &j, std::string filename) {
if (!boost::filesystem::is_regular_file(filename)) {
return false;
std::ifstream in(filename, std::ios::binary);
std::string fstr;
fstr = {std::istreambuf_iterator<char>(in), std::istreambuf_iterator<char>()};
Json::CharReaderBuilder builder;
std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
std::string errors;
return reader->parse(fstr.c_str(), fstr.c_str() + fstr.size(), &j, &errors);
Example 30
// Valid
BOOST_CHECK_EQUAL(ParseNonRFCJSONValue("1.0").get_real(), 1.0);
// Valid, with leading or trailing whitespace
BOOST_CHECK_EQUAL(ParseNonRFCJSONValue(" 1.0").get_real(), 1.0);
BOOST_CHECK_EQUAL(ParseNonRFCJSONValue("1.0 ").get_real(), 1.0);
BOOST_CHECK_THROW(AmountFromValue(ParseNonRFCJSONValue(".19e-6")), std::runtime_error); //should fail, missing leading 0, therefore invalid JSON
BOOST_CHECK_EQUAL(AmountFromValue(ParseNonRFCJSONValue("0.00000000000000000000000000000000000001e+30 ")), 1);
// Invalid, initial garbage
BOOST_CHECK_THROW(ParseNonRFCJSONValue("[1.0"), std::runtime_error);
BOOST_CHECK_THROW(ParseNonRFCJSONValue("a1.0"), std::runtime_error);
// Invalid, trailing garbage
BOOST_CHECK_THROW(ParseNonRFCJSONValue("1.0sds"), std::runtime_error);
BOOST_CHECK_THROW(ParseNonRFCJSONValue("1.0]"), std::runtime_error);
// SOV addresses should fail parsing
BOOST_CHECK_THROW(ParseNonRFCJSONValue("175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W"), std::runtime_error);
BOOST_CHECK_THROW(ParseNonRFCJSONValue("3J98t1WpEZ73CNmQviecrnyiWrnqRhWNL"), std::runtime_error);
Example 31
std::istringstream sinput(input);
bool ok = Json::parseFromStream(rbuilder, sinput, &ret, &errs);
if (!ok) {
std::cerr << "Unable to parse JSON: " << errs;
return std::nullopt;
return ret;
Example 32
util::Status JsonToBinaryStream(TypeResolver* resolver,
const string& type_url,
io::ZeroCopyInputStream* json_input,
io::ZeroCopyOutputStream* binary_output,
const JsonParseOptions& options) {
google::protobuf::Type type;
RETURN_IF_ERROR(resolver->ResolveMessageType(type_url, &type));
internal::ZeroCopyStreamByteSink sink(binary_output);
StatusErrorListener listener;
converter::ProtoStreamObjectWriter::Options proto_writer_options;
proto_writer_options.ignore_unknown_fields = options.ignore_unknown_fields;
converter::ProtoStreamObjectWriter proto_writer(resolver, type, &sink,
&listener,
proto_writer_options);
converter::JsonStreamParser parser(&proto_writer);
const void* buffer;
int length;
while (json_input->Next(&buffer, &length)) {
if (length == 0) continue;
RETURN_IF_ERROR(
parser.Parse(StringPiece(static_cast<const char*>(buffer), length)));
RETURN_IF_ERROR(parser.FinishParse());
return listener.GetStatus();
Example 33
Oomd::Config2::IR::DropIn parseDropIn(const Json::Value& dropin) {
Oomd::Config2::IR::DropIn ir_dropin;
ir_dropin.disable_on_drop_in =
dropin.get("disable-on-drop-in", false).asBool();
ir_dropin.detectorgroups_enabled = dropin.get("detectors", false).asBool();
ir_dropin.actiongroup_enabled = dropin.get("actions", false).asBool();
return ir_dropin;
Example 34
oauth2_token oauth2_config::_parse_token_from_json(const json::value& token_json)
oauth2_token result;
if (token_json.has_string_field(oauth2_strings::access_token))
result.set_access_token(token_json.at(oauth2_strings::access_token).as_string());
throw
Example 35
for (const auto& key : json_args.getMemberNames()) {
const auto& value = json_args[key];
// Value has to be a string, number, or bool
if (!value.isString() && !value.isNumeric() && !value.isBool()) {
return ret;
ret.args[key] = value.asString();
return ret;
Example 36
if (! object.isVoid())
String cmd (object.getProperty (getCmdIdentifier(), var()).toString());
var params (object.getProperty (getParamIdentifier(), var()));
if (responder != nullptr)
responder->handleCommand (cmd, params);
Example 37
util::Status JsonToBinaryString(TypeResolver* resolver,
const string& type_url,
const string& json_input,
string* binary_output,
const JsonParseOptions& options) {
io::ArrayInputStream input_stream(json_input.data(), json_input.size());
io::StringOutputStream output_stream(binary_output);
return JsonToBinaryStream(
resolver, type_url, &input_stream, &output_stream, options);
Example 38
std::string strDownStatus;
std::string strGidItem;
if (dc.HasMember("method") && dc["method"].IsString())
strDownStatus = dc["method"].GetString();
if (dc.HasMember("params") && dc["params"].IsArray())
for (auto &v : dc["params"].GetArray())
if (!v.IsObject())
continue;
if (v.HasMember("gid") && v["gid"].IsString())
strGidItem = v["gid"].GetString();
if (strDownStatus == ARIA2_DOWNLOAD_COMPLATE)
PVOID sendPtr = AlloclocalHeap(strGidItem);
::PostMessage(m_hwnd, ARIA2_DOWNLOAD_COMPLATE_MSG, NULL, (LPARAM)sendPtr);
else if (strDownStatus == ARIA2_DOWNLOAD_START)
PVOID sendPtr = AlloclocalHeap(strGidItem);
::PostMessage(m_hwnd, ARIA2_DOWNLOAD_START_MSG, NULL, (LPARAM)sendPtr);
else if
Example 39
BOOST_AUTO_TEST_CASE(json_decode_helpers_comma_separated_with_failing_inner_parse) {
auto ctx = make_context("<a,a>");
bool was_called_already = false;
BOOST_CHECK_THROW(decode_comma_separated(ctx, '<', '>', [&]{
BOOST_CHECK(!was_called_already);
was_called_already = true;
skip_1(ctx, 'b');
}), decode_exception);
Example 40
const char* CompositePeripheral::parseName(const char* json)
unsigned int len = strlen(json);
const char* name = nullptr;
// scanning for optional name
if(json_scanf(json, len, "{name: %Q}", &name) != 1)
LOG << F("ERROR: CompositePeriph name not found\n");
return name;
Example 41
FileReadStatus ParseDocument(JSONDocument &document, ConstByteArray const &contents)
FileReadStatus status{FileReadStatus::FAILURE};
if (contents.empty())
status = FileReadStatus::FILE_NOT_PRESENT;
Example 42
SIMDJSON_PUSH_DISABLE_WARNINGS
SIMDJSON_DISABLE_DEPRECATED_WARNING
static void json_parse(State& state) {
ParsedJson pj;
if (!pj.allocate_capacity(EMPTY_ARRAY.length())) { return; }
for (UNUSED auto _ : state) {
auto error = json_parse(EMPTY_ARRAY, pj);
if (error) { return; }
Example 43
BulbId RgbPacketFormatter::parsePacket(const uint8_t* packet, JsonObject result) {
uint8_t command = packet[RGB_COMMAND_INDEX] & 0x7F;
BulbId bulbId(
(packet[1] << 8) | packet[2],
REMOTE_TYPE_RGB
if (command == RGB_ON) {
result[GroupStateFieldNames::STATE] = "ON";
} else if
Example 44
Policy* Policy::parse_from_json_value(const rapidjson::Value& value) {
if (!value.IsObject()) {
LOG(WARNING) << "Failed to parse policy from json, not an object: " << utils::json_to_string(value);
return nullptr;
if (!value.HasMember("trigger") || !value["trigger"].IsObject()
|| !value["trigger"].HasMember("intent") || !value["trigger"]["intent"].IsString()) {
LOG(WARNING) << "Failed to parse policy from json, invalid trigger";
return nullptr;
PolicyTrigger trigger;
trigger.intent = value["trigger"]["intent"].GetString();
if (value["trigger"].HasMember("slots") && value["trigger"]["slots"].IsArray()) {
for (auto& v : value["trigger"]["slots"].GetArray()) {
trigger.slots.push_back(v.GetString());
if (value["trigger"].HasMember("state") && value["trigger"]["state"].IsString()) {
trigger.state = value["trigger"]["state"].GetString();
std::vector<PolicyParam> params;
if (value.HasMember("params") && value["params"].IsArray()) {
for (auto& v : value["params"].GetArray()) {
PolicyParam param;
param.name = v["name"].GetString();
param.type = v["type"].GetString();
param.value = v["value"].GetString();
if (v.HasMember("required") && v["required"].IsBool()) {
param.required = v["required"].GetBool();
} else {
param.required = false;
if (v.HasMember("default") && v["default"].IsString()) {
param.default_value = v["default"].GetString();
params.push_back(param);
Example 45
QJsonArray NetworkResult::parseJsonArray() const
QJsonDocument jsonDoc(QJsonDocument::fromJson(this->data_));
if (jsonDoc.isNull())
return QJsonArray{};
return jsonDoc.array();
Example 46
JsonRpcObject* JsonRpcObjectFactory::parseJsonRpcObject(const QJsonObject& _jsonObject, int& _jsonRpcErrorCode, QString& _jsonRpcErrorString,
QString& _jsonRpcErrorData) {
if (!_jsonObject.contains(JsonRpcObject::jsonRpcTagName) ||
_jsonObject.value(JsonRpcObject::jsonRpcTagName).toString().compare(JsonRpcObject::jsonRpcVersion)) {
_jsonRpcErrorCode = JsonRpcObject::JSON_RPC_INVALID_REQUEST_ERROR;
_jsonRpcErrorString = JsonRpcObject::JSON_RPC_INVALID_REQUEST_ERROR_MESSAGE;
_jsonRpcErrorData = "Incorrect JSON RPC version";
return nullptr;
if (JsonRpcObject::isValidJsonRpcRequest(_jsonObject)) {
return new JsonRpcRequest(_jsonObject);
if (JsonRpcObject::isValidJsonRpcResponse(_jsonObject)) {
return new JsonRpcResponse(_jsonObject);
if (JsonRpcObject::isValidJsonRpcNotification(_jsonObject)) {
return new JsonRpcNotification(_jsonObject);
_jsonRpcErrorCode = JsonRpcObject::JSON_RPC_INVALID_REQUEST_ERROR;
_jsonRpcErrorString = JsonRpcObject::JSON_RPC_INVALID_REQUEST_ERROR_MESSAGE;
return nullptr;
Example 47
static const char *parse_number(cJSON *item,const char *num)
double n=0,sign=1,scale=0;int subscale=0,signsubscale=1;
if (*num=='-') sign=-1,num++; /* Has sign? */
if (*num=='0') num++; /* is zero */
if (*num>='1' && *num<='9') do n=(n*10.0)+(*num++ -'0'); while (*num>='0' && *num<='9'); /* Number? */
if (*num=='.' && num[1]>='0' && num[1]<='9') {num++; do n=(n*10.0)+(*num++ -'0'),scale--; while (*num>='0' && *num<='9');} /* Fractional part? */
if (*num=='e' || *num=='E') /* Exponent? */
{ num++;if (*num=='+') num++; else if (*num=='-') signsubscale=-1,num++; /* With sign? */
while (*num>='0' && *num<='9') subscale=(subscale*10)+(*num++ - '0'); /* Number? */
Example 48
catch( const std::invalid_argument& e ) {
log( ERROR, "Error while parsing application/json request: %s", e.what() );
return false;
Example 49
BUILTIN(JsonParse) {
HandleScope scope(isolate);
Handle<Object> source = args.atOrUndefined(isolate, 1);
Handle<Object> reviver = args.atOrUndefined(isolate, 2);
Handle<String> string;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, string,
Object::ToString(isolate, source));
string = String::Flatten(isolate, string);
RETURN_RESULT_OR_FAILURE(
isolate, String::IsOneByteRepresentationUnderneath(*string)
? JsonParser<uint8_t>::Parse(isolate, string, reviver)
: JsonParser<uint16_t>::Parse(isolate, string, reviver));
Example 50
return;
if (contentType_ == CT_APPLICATION_JSON ||
getHeaderBy("content-type").find("application/json") !=
std::string::npos)
static std::once_flag once;
static Json::CharReaderBuilder builder;
std::call_once(once, []() { builder["collectComments"] = false; });
jsonPtr_ = std::make_shared<Json::Value>();
JSONCPP_STRING errs;
std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
if (!reader->parse(input.data(),
input.data() + input.size(),
jsonPtr_.get(),
&errs))
LOG_ERROR << errs;
jsonPtr_.reset();
Example 51
BulbId FUT089PacketFormatter::parsePacket(const uint8_t *packet, JsonObject result) {
if (stateStore == NULL) {
Serial.println(F("ERROR: stateStore not set. Prepare was not called! **THIS IS A BUG**"));
BulbId fakeId(0, 0, REMOTE_TYPE_FUT089);
return fakeId;
uint8_t packetCopy[V2_PACKET_LEN];
memcpy(packetCopy, packet, V2_PACKET_LEN);
V2RFEncoding::decodeV2Packet(packetCopy);
BulbId bulbId(
(packetCopy[2] << 8) | packetCopy[3],
packetCopy[7],
REMOTE_TYPE_FUT089
uint8_t command = (packetCopy[V2_COMMAND_INDEX] & 0x7F);
uint8_t arg = packetCopy[V2_ARGUMENT_INDEX];
if (command == FUT089_ON) {
if ((packetCopy[V2_COMMAND_INDEX] & 0x80) == 0x80) {
result[GroupStateFieldNames::COMMAND] = MiLightCommandNames::NIGHT_MODE;
} else if (arg == FUT089_MODE_SPEED_DOWN) {
result[GroupStateFieldNames::COMMAND] = MiLightCommandNames::MODE_SPEED_DOWN;
} else if
Example 52
BulbId FUT020PacketFormatter::parsePacket(const uint8_t* packet, JsonObject result) {
FUT020Command command = static_cast<FUT020Command>(packet[FUT02xPacketFormatter::FUT02X_COMMAND_INDEX] & 0x0F);
BulbId bulbId(
(packet[1] << 8) | packet[2],
REMOTE_TYPE_FUT020
switch (command) {
case FUT020Command::ON_OFF:
result[F("state")] = F("ON");
break;
case FUT020Command::BRIGHTNESS_DOWN:
result[F("command")] = F("brightness_down");
break;
case FUT020Command::BRIGHTNESS_UP:
result[F("command")] = F("brightness_up");
break;
case FUT020Command::MODE_SWITCH:
result[F("command")] = F("next_mode");
break;
case FUT020Command::COLOR_WHITE_TOGGLE:
result[F("command")] = F("color_white_toggle");
break;
case FUT020Command::COLOR:
uint16_t remappedColor = Units::rescale<uint16_t, uint16_t>(packet[FUT02xPacketFormatter::FUT02X_ARGUMENT_INDEX], 360.0, 255.0);
remappedColor = (remappedColor + 113) % 360;
result[GroupStateFieldNames::HUE] = remappedColor;
break;
return bulbId;
Example 53
util::Status JsonStreamParser::FinishParse() {
// If we do not expect anything and there is nothing left to parse we're all
// done.
if (stack_.empty() && leftover_.empty()) {
return util::Status::OK;
// Storage for UTF8-coerced string.
google::protobuf::scoped_array<char> utf8;
if (coerce_to_utf8_) {
utf8.reset(new char[leftover_.size()]);
char* coerced = internal::UTF8CoerceToStructurallyValid(leftover_, utf8.get(), ' ');
p_ = json_ = StringPiece(coerced, leftover_.size());
} else {
