static QVariant fromJson(const cJSON *json)
{
Q_ASSERT(json);
switch (json->type) {
case cJSON_False: return QVariant(false);
case cJSON_True: return QVariant(true);
case cJSON_NULL: return QVariant();
case cJSON_Number: return (json->valuedouble == json->valueint
? QVariant(json->valueint)
: QVariant(json->valuedouble));
case cJSON_String: return QVariant(QString::fromUtf8(json->valuestring));
case cJSON_Array: {
QVariantList list;
for (json=json->child; json; json = json->next)
list.append(fromJson(json));
return list; }
case cJSON_Object: {
QVariantMap map;
for (json=json->child; json; json = json->next)
map[json->string] = fromJson(json);
return map; }
default:
Q_ASSERT(0);
}
return QVariant();
}
QVariant NoronJsonBinarySerializer::deserialize(QByteArray bytes)
{
QJsonDocument doc = QJsonDocument::fromJson(bytes);
if(doc.isArray())
return fromJson(QJsonDocument::fromJson(bytes).array());
if(doc.isObject())
return fromJson(QJsonDocument::fromJson(bytes).object());
qWarning("Input string is not valid serialized json");
qWarning(bytes);
return QVariant();
}
bool fromJsonFile(const char * file, QVariant& var)
{
std::size_t length;
std::vector< char > buffer;
bool res = false;
try {
std::ifstream is(file);
if (!is.is_open()) return false;
// get length of file:
is.seekg (0, std::ios::end);
length = is.tellg();
is.seekg (0, std::ios::beg);
// allocate memory:
buffer.resize(length);
// read data as a block:
is.read (&(*buffer.begin()), length);
is.close();
res = fromJson(var, &(*buffer.begin()), length);
} catch (...) {
}
return res;
}
// static
PackageDescription* PackageDescription::fromFile(const std::string& filePath, const std::string& folderPath)
{
PackageDescription* packageDesc = NULL;
char* jsonStr = NULL;
jsonStr = readFile(filePath.c_str());
if (!jsonStr || !g_utf8_validate(jsonStr, -1, NULL)) {
return NULL;
}
struct json_object* root = json_tokener_parse(jsonStr);
if (!root || is_error( root )) {
g_warning("Failed to parse '%s' into a JSON string", filePath.c_str());
goto Done;
}
packageDesc = fromJson(root, folderPath);
Done:
if (root && !is_error(root))
json_object_put(root);
delete[] jsonStr;
return packageDesc;
}
std::shared_ptr<OneSixVersion> OneSixVersion::fromFile(QString filepath)
{
QFile file(filepath);
if (!file.open(QIODevice::ReadOnly))
{
return std::shared_ptr<OneSixVersion>();
}
auto data = file.readAll();
QJsonParseError jsonError;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &jsonError);
if (jsonError.error != QJsonParseError::NoError)
{
return std::shared_ptr<OneSixVersion>();
}
if (!jsonDoc.isObject())
{
return std::shared_ptr<OneSixVersion>();
}
QJsonObject root = jsonDoc.object();
auto version = fromJson(root);
if (version)
version->original_file = filepath;
return version;
}
bool Settings::readJsonFile(const std::string &filename) {
std::ifstream is(filename.c_str(), std::ios_base::binary);
if (!is.good())
return false;
Json::Value json;
is >> json;
return fromJson(json);
}
inline bool fromJson(const rapidjson::Value &v, const char *field, T &dst)
{
const rapidjson::Value::Member *member = v.FindMember(field);
if (!member)
return false;
return fromJson(member->value, dst);
}
void Settings::msgpack_unpack(msgpack::object o)
{
std::string data;
o.convert(&data);
std::istringstream os(data, std::ios_base::binary);
os >> m_json;
fromJson(m_json);
}
void childFromJson(const Json::Value& parent, T& ref, const char* name, const T& df) {
if (parent.isMember(name)) {
const Json::Value& v = parent[name];
fromJson(v, ref);
}
else {
ref = df;
}
}
void fromJsonArray(const Json::Value& parent, std::vector<T>& ref) {
ref.clear();
ref.reserve(parent.size());
for (Json::Value::const_iterator it = parent.begin(); it != parent.end(); ++it) {
T t;
fromJson(*it, t);
ref.push_back(t);
}
}
T as(const rapidjson::Value &v)
{
T result;
if (!fromJson(v, result)) {
FAIL("Conversion from JSON datatype failed");
return T();
}
return result;
}
void childFromJson(const Json::Value& parent, T& ref, const char* name) {
if (parent.isMember(name)) {
const Json::Value& v = parent[name];
fromJson(v, ref);
}
else {
PRINT_AND_THROW(boost::format("missing field: %s")%name);
}
}
static void fillFrom(const QJsonObject& jo, GetPushersJob::Pusher& result)
{
fromJson(jo.value("pushkey"_ls), result.pushkey);
fromJson(jo.value("kind"_ls), result.kind);
fromJson(jo.value("app_id"_ls), result.appId);
fromJson(jo.value("app_display_name"_ls), result.appDisplayName);
fromJson(jo.value("device_display_name"_ls), result.deviceDisplayName);
fromJson(jo.value("profile_tag"_ls), result.profileTag);
fromJson(jo.value("lang"_ls), result.lang);
fromJson(jo.value("data"_ls), result.data);
}
Bencode *Bencode::fromJson(const QVariant &json)
{
Bencode *res;
switch (json.type()) {
case QVariant::String:
res = new Bencode(toRawString(json.toString()));
break;
case QVariant::Map: {
QVariantMap variantMap = json.toMap();
res = new Bencode(Type::Dictionary);
QStringList keys = variantMap.keys();
foreach (const QString &key, keys) {
Bencode *newItem = fromJson(variantMap.value(key));
newItem->_key = key.toUtf8();
if (hexKeys.contains(QString(key)))
newItem->_hex = true;
res->appendChild(newItem);
}
break; }
case QVariant::List: {
QVariantList variantList = json.toList();
res = new Bencode(Type::List);
for (int i = 0; i < variantList.size(); ++i) {
res->appendChild(fromJson(variantList.at(i)));
}
break; }
case QVariant::UInt:
case QVariant::Int:
case QVariant::ULongLong:
case QVariant::LongLong:
case QVariant::Double:
res = new Bencode(json.toLongLong());
break;
default:
#ifdef DEBUG
qDebug() << "wrong variant" << json.type();
#endif
break;
}
void kJsonProtocolBase::fromBuffer(const unsigned char* pbuffer,unsigned int bufflen)
{
// alloc size here first,if not alloc,it will alloc each time when not enough
kByteBuffer kb(bufflen);
kb.putBytes(pbuffer, bufflen);
kb.getShort();
unsigned char buf[bufflen - sizeof(short)];
kb.getBytes(buf, bufflen - sizeof(short));
fromJson(std::string((char*)buf));
}
void QEditorSettings::init(const QByteArray &data){
m_content = data;
QJsonParseError error;
QJsonDocument jsondoc = QJsonDocument::fromJson(data, &error);
if ( error.error != QJsonParseError::NoError ){
emit initError(error.errorString());
qCritical("Failed to parse settings file: %s", qPrintable(error.errorString()));
}
fromJson(jsondoc.object());
}
bool fromJson(const rapidjson::Value &v, Path &dst)
{
std::string path;
bool result = fromJson(v, path);
dst = Path(path);
dst.freezeWorkingDirectory();
return result;
}
std::shared_ptr<AbstractPropertyType> amb::jsonToProperty(const picojson::value &json)
{
std::string name = json.get("name").to_str();
std::string type = json.get("type").to_str();
auto t = VehicleProperty::getPropertyTypeForPropertyNameValue(name);
if(!t)
{
bool ret = VehicleProperty::registerProperty(name, [name, type]() -> AbstractPropertyType* {
if(type == amb::BasicTypes::UInt16Str)
{
return new BasicPropertyType<uint16_t>(name, 0);
}
else if(type == amb::BasicTypes::Int16Str)
{
return new BasicPropertyType<int16_t>(name, 0);
}
else if(type == amb::BasicTypes::UInt32Str)
{
return new BasicPropertyType<uint32_t>(name, 0);
}
else if(type == amb::BasicTypes::Int32Str)
{
return new BasicPropertyType<int32_t>(name, 0);
}
else if(type == amb::BasicTypes::StringStr)
{
return new StringPropertyType(name);
}
else if(type == amb::BasicTypes::DoubleStr)
{
return new BasicPropertyType<double>(name, 0);
}
else if(type == amb::BasicTypes::BooleanStr)
{
return new BasicPropertyType<bool>(name, false);
}
DebugOut(DebugOut::Warning) << "Unknown or unsupported type: " << type << endl;
return nullptr;
});
if(!ret)
{
DebugOut(DebugOut::Error) << "failed to register property: " << name << endl;
return nullptr;
}
t = VehicleProperty::getPropertyTypeForPropertyNameValue(name);
}
t->fromJson(json);
return std::shared_ptr<AbstractPropertyType>(t);
}
void Canvas::onNewData(const QByteArray & array)
{
// static quint64 h_size = 0;
// if(historySize_) {
// h_size += array.size();
// qDebug()<<h_size<<historySize_;
// if(h_size < quint64(historySize_)){
// this->setDisabled(true);
// }else{
// historySize_ = 0;
// h_size = 0;
// this->setEnabled(true);
// qDebug()<<"enable!";
// }
// }
QVariantMap m = fromJson(array).toMap();
QString action = m["action"].toString().toLower();
if(action == "drawpoint"){
QPoint point;
QString layerName;
QVariantMap map = m["info"].toMap();
QVariantMap point_j = map["point"].toMap();
point.setX(point_j["x"].toInt());
point.setY(point_j["y"].toInt());
layerName = map["layer"].toString();
QVariantMap brushInfo = map["brush"].toMap();
quint64 userid = map["userid"].toLongLong();
remoteDrawPoint(point, brushInfo,
layerName, userid);
}else if(action == "drawline"){
QPoint start;
QPoint end;
QString layerName;
QVariantMap map = m["info"].toMap();
QVariantMap start_j = map["start"].toMap();
start.setX(start_j["x"].toInt());
start.setY(start_j["y"].toInt());
QVariantMap end_j = map["end"].toMap();
end.setX(end_j["x"].toInt());
end.setY(end_j["y"].toInt());
layerName = map["layer"].toString();
QVariantMap brushInfo = map["brush"].toMap();
quint64 userid = map["userid"].toLongLong();
remoteDrawLine(start, end,
brushInfo, layerName,
userid);
}
}
Response Response::fromString(const std::string &json)
{
Json::Reader reader;
Json::Value root;
if (reader.parse(json, root) == false)
throw Response(Response::Code::NotJson,
"No valid JSON");
return fromJson(root);
}
static QVariant fromJson(const QString &string)
{
if (string.isEmpty())
return QVariant();
cJSON *json = cJSON_Parse(string.toUtf8().constData());
if (!json) {
qWarning("Error parsing string:(%s): error: %s", qPrintable(string), cJSON_GetErrorPtr());
return QVariant();
}
const QVariant variant = fromJson(json);
cJSON_Delete(json);
return variant;
}
void kJsonProtocolBase::fromBufferDecryptJavaServer(const unsigned char* pbuffer,unsigned int bufflen)
{
// alloc size here first,if not alloc,it will alloc each time when not enough
kByteBuffer kb(bufflen);
kb.putBytes(pbuffer, bufflen);
kb.toSmallEndian();
kb.getShort();
int datalen = bufflen - sizeof(short);
unsigned char buf[datalen];
kb.getBytes(buf, datalen);
kCipher::decryptBuffer(buf, datalen);
fromJson(std::string((char*)buf));
}
/**
* @brief ServerCommunicator::requestFinished
* @param reply
*/
void ServerCommunicator::requestFinished(QNetworkReply *reply) {
if(reply->operation() == QNetworkAccessManager::GetOperation) {
QByteArray data = reply->readAll();
if(data.length() == 0) {
return;
}
QList<Note*> notes = fromJson(data);
for(int i = 0; i < notes.length(); i++) {
emit noteFetched(notes.at(i));
}
}
reply->deleteLater();
}
/**
* @brief Database::load
* @param errorList
*/
void Database::load(ErrorList &errorList)
{
QFile f(makeFullPath());
if (f.open(QIODevice::ReadOnly)) {
QJsonParseError errorMessage;
QJsonDocument jdoc(QJsonDocument::fromJson(f.readAll(), &errorMessage));
if (errorMessage.error == QJsonParseError::NoError) {
fromJson(jdoc.object(), errorList);
} else {
errorList << errorMessage.errorString();
}
} else {
errorList << QObject::tr("Can't load database: %1.").arg(f.fileName());
}
m_Valid = errorList.isEmpty();
}
bool Settings::fromJson(const Json::Value &json) {
if (!json.isObject())
return false;
m_json = json;
for (const auto & key: json.getMemberNames()) {
if (json[key].isObject()) {
//setJson(key, json[key]); // save type info
auto s = new Settings;
s->fromJson(json[key]);
setGroup(key, s);
} else if (json[key].isArray()) {
//setJson(key, json[key]);
} else {
set(key, json[key].asString());
m_json.removeMember(key); // todo: remove
}
}
return true;
}
static void fillFrom(const QJsonObject& jo, GetWhoIsJob::SessionInfo& result)
{
fromJson(jo.value("connections"_ls), result.connections);
}
static void fillFrom(const QJsonObject& jo, GetWhoIsJob::DeviceInfo& result)
{
fromJson(jo.value("sessions"_ls), result.sessions);
}
bool fromJson(const rapidjson::Value &v, Mat4f &dst)
{
if (v.IsArray()) {
ASSERT(v.Size() == 16, "Cannot convert Json Array to 4x4 Matrix: Invalid size");
for (unsigned i = 0; i < 16; ++i)
dst[i] = as<float>(v[i]);
return true;
} else if (v.IsObject()) {
Vec3f x(1.0f, 0.0f, 0.0f);
Vec3f y(0.0f, 1.0f, 0.0f);
Vec3f z(0.0f, 0.0f, 1.0f);
Vec3f pos(0.0f);
fromJson(v, "position", pos);
bool explicitX = false, explicitY = false, explicitZ = false;
Vec3f lookAt;
if (fromJson(v, "look_at", lookAt)) {
z = lookAt - pos;
explicitZ = true;
}
explicitY = fromJson(v, "up", y);
explicitX = fromJson(v, "x_axis", x) || explicitX;
explicitY = fromJson(v, "y_axis", y) || explicitY;
explicitZ = fromJson(v, "z_axis", z) || explicitZ;
int id =
(explicitZ ? 4 : 0) +
(explicitY ? 2 : 0) +
(explicitX ? 1 : 0);
switch (id) {
case 0: gramSchmidt(z, y, x); break;
case 1: gramSchmidt(x, z, y); break;
case 2: gramSchmidt(y, z, x); break;
case 3: gramSchmidt(y, x, z); break;
case 4: gramSchmidt(z, y, x); break;
case 5: gramSchmidt(z, x, y); break;
case 6: gramSchmidt(z, y, x); break;
case 7: gramSchmidt(z, y, x); break;
}
if (x.cross(y).dot(z) < 0.0f) {
if (!explicitX)
x = -x;
else if (!explicitY)
y = -y;
else
z = -z;
}
Vec3f scale;
if (fromJson(v, "scale", scale)) {
x *= scale.x();
y *= scale.y();
z *= scale.z();
}
Vec3f rot;
if (fromJson(v, "rotation", rot)) {
Mat4f tform = Mat4f::rotYXZ(rot);
x = tform*x;
y = tform*y;
z = tform*z;
}
dst = Mat4f(
x[0], y[0], z[0], pos[0],
x[1], y[1], z[1], pos[1],
x[2], y[2], z[2], pos[2],
0.0f, 0.0f, 0.0f, 1.0f
);
return true;
}
return false;
}
Door Door::fromJson(const std::string& json)
{
Any map = JSon::fromJson(json);
return fromJson(map.toMap());
}
JsonDocument JsonDocument::fromFilePath(const QString &path, bool allowComment)
{
QFile file(path);
file.open(QFile::ReadOnly);
return fromJson(file.readAll(), allowComment);
}
