Lookup a native pointer to a collider and return its Java object.

@param nativePointer native pointer to C++ Collider
@return Java GVRCollider object
482529
static GVRCollider lookup(long nativePointer)
    {
        synchronized (sColliders)
        {
            WeakReference<GVRCollider> weakReference = sColliders.get(nativePointer);
            return weakReference == null ? null : weakReference.get();
        }
    }
118348
@Override
    public FeatureCollector getCollector() {
        JiraMode mode = featureSettings.isJiraBoardAsTeam() ? JiraMode.Board : JiraMode.Team;
        FeatureCollector collector = FeatureCollector.prototype(mode);
        FeatureCollector existing = featureCollectorRepository.findByName(collector.getName());
        if (existing != null) {
            collector.setLastRefreshTime(existing.getLastRefreshTime());
        }
        return collector;
    }
42686
public static int cusolverRfAccessBundledFactorsDevice(
        cusolverRfHandle handle, 
        /** Output (in the host memory) */
        Pointer nnzM, 
        /** Output (in the device memory) */
        Pointer Mp, 
        Pointer Mi, 
        Pointer Mx)
    {
        return checkResult(cusolverRfAccessBundledFactorsDeviceNative(handle, nnzM, Mp, Mi, Mx));
    }
893352
public static StackTraceElement nativeElement(String declaringClass, String methodName) {
        return new StackTraceElement(declaringClass, methodName, null, -2);
    }
510507
@Override
    public ArrayList<InetAddress> getNaturalEndpoints(RingPosition searchPosition)
    {
        ArrayList<InetAddress> l = new ArrayList<InetAddress>(1);
        l.add(FBUtilities.getBroadcastAddress());
        return l;
    }
434118
public synchronized GeoInterface getGeoInterface() {
        if (geoInterface == null) {
            geoInterface = new GeoInterface(apiKey, sharedSecret, transport);
        }
        return geoInterface;
    }
856335
@Override
	public LayerRenderer getRenderer() {
		if (renderer == null) {
			renderer = new DomTileLevelLayerRenderer(viewPort, this, eventBus) {

				@Override
				public TileLevelRenderer createNewScaleRenderer(int tileLevel, View view, HtmlContainer container) {
					return new DomTileLevelRenderer(AbstractTileBasedLayer.this, tileLevel, viewPort, container,
							getTileRenderer());
				}
			};
		}
		return renderer;
	}
1347289
public static int nvgraphContractGraph(
        nvgraphHandle handle, 
        nvgraphGraphDescr descrG, 
        nvgraphGraphDescr contrdescrG, 
        Pointer aggregates, 
        long numaggregates, 
        int VertexCombineOp, 
        int VertexReduceOp, 
        int EdgeCombineOp, 
        int EdgeReduceOp, 
        int flag)
    {
        return checkResult(nvgraphContractGraphNative(handle, descrG, contrdescrG, aggregates, numaggregates, VertexCombineOp, VertexReduceOp, EdgeCombineOp, EdgeReduceOp, flag));
    }
1167617
public int seekKeyExact(long nativeValue)
    {
        if (positionCount == 0) {
            return -1;
        }

        mapBlock.ensureHashTableLoaded();
        int[] hashTable = mapBlock.getHashTables().get().get();

        long hashCode;
        try {
            hashCode = (long) mapBlock.keyNativeHashCode.invokeExact(nativeValue);
        }
        catch (Throwable throwable) {
            throw handleThrowable(throwable);
        }

        int hashTableOffset = offset / 2 * HASH_MULTIPLIER;
        int hashTableSize = positionCount / 2 * HASH_MULTIPLIER;
        int position = computePosition(hashCode, hashTableSize);
        while (true) {
            int keyPosition = hashTable[hashTableOffset + position];
            if (keyPosition == -1) {
                return -1;
            }
            Boolean match;
            try {
                // assuming maps with indeterminate keys are not supported
                match = (Boolean) mapBlock.keyBlockNativeEquals.invokeExact(mapBlock.getRawKeyBlock(), offset / 2 + keyPosition, nativeValue);
            }
            catch (Throwable throwable) {
                throw handleThrowable(throwable);
            }
            checkNotIndeterminate(match);
            if (match) {
                return keyPosition * 2 + 1;
            }
            position++;
            if (position == hashTableSize) {
                position = 0;
            }
        }
    }
956514
@Override
	protected ChainedResourceBundlePostProcessor getCustomProcessorWrapper(ResourceBundlePostProcessor customProcessor,
			String key, boolean isVariantPostProcessor) {

		return new CustomJsPostProcessorChainWrapper(key, customProcessor, isVariantPostProcessor);
	}
164092
@Override
    public Point3d get3DCenter() {
        double xOfCenter = 0;
        double yOfCenter = 0;
        double zOfCenter = 0;
        for (IAtom atom : atoms) {
            xOfCenter += atom.getPoint3d().x;
            yOfCenter += atom.getPoint3d().y;
            zOfCenter += atom.getPoint3d().z;
        }

        return new Point3d(xOfCenter / getAtomCount(), yOfCenter / getAtomCount(), zOfCenter / getAtomCount());
    }
63285
@Override
    public ConsumerManager getLocalPtoPConsumerManager()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "getLocalPtoPConsumerManager");

        ConsumerManager consumerManager = _targetDestinationHandler.getLocalPtoPConsumerManager();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "getLocalPtoPConsumerManager", consumerManager);

        return consumerManager;
    }
172299
function fetchObjectByPointer(pointer) {
  const collection = getCollection(pointer.className);
  const storedItem = collection[pointer.objectId];

  if (storedItem === undefined) {
    return undefined;
  }

  return Object.assign(
    { __type: 'Object', className: pointer.className },
    _.cloneDeep(storedItem)
  );
}
639945
@Override
    public ConsumerManager getLocalPtoPConsumerManager()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "getLocalPtoPConsumerManager");

        ConsumerManager consumerManager = null;

        consumerManager = _ptoPRealization.getLocalPtoPConsumerManager();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "getLocalPtoPConsumerManager", consumerManager);

        return consumerManager;
    }
153373
static float getRelativeY (NativeEvent e, Element target) {
    return (e.getClientY() - target.getAbsoluteTop() + target.getScrollTop() +
            target.getOwnerDocument().getScrollTop()) / HtmlGraphics.experimentalScale;
  }
517646
def lookup(self, opaque_ref):
        
        opaque_ref_value = self._get_reference_value(opaque_ref)
        # check local refs
        if opaque_ref_value in self.local_refs:
            return self.local_refs[opaque_ref_value]
        # check global refs
        if opaque_ref_value in self.global_refs:
            return self.global_refs[opaque_ref_value]
        raise KeyError("Unknown JNI reference %d. Local references: %s Global references: %s"
                       % (opaque_ref_value, self.local_refs, self.global_refs))
109878
public Point2D_F64 getCenter() {
		Rectangle r = getVisibleRect();
		
		double x = (r.x+r.width/2)/scale;
		double y = (r.y+r.height/2)/scale;

		return new Point2D_F64(x,y);
	}