void newAssoc(Name name, Any obj) { PceITFSymbol symbol; Any old; if ( (old = getObjectAssoc(name)) ) deleteAssoc(old); deleteAssoc(obj); if ( onFlag(name, F_ITFNAME) ) { symbol = getMemberHashTable(NameToITFTable, name); symbol->object = obj; appendHashTable(ObjectToITFTable, obj, symbol); setFlag(obj, F_ASSOC); } else { symbol = newSymbol(obj, name); setFlag(name, F_ITFNAME); if ( isObject(obj) ) setFlag(obj, F_ASSOC); appendHashTable(ObjectToITFTable, obj, symbol); appendHashTable(NameToITFTable, name, symbol); } if ( isObject(obj) ) lockObj(obj); }
static status callCv(CObj host, CPointer function, int argc, Any *argv) { status rval; SendFunc f = (SendFunc) function->pointer; int n; for(n=0; n<argc; n++) if ( isObject(argv[n]) ) addCodeReference(argv[n]); switch(argc) { case 0: rval = (*f)(); break; case 1: rval = (*f)(argv[0]); break; case 2: rval = (*f)(argv[0], argv[1]); break; case 3: rval = (*f)(argv[0], argv[1], argv[2]); break; case 4: rval = (*f)(argv[0], argv[1], argv[2], argv[3]); break; case 5: rval = (*f)(argv[0], argv[1], argv[2], argv[3], argv[4]); break; case 6: rval = (*f)(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]); break; case 7: rval = (*f)(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]); break; case 8: rval = (*f)(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7]); break; case 9: rval = (*f)(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8]); break; default: rval = errorPce(host, NAME_tooManyArguments, argc); } for(n=0; n<argc; n++) if ( isObject(argv[n]) && !isFreedObj(argv[n]) ) delCodeReference(argv[n]); return rval ? SUCCEED : FAIL; }
const AST::MethodSet* getTypeMethodSet(Context& context, const AST::Type* const rawType) { assert(context.methodSetsComplete()); const auto type = rawType->resolveAliases(); assert(type->isObject() || type->isTemplateVar()); const auto templatedObject = lookupTemplatedObject(context.scopeStack()); const auto existingMethodSet = context.findMethodSet(templatedObject, type); if (existingMethodSet != nullptr) { return existingMethodSet; } // In static asserts we won't have a templated object (which would // normally be the containing alias, function or type instance), so // in this case we do NOT expect to see template variables. assert(type->isObject() || templatedObject != nullptr); const auto methodSet = type->isObject() ? getMethodSetForObjectType(context, type) : getMethodSetForTemplateVarType(context, type, *templatedObject); context.addMethodSet(templatedObject, type, methodSet); return methodSet; }
bool ASTType::equals(const ASTType& that) const { if ( (isObject() || isArray()) && that.isNull() ) { return true; } return mKind == that.mKind && (isObject() ? mpObjectClass == that.mpObjectClass : true); }
/*! \internal Returns the ID of this object, or -1 if this QScriptValue is not an object. \sa QScriptEngine::objectById() */ qint64 QScriptValue::objectId() const { if (!isObject()) return -1; QScriptValueImpl self = QScriptValuePrivate::valueOf(*this); return self.m_object_value->m_id; }
void ObjectNodeInstance::addToNewProperty(QObject *object, QObject *newParent, const PropertyName &newParentProperty) { QQmlProperty property(newParent, QString::fromUtf8(newParentProperty), context()); if (object) object->setParent(newParent); if (isList(property)) { QQmlListReference list = qvariant_cast<QQmlListReference>(property.read()); if (!QmlPrivateGate::hasFullImplementedListInterface(list)) { qWarning() << "Property list interface not fully implemented for Class " << property.property().typeName() << " in property " << property.name() << "!"; return; } list.append(object); } else if (isObject(property)) { property.write(objectToVariant(object)); if (QQuickItem *item = qobject_cast<QQuickItem *>(object)) if (QQuickItem *newParentItem = qobject_cast<QQuickItem *>(newParent)) item->setParentItem(newParentItem); } Q_ASSERT(objectToVariant(object).isValid()); }
void Json::set(const std::string& key, const Json& value) { if (isObject()) { json_object_set(m_json, key.c_str(), value.m_json); } else { throw std::domain_error("cannot use set() with this json type"); } }
static optional<std::unique_ptr<Source>> convertGeoJSONSource(const std::string& id, const Convertible& value, Error& error) { auto dataValue = objectMember(value, "data"); if (!dataValue) { error = { "GeoJSON source must have a data value" }; return {}; } optional<GeoJSONOptions> options = convert<GeoJSONOptions>(value, error); if (!options) { return {}; } auto result = std::make_unique<GeoJSONSource>(id, *options); if (isObject(*dataValue)) { optional<GeoJSON> geoJSON = convert<GeoJSON>(*dataValue, error); if (!geoJSON) { return {}; } result->setGeoJSON(std::move(*geoJSON)); } else if (toString(*dataValue)) { result->setURL(*toString(*dataValue)); } else { error = { "GeoJSON data must be a URL or an object" }; return {}; } return { std::move(result) }; }
bool Dictionary::getOwnPropertiesAsStringHashMap(HashMap<String, String>& hashMap) const { if (!isObject()) return false; v8::Handle<v8::Object> options = m_options->ToObject(); if (options.IsEmpty()) return false; v8::Local<v8::Array> properties = options->GetOwnPropertyNames(); if (properties.IsEmpty()) return true; for (uint32_t i = 0; i < properties->Length(); ++i) { v8::Local<v8::String> key = properties->Get(i)->ToString(); if (!options->Has(key)) continue; v8::Local<v8::Value> value = options->Get(key); String stringKey = toWebCoreString(key); String stringValue = toWebCoreString(value); if (!stringKey.isEmpty()) hashMap.set(stringKey, stringValue); } return true; }
Array::operator const Poco::Dynamic::Array& () const { if (!_pArray) { ValueVec::const_iterator it = _values.begin(); ValueVec::const_iterator end = _values.end(); _pArray = new Poco::Dynamic::Array; int index = 0; for (; it != end; ++it, ++index) { if (isObject(it)) { _pArray->insert(_pArray->end(), Poco::JSON::Object::makeStruct(getObject(index))); } else if (isArray(it)) { _pArray->insert(_pArray->end(), makeArray(getArray(index))); } else { _pArray->insert(_pArray->end(), *it); } } } return *_pArray; }
/**jsdoc * A material or set of materials such as may be used by a {@link Entities.EntityType|Material} entity. * @typedef {object} MaterialResource * @property {number} materialVersion=1 - The version of the material. <em>Currently not used.</em> * @property {Material|Material[]} materials - The details of the material or materials. */ NetworkMaterialResource::ParsedMaterials NetworkMaterialResource::parseJSONMaterials(const QJsonDocument& materialJSON, const QUrl& baseUrl) { ParsedMaterials toReturn; if (!materialJSON.isNull() && materialJSON.isObject()) { QJsonObject materialJSONObject = materialJSON.object(); for (auto& key : materialJSONObject.keys()) { if (key == "materialVersion") { auto value = materialJSONObject.value(key); if (value.isDouble()) { toReturn.version = (uint)value.toInt(); } } else if (key == "materials") { auto materialsValue = materialJSONObject.value(key); if (materialsValue.isArray()) { QJsonArray materials = materialsValue.toArray(); for (auto material : materials) { if (!material.isNull() && material.isObject()) { auto parsedMaterial = parseJSONMaterial(material.toObject(), baseUrl); toReturn.networkMaterials[parsedMaterial.first] = parsedMaterial.second; toReturn.names.push_back(parsedMaterial.first); } } } else if (materialsValue.isObject()) { auto parsedMaterial = parseJSONMaterial(materialsValue.toObject(), baseUrl); toReturn.networkMaterials[parsedMaterial.first] = parsedMaterial.second; toReturn.names.push_back(parsedMaterial.first); } } } } return toReturn; }
void ColorSchemePresets::reload() { m_valid = false; clear(); QFile file{ m_fileName }; if (!file.exists() || !file.open(QIODevice::ReadOnly | QIODevice::Text)) return; const auto json = QString::fromUtf8(file.readAll()); file.close(); std::unique_ptr<QJsonParseError> jsonParseError{ new QJsonParseError }; auto doc = QJsonDocument::fromJson(json.toUtf8(), jsonParseError.get()); static const auto warning = QString("Cannot retrieve color scheme presets from Json \"%1\": "); if (jsonParseError->error != QJsonParseError::NoError) { qWarning() << qPrintable(warning.arg(m_fileName) + jsonParseError->errorString()); return; } if (!doc.isObject()) { qWarning() << qPrintable(warning.arg(m_fileName) + " document is not an object."); return; } auto presets = doc.object(); m_valid = initialize(presets); }
void CMakeTool::fetchFromCapabilities() const { Utils::SynchronousProcessResponse response = run({ "-E", "capabilities" }, true); if (response.result != Utils::SynchronousProcessResponse::Finished) return; auto doc = QJsonDocument::fromJson(response.stdOut().toUtf8()); if (!doc.isObject()) return; const QVariantMap data = doc.object().toVariantMap(); m_hasServerMode = data.value("serverMode").toBool(); const QVariantList generatorList = data.value("generators").toList(); for (const QVariant &v : generatorList) { const QVariantMap gen = v.toMap(); m_generators.append(Generator(gen.value("name").toString(), gen.value("extraGenerators").toStringList(), gen.value("platformSupport").toBool(), gen.value("toolsetSupport").toBool())); } const QVariantMap versionInfo = data.value("version").toMap(); m_version.major = versionInfo.value("major").toInt(); m_version.minor = versionInfo.value("minor").toInt(); m_version.patch = versionInfo.value("patch").toInt(); m_version.fullVersion = versionInfo.value("string").toByteArray(); }
void HeadData::fromJson(const QJsonObject& json) { if (json.contains(JSON_AVATAR_HEAD_BLENDSHAPE_COEFFICIENTS)) { auto jsonValue = json[JSON_AVATAR_HEAD_BLENDSHAPE_COEFFICIENTS]; if (jsonValue.isArray()) { QVector<float> blendshapeCoefficients; QJsonArray blendshapeCoefficientsJson = jsonValue.toArray(); for (const auto& blendshapeCoefficient : blendshapeCoefficientsJson) { blendshapeCoefficients.push_back((float)blendshapeCoefficient.toDouble()); } setBlendshapeCoefficients(blendshapeCoefficients); } else if (jsonValue.isObject()) { QJsonObject blendshapeCoefficientsJson = jsonValue.toObject(); for (const QString& name : blendshapeCoefficientsJson.keys()) { float value = (float)blendshapeCoefficientsJson[name].toDouble(); setBlendshape(name, value); } } else { qWarning() << "Unable to deserialize head json: " << jsonValue; } } if (json.contains(JSON_AVATAR_HEAD_LOOKAT)) { auto relativeLookAt = vec3FromJsonValue(json[JSON_AVATAR_HEAD_LOOKAT]); if (glm::length2(relativeLookAt) > 0.01f) { setLookAtPosition((_owningAvatar->getOrientation() * relativeLookAt) + _owningAvatar->getPosition()); } } if (json.contains(JSON_AVATAR_HEAD_ROTATION)) { setHeadOrientation(quatFromJsonValue(json[JSON_AVATAR_HEAD_ROTATION])); } }
/*----------------------------------------------------------------------*/ static void showInstanceLocation(int ins, char *prefix) { char buffer[1000]; if (admin[ins].location == 0) return; else { output(prefix); if (isALocation(admin[ins].location)) { output("at"); say(admin[ins].location); sprintf(buffer, "[%d]", admin[ins].location); output(buffer); } else if (isContainer(admin[ins].location)) { if (isObject(admin[ins].location)) output("in"); else if (isActor(admin[ins].location)) output("carried by"); say(admin[ins].location); sprintf(buffer, "[%d]", admin[ins].location); output(buffer); } else output("Illegal location!"); } }
Response decode(QNetworkReply *reply) { Response r; auto data = reply->readAll(); r.code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(); if(r.code == 0) { r.error = reply->errorString(); return r; } QJsonParseError err{0, QJsonParseError::NoError}; auto json = QJsonDocument::fromJson(data, &err); if(err.error || !json.isObject()) { QString msg; msg = QObject::tr("Malformed response from server: %1").arg(err.errorString()); if(data.size()) { msg += QObject::tr("\nResponse was:\n%1").arg(QString::fromUtf8(data)); } r.error = msg; return r; } r.object = json.object(); if(r.code != 200) { r.error = r.object["error"].toString(); if(!r.error->size()) { r.error = QString("HTTP " + QString::number(r.code) + ": " + reply->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toString()); } } return r; }
void JsonWrapper::get( const char* name, const std::unordered_map<std::string, std::vector<std::string>>& dflt, std::unordered_map<std::string, std::vector<std::string>>& param) const { auto cfg = m_config[name]; param.clear(); if (cfg == Json::nullValue) { param = dflt; } else { if (!cfg.isObject()) { throw std::runtime_error("Cannot convert JSON value to object: " + cfg.asString()); } for (auto it = cfg.begin(); it != cfg.end(); ++it) { auto key = it.key(); if (!key.isString()) { throw std::runtime_error("Cannot convert JSON value to string: " + key.asString()); } auto& val = *it; if (!val.isArray()) { throw std::runtime_error("Cannot convert JSON value to array: " + val.asString()); } for (auto& str : val) { if (!str.isString()) { throw std::runtime_error("Cannot convert JSON value to string: " + str.asString()); } param[key.asString()].push_back(str.asString()); } } } }
ProxyConfig::ProxyConfig(proxy_t* proxy, const folly::dynamic& json, std::string configMd5Digest, std::shared_ptr<PoolFactory> poolFactory) : poolFactory_(std::move(poolFactory)), configMd5Digest_(std::move(configMd5Digest)) { McRouteHandleProvider provider(proxy, *proxy->destinationMap, *poolFactory_); RouteHandleFactory<McrouterRouteHandleIf> factory(provider); checkLogic(json.isObject(), "Config is not an object"); if (json.count("named_handles")) { checkLogic(json["named_handles"].isArray(), "named_handles is not array"); for (const auto& it : json["named_handles"]) { factory.create(it); } } RouteSelectorMap routeSelectors; auto jRoute = json.get_ptr("route"); auto jRoutes = json.get_ptr("routes"); checkLogic(!jRoute || !jRoutes, "Invalid config: both 'route' and 'routes' are specified"); checkLogic(jRoute || jRoutes, "No route/routes in config"); if (jRoute) { routeSelectors[proxy->getRouterOptions().default_route] = std::make_shared<PrefixSelectorRoute>(factory, *jRoute); } else { // jRoutes checkLogic(jRoutes->isArray() || jRoutes->isObject(), "Config: routes is not array/object"); if (jRoutes->isArray()) { for (const auto& it : *jRoutes) { checkLogic(it.isObject(), "RoutePolicy is not an object"); auto jCurRoute = it.get_ptr("route"); auto jAliases = it.get_ptr("aliases"); checkLogic(jCurRoute, "RoutePolicy: no route"); checkLogic(jAliases, "RoutePolicy: no aliases"); checkLogic(jAliases->isArray(), "RoutePolicy: aliases is not an array"); auto routeSelector = std::make_shared<PrefixSelectorRoute>(factory, *jCurRoute); for (const auto& alias : *jAliases) { checkLogic(alias.isString(), "RoutePolicy: alias is not a string"); routeSelectors[alias.stringPiece()] = routeSelector; } } } else { // object for (const auto& it : jRoutes->items()) { checkLogic(it.first.isString(), "RoutePolicy: alias is not a string"); routeSelectors[it.first.stringPiece()] = std::make_shared<PrefixSelectorRoute>(factory, it.second); } } } asyncLogRoutes_ = provider.releaseAsyncLogRoutes(); proxyRoute_ = std::make_shared<ProxyRoute>(proxy, routeSelectors); serviceInfo_ = std::make_shared<ServiceInfo>(proxy, *this); }
bool TypeConstraint::checkTypeAliasObj(const Class* cls) const { assert(isObject() && m_namedEntity && m_typeName); // Look up the type alias (autoloading if necessary) // and fail if we can't find it auto const td = getTypeAliasWithAutoload(m_namedEntity, m_typeName); if (!td) { return false; } // We found the type alias, check if an object of type cls // is compatible switch (getAnnotMetaType(td->type)) { case AnnotMetaType::Precise: return td->type == AnnotType::Object && td->klass && cls->classof(td->klass); case AnnotMetaType::Mixed: return true; case AnnotMetaType::Callable: return cls->lookupMethod(s___invoke.get()) != nullptr; case AnnotMetaType::Self: case AnnotMetaType::Parent: case AnnotMetaType::Number: case AnnotMetaType::ArrayKey: case AnnotMetaType::Dict: case AnnotMetaType::Vec: // Self and Parent should never happen, because type // aliases are not allowed to use those MetaTypes return false; } not_reached(); }
Object::operator const Poco::DynamicStruct& () const { if (!_pStruct) { ValueMap::const_iterator it = _values.begin(); ValueMap::const_iterator end = _values.end(); _pStruct = new Poco::DynamicStruct; for (; it != end; ++it) { if (isObject(it)) { _pStruct->insert(it->first, makeStruct(getObject(it->first))); } else if (isArray(it)) { _pStruct->insert(it->first, Poco::JSON::Array::makeArray(getArray(it->first))); } else { _pStruct->insert(it->first, it->second); } } } return *_pStruct; }
JSObject* JSCell::toObject(ExecState* exec, JSGlobalObject* globalObject) const { if (isString()) return static_cast<const JSString*>(this)->toObject(exec, globalObject); ASSERT(isObject()); return jsCast<JSObject*>(const_cast<JSCell*>(this)); }
void SandboxUtils::ifLocalSandboxRunningElse(std::function<void()> localSandboxRunningDoThis, std::function<void()> localSandboxNotRunningDoThat) { QNetworkAccessManager& networkAccessManager = NetworkAccessManager::getInstance(); QNetworkRequest sandboxStatus(SANDBOX_STATUS_URL); sandboxStatus.setAttribute(QNetworkRequest::FollowRedirectsAttribute, true); sandboxStatus.setHeader(QNetworkRequest::UserAgentHeader, HIGH_FIDELITY_USER_AGENT); QNetworkReply* reply = networkAccessManager.get(sandboxStatus); connect(reply, &QNetworkReply::finished, this, [reply, localSandboxRunningDoThis, localSandboxNotRunningDoThat]() { if (reply->error() == QNetworkReply::NoError) { auto statusData = reply->readAll(); auto statusJson = QJsonDocument::fromJson(statusData); if (!statusJson.isEmpty()) { auto statusObject = statusJson.object(); auto serversValue = statusObject.value("servers"); if (!serversValue.isUndefined() && serversValue.isObject()) { auto serversObject = serversValue.toObject(); auto serversCount = serversObject.size(); const int MINIMUM_EXPECTED_SERVER_COUNT = 5; if (serversCount >= MINIMUM_EXPECTED_SERVER_COUNT) { localSandboxRunningDoThis(); return; } } } } localSandboxNotRunningDoThat(); }); }
optional<std::unique_ptr<Source>> Converter<std::unique_ptr<Source>>::operator()(const Convertible& value, Error& error, const std::string& id) const { if (!isObject(value)) { error = { "source must be an object" }; return {}; } auto typeValue = objectMember(value, "type"); if (!typeValue) { error = { "source must have a type" }; return {}; } optional<std::string> type = toString(*typeValue); if (!type) { error = { "source type must be a string" }; return {}; } if (*type == "raster") { return convertRasterSource(id, value, error); } else if (*type == "vector") { return convertVectorSource(id, value, error); } else if (*type == "geojson") { return convertGeoJSONSource(id, value, error); } else if (*type == "image") { return convertImageSource(id, value, error); } else { error = { "invalid source type" }; return {}; } }
JSON::Pos JSON::skipObject() const { //std::cerr << "skipObject()\t" << data() << std::endl; if (!isObject()) throw JSONException("JSON: expected {"); Pos pos = ptr_begin; ++pos; checkPos(pos); if (*pos == '}') return ++pos; while (1) { pos = JSON(pos, ptr_end, level + 1).skipNameValuePair(); checkPos(pos); switch (*pos) { case ',': ++pos; break; case '}': return ++pos; default: throw JSONException(std::string("JSON: expected one of ',}', got ") + *pos); } } }
bool QScriptValueImpl::hasInstance(const QScriptValueImpl &value) const { Q_ASSERT(isObject()); if (QScriptClassData *odata = classInfo()->data()) { if (odata->implementsHasInstance(*this)) return odata->hasInstance(*this, value); } if (!isFunction()) return false; // [[HasInstance] for function objects if (!value.isObject()) return false; QScriptEnginePrivate *eng = engine(); QScriptValueImpl proto = property(eng->idTable()->id_prototype); if (!proto.isObject()) { QScriptContextPrivate *ctx = eng->currentContext(); ctx->throwTypeError(QLatin1String("instanceof: 'prototype' property is not an object")); return false; } QScriptObject *target = proto.m_object_value; QScriptValueImpl v = value; while (true) { v = v.prototype(); if (!v.isObject()) break; if (target == v.m_object_value) return true; } return false; }
bool DocumentAccessor::hasKey (std::string const& attribute) const { if (! isObject()) { return false; } if (_current == nullptr) { if (attribute.size() > 1 && attribute[0] == '_') { if (attribute == TRI_VOC_ATTRIBUTE_ID || attribute == TRI_VOC_ATTRIBUTE_KEY || attribute == TRI_VOC_ATTRIBUTE_REV) { return true; } if (TRI_IS_EDGE_MARKER(_mptr) && (attribute == TRI_VOC_ATTRIBUTE_FROM || attribute == TRI_VOC_ATTRIBUTE_TO)) { return true; } } auto shaper = _document->getShaper(); TRI_shape_pid_t pid = shaper->lookupAttributePathByName(attribute.c_str()); if (pid != 0) { return true; } return false; } return (TRI_LookupObjectJson(_current, attribute.c_str()) != nullptr); }
Json Json::get(const std::string& key) const { if (isObject()) { return Json(json_incref(json_object_get(m_json, key.c_str()))); } else { throw std::domain_error("This method only applies to object type"); } }
QString SimpleJsonDB::jsonString() { acquireWriteLock(); QString dbString = db->toJson(QMJsonFormat_Pretty, QMJsonSort_CaseSensitive); if (filterVmAndDomstoreKeys) { auto filteredValue = QMJsonValue::fromJson(dbString); if (filteredValue.isNull()) { qCritical("unable to convert db string to qmjsonvalue!"); exit(1); } if (!filteredValue->isObject()) { qCritical("db qmjsonvalue is not an object!"); exit(1); } filteredValue->toObject()->remove("vm"); filteredValue->toObject()->remove("dom-store"); dbString = filteredValue->toJson(QMJsonFormat_Pretty, QMJsonSort_CaseSensitive); } releaseWriteLock(); return dbString; }
bool Dictionary::getOwnPropertiesAsStringHashMap(HashMap<String, String>& hashMap) const { if (!isObject()) return false; v8::Handle<v8::Object> options = m_options->ToObject(); if (options.IsEmpty()) return false; v8::Local<v8::Array> properties = options->GetOwnPropertyNames(); if (properties.IsEmpty()) return true; for (uint32_t i = 0; i < properties->Length(); ++i) { v8::Local<v8::String> key = properties->Get(i)->ToString(); if (!options->Has(key)) continue; v8::Local<v8::Value> value = options->Get(key); V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringKey, key, false); V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringValue, value, false); if (!static_cast<const String&>(stringKey).isEmpty()) hashMap.set(stringKey, stringValue); } return true; }
// Metoda zwraca obiekt z obiektów const Json& Json::at(const std::string& arg) { if (isObject()) return value.object->at(arg); else throw std::domain_error("type is not object"); }