FailoverErrorsSettings::FailoverErrorsSettings(const folly::dynamic& json) {
checkLogic(json.isObject() || json.isArray(),
"Failover errors must be either an array or an object.");
if (json.isObject()) {
if (auto jsonGets = json.get_ptr("gets")) {
gets_ = FailoverErrorsSettings::List(*jsonGets);
}
if (auto jsonUpdates = json.get_ptr("updates")) {
updates_ = FailoverErrorsSettings::List(*jsonUpdates);
}
if (auto jsonDeletes = json.get_ptr("deletes")) {
deletes_ = FailoverErrorsSettings::List(*jsonDeletes);
}
} else if (json.isArray()) {
gets_ = FailoverErrorsSettings::List(json);
updates_ = FailoverErrorsSettings::List(json);
deletes_ = FailoverErrorsSettings::List(json);
}
}
fbstring phpSerialize(const folly::dynamic& d) {
if (d.isNull()) {
return "N;";
}
if (d.isBool()) {
return d.asBool() ? "b:1;" : "b:0;";
}
if (d.isInt()) {
return "i:" + d.asString() + ";";
}
if (d.isDouble()) {
return "d:" + d.asString() + ";";
}
if (d.isString()) {
auto str = d.asString();
return folly::to<fbstring>("s:", str.size(), ":\"", str, "\";");
}
if (d.isArray()) {
fbstring ret = folly::to<fbstring>("a:", d.size(), ":{");
int i = 0;
for (auto &v : d) {
ret += folly::to<fbstring>("i:", i, ";", phpSerialize(v));
}
return ret + "};";
}
if (d.isObject()) {
fbstring ret = folly::to<fbstring>("a:", d.size(), ":{");
int nextindex = 0;
for (auto &k : d.keys()) {
if (k.isNull()) {
ret += "i:0;";
if (nextindex <= 0) {
nextindex = 1;
}
} else if (k.isInt() || k.isDouble()) {
int i = k.asInt();
ret += folly::to<fbstring>("i:", i, ";");
if (nextindex <= i) {
nextindex = i + 1;
}
} else if (k.isString()) {
ret += folly::to<fbstring>("s:", k.size(), ":\"",
escapeCpp(k.asString()), "\";");
} else {
/* Should never be reached, but cover it to be safe */
ret += folly::to<fbstring>("i:", nextindex++, ";");
}
ret += phpSerialize(d[k]);
}
return ret + "};";
}
throw std::logic_error("Unhandled dynamic type in php serialization");
return "N;";
}
FailoverErrorsSettings::List::List(const folly::dynamic& json) {
checkLogic(json.isArray(), "List of failover errors is not an array.");
std::vector<std::string> errors;
errors.reserve(json.size());
for (const auto& elem : json) {
checkLogic(elem.isString(), "Failover error {} is not a string", elem);
errors.push_back(elem.getString());
}
init(std::move(errors));
}
bool anyFlags(std::function<bool(const fbstring&)> pred,
const folly::dynamic& flagsArray) {
if (!flagsArray.isArray()) {
return false;
}
for (auto const& strDyn : flagsArray) {
auto str = strDyn.asString();
if (pred(str)) {
return true;
}
}
return false;
}
static unsigned long parseFlags(const folly::dynamic &flags) {
if (flags.isNull()) {
return 0;
}
if (!flags.isArray()) {
throw std::logic_error("'flags' field must be an array");
}
unsigned long ret = 0;
for (auto &flag : flags) {
auto f = g_flagsMap.find(flag.asString());
if (f == g_flagsMap.end()) {
throw std::logic_error(
folly::format("Unknown flag '{0}' specified", flag.asString()).str()
);
}
ret |= f->second;
}
return ret;
}
jni::local_ref<NativeArray::jhybridobject>
createReadableNativeArrayWithContents(folly::dynamic array) {
if (array.isNull()) {
return jni::local_ref<NativeArray::jhybridobject>();
}
if (!array.isArray()) {
jni::throwNewJavaException("com/facebook/react/bridge/UnexpectedNativeTypeException",
"expected Array, got a %s", array.typeName());
}
static auto readableNativeArrayClass =
jni::findClassStatic("com/facebook/react/bridge/ReadableNativeArray");
static auto readableNativeArrayCtor =
readableNativeArrayClass->getConstructor<NativeArray::jhybridobject()>();
auto jnewArray = readableNativeArrayClass->newObject(readableNativeArrayCtor);
jni::cthis(jnewArray)->array = std::move(array);
return jnewArray;
}
// Infer type from an actual value, e.g. 123, "foo", null, true, etc...
static DataType kindOfFromValue(const folly::dynamic& v) {
if (v.isNull()) {
return KindOfNull;
}
if (v.isBool()) {
return KindOfBoolean;
}
if (v.isInt()) {
return KindOfInt64;
}
if (v.isDouble()) {
return KindOfDouble;
}
if (v.isString()) {
return KindOfString;
}
if (v.isArray()) {
return KindOfArray;
}
if (v.isObject()) {
return KindOfObject;
}
return KindOfInvalid;
}