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