Java AbstractLookup.Pair方法代码示例

import org.openide.util.lookup.AbstractLookup; //导入方法依赖的package包/类
static void enhancedQueryMode(Lookup lookup, Class<?> clazz) {
    Object type = QUERY_MODE.get();
    if (type != clazz) {
        return;
    }
    Collection<? extends Lookup.Item<?>> items = lookup.lookupResult(clazz).allItems();
    if (items.size() == 0) {
        return;
    }
    AbstractLookup.Pair[] arr = new AbstractLookup.Pair[items.size()];
    Iterator<? extends Lookup.Item> it = items.iterator();
    for (int i = 0; i < arr.length; i++) {
        arr[i] = new PairWrap(it.next());
    }
    QUERY_MODE.set(arr);
}
 

import org.openide.util.lookup.AbstractLookup; //导入方法依赖的package包/类
/** Exits query mode.
 */
static Collection<AbstractLookup.Pair> exitQueryMode(Object prev) {
    Object cookie = QUERY_MODE.get();
    QUERY_MODE.set(prev);

    if (cookie instanceof CookieSet.CookieEntry) {
        return Collections.singleton((AbstractLookup.Pair)new CookieEntryPair((CookieSet.CookieEntry) cookie));
    } else if (cookie instanceof AbstractLookup.Pair[]) {
        return Arrays.asList((AbstractLookup.Pair[])cookie);
    } else {
        return null;
    }
}
 

import org.openide.util.lookup.AbstractLookup; //导入方法依赖的package包/类
private void fillServiceInstance(Item<T> li) {
    String className = getClassName(li);
    Object instance = null;
    synchronized(instanceCache) {
        instance = instanceCache.get (className);
        Object origInstance = origInstanceCache.get(className);
        Item lastItem = lookupItemsCache.get(className);
        if (origInstance != null && li instanceof AbstractLookup.Pair &&
            lastItem != null && lastItem.getId().equals(li.getId())) {
            // Check whether the cached original instance was created by this lookup item.
            // If yes, we can use it, if not, we should create a new instance.
            // Verify whether the item is from the same registry file,
            // since there can be several registrations for one class instance.
            try {
                java.lang.reflect.Method creatorOfMethod = AbstractLookup.Pair.class.getDeclaredMethod("creatorOf", Object.class);
                creatorOfMethod.setAccessible(true);
                Object isCreator = creatorOfMethod.invoke(li, origInstance);
                if (logger.isLoggable(Level.FINE)) {
                    logger.fine("fillServiceInstance("+li+" [HASH = "+System.identityHashCode(li)+"]):");
                    logger.fine("  className = \""+className+"\", orig instance = "+origInstance+", instance = "+instance+", is creator of = "+isCreator);
                    if (lastItem != null) {
                        logger.fine("  last item was "+lastItem+" [HASH = "+System.identityHashCode(lastItem)+"])");
                    }
                    if (!Boolean.TRUE.equals(isCreator)) {
                        logger.fine("\n!!!\n"+li+" is not a creator of "+origInstance+" !\nCreating a new instance...");
                    }
                }
                if (!Boolean.TRUE.equals(isCreator)) {
                    instance = null;
                    instanceCache.remove(className);
                    origInstanceCache.remove(className);
                    lookupItemsCache.remove(className);
                }
            } catch (Exception ex) {
                Exceptions.printStackTrace(ex);
            }
        }
    }
    // remember the instance position for merge purpose: li.fo.getAttribute("position")
    int position = getPosition(li);
    while (elementPositions.size() < size()) {
        elementPositions.add(Integer.MAX_VALUE);
    }
    elementPositions.add(position);
    if (instance != null) {
        try {
            add(service.cast(instance), className);
        } catch (ClassCastException cce) {
            logger.log(Level.WARNING, null, cce);
        }
        listenOn(instance.getClass().getClassLoader());
    } else {
        add(new LazyInstance<T>(service, li));
    }
}