Facebook/react-native
1
0
Fork 0
mirror of https://github.com/facebook/react-native.git synced 2025-11-01 09:14:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

remove useMapNativeAccessor stuff

Browse Source 
Summary:
This was quite a rabit hole of remove deps -> delete dead code -> repeat.

Waaay simpler now with less duplicate lookups, redundant type verification, and extra function calls.

Reviewed By: mdvacca

Differential Revision: D14486283

fbshipit-source-id: 035db30181755d046a1ae99760468b954b2449df
This commit is contained in:
Spencer Ahrens
2019-03-25 12:04:37 -07:00
committed by Facebook Github Bot
parent a46fba5dd3
commit b257e06bc6
6 changed files with 56 additions and 298 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ReactAndroid/src/main/java/com/facebook/react/bridge/ReadableNativeMap.java
+9 -112
View File
@@ -36,20 +36,14 @@ public class ReadableNativeMap extends NativeMap implements ReadableMap {
private @Nullable HashMap<String, ReadableType> mLocalTypeMap;
private static int mJniCallCounter;
public static void setUseNativeAccessor(boolean useNativeAccessor) {
ReactFeatureFlags.useMapNativeAccessor = useNativeAccessor;
}
public static int getJNIPassCounter() {
return mJniCallCounter;
}
private HashMap<String, Object> getLocalMap() {
// Fast return for the common case
if (mLocalMap != null) {
return mLocalMap;
}
// Check and when necessary get keys atomically
synchronized (this) {
if (mKeys == null) {
mKeys = Assertions.assertNotNull(importKeys());
@@ -73,11 +67,9 @@ public class ReadableNativeMap extends NativeMap implements ReadableMap {
private native Object[] importValues();
private @Nonnull HashMap<String, ReadableType> getLocalTypeMap() {
// Fast and non-blocking return for common case
if (mLocalTypeMap != null) {
return mLocalTypeMap;
}
// Check and when necessary get keys
synchronized (this) {
if (mKeys == null) {
mKeys = Assertions.assertNotNull(importKeys());
@@ -101,29 +93,17 @@ public class ReadableNativeMap extends NativeMap implements ReadableMap {
@Override
public boolean hasKey(@Nonnull String name) {
if (ReactFeatureFlags.useMapNativeAccessor) {
mJniCallCounter++;
return hasKeyNative(name);
}
return getLocalMap().containsKey(name);
}
private native boolean hasKeyNative(String name);
@Override
public boolean isNull(@Nonnull String name) {
if (ReactFeatureFlags.useMapNativeAccessor) {
mJniCallCounter++;
return isNullNative(name);
}
if (getLocalMap().containsKey(name)) {
return getLocalMap().get(name) == null;
}
throw new NoSuchKeyException(name);
}
private native boolean isNullNative(@Nonnull String name);
private @Nonnull Object getValue(@Nonnull String name) {
if (hasKey(name) && !(isNull(name))) {
return Assertions.assertNotNull(getLocalMap().get(name));
@@ -152,7 +132,7 @@ public class ReadableNativeMap extends NativeMap implements ReadableMap {
private void checkInstance(String name, Object value, Class type) {
if (value != null && !type.isInstance(value)) {
throw new ClassCastException(
throw new UnexpectedNativeTypeException(
"Value for "
+ name
+ " cannot be cast from "
@@ -164,86 +144,43 @@ public class ReadableNativeMap extends NativeMap implements ReadableMap {
@Override
public boolean getBoolean(@Nonnull String name) {
if (ReactFeatureFlags.useMapNativeAccessor) {
mJniCallCounter++;
return getBooleanNative(name);
}
return getValue(name, Boolean.class).booleanValue();
}
private native boolean getBooleanNative(String name);
@Override
public double getDouble(@Nonnull String name) {
if (ReactFeatureFlags.useMapNativeAccessor) {
mJniCallCounter++;
return getDoubleNative(name);
}
return getValue(name, Double.class).doubleValue();
}
private native double getDoubleNative(String name);
@Override
public int getInt(@Nonnull String name) {
if (ReactFeatureFlags.useMapNativeAccessor) {
mJniCallCounter++;
return getIntNative(name);
}
// All numbers coming out of native are doubles, so cast here then truncate
return getValue(name, Double.class).intValue();
}
private native int getIntNative(String name);
@Override
public @Nullable String getString(@Nonnull String name) {
if (ReactFeatureFlags.useMapNativeAccessor) {
mJniCallCounter++;
return getStringNative(name);
}
return getNullableValue(name, String.class);
}
private native String getStringNative(String name);
@Override
public @Nullable ReadableArray getArray(@Nonnull String name) {
if (ReactFeatureFlags.useMapNativeAccessor) {
mJniCallCounter++;
return getArrayNative(name);
}
return getNullableValue(name, ReadableArray.class);
}
private native ReadableNativeArray getArrayNative(String name);
@Override
public @Nullable ReadableNativeMap getMap(@Nonnull String name) {
if (ReactFeatureFlags.useMapNativeAccessor) {
mJniCallCounter++;
return getMapNative(name);
}
return getNullableValue(name, ReadableNativeMap.class);
}
private native ReadableNativeMap getMapNative(String name);
@Override
public @Nonnull ReadableType getType(@Nonnull String name) {
if (ReactFeatureFlags.useMapNativeAccessor) {
mJniCallCounter++;
return getTypeNative(name);
}
if (getLocalTypeMap().containsKey(name)) {
return Assertions.assertNotNull(getLocalTypeMap().get(name));
}
throw new NoSuchKeyException(name);
}
private native ReadableType getTypeNative(String name);
@Override
public @Nonnull Dynamic getDynamic(@Nonnull String name) {
return DynamicFromMap.create(this, name);
@@ -275,42 +212,6 @@ public class ReadableNativeMap extends NativeMap implements ReadableMap {
@Override
public @Nonnull HashMap<String, Object> toHashMap() {
if (ReactFeatureFlags.useMapNativeAccessor) {
ReadableMapKeySetIterator iterator = keySetIterator();
HashMap<String, Object> hashMap = new HashMap<>();
while (iterator.hasNextKey()) {
// increment for hasNextKey call
mJniCallCounter++;
String key = iterator.nextKey();
// increment for nextKey call
mJniCallCounter++;
switch (getType(key)) {
case Null:
hashMap.put(key, null);
break;
case Boolean:
hashMap.put(key, getBoolean(key));
break;
case Number:
hashMap.put(key, getDouble(key));
break;
case String:
hashMap.put(key, getString(key));
break;
case Map:
hashMap.put(key, Assertions.assertNotNull(getMap(key)).toHashMap());
break;
case Array:
hashMap.put(key, Assertions.assertNotNull(getArray(key)).toArrayList());
break;
default:
throw new IllegalArgumentException("Could not convert object with key: " + key + ".");
}
}
return hashMap;
}
// we can almost just return getLocalMap(), but we need to convert nested arrays and maps to the
// correct types first
HashMap<String, Object> hashMap = new HashMap<>(getLocalMap());
@@ -337,25 +238,21 @@ public class ReadableNativeMap extends NativeMap implements ReadableMap {
return hashMap;
}
/** Implementation of a {@link ReadableNativeMap} iterator in native memory. */
@DoNotStrip
private static class ReadableNativeMapKeySetIterator implements ReadableMapKeySetIterator {
@DoNotStrip private final HybridData mHybridData;
// Need to hold a strong ref to the map so that our native references remain valid.
@DoNotStrip private final ReadableNativeMap mMap;
private final Iterator<String> mIterator;
public ReadableNativeMapKeySetIterator(ReadableNativeMap readableNativeMap) {
mMap = readableNativeMap;
mHybridData = initHybrid(readableNativeMap);
mIterator = readableNativeMap.getLocalMap().keySet().iterator();
}
@Override
public native boolean hasNextKey();
public boolean hasNextKey() {
return mIterator.hasNext();
}
@Override
public native String nextKey();
private static native HybridData initHybrid(ReadableNativeMap readableNativeMap);
public String nextKey() {
return mIterator.next();
}
}
}