Java Lookups类代码示例

import org.openide.util.lookup.Lookups; //导入依赖的package包/类
protected @Override void setUp() throws Exception {
    super.setUp();
    MockLookup.init();
    assertEquals("No factory has been used yet", 0, AnnotatedProject.factoryCalls);
    Collection<? extends AntBasedProjectType> all = Lookups.forPath("Services/AntBasedProjectTypes").lookupAll(AntBasedProjectType.class);
    assertEquals("Two found", 2, all.size());
    Iterator<? extends AntBasedProjectType> it = all.iterator();
    if ("testFactory".equals(getName())) {
        it.next();
    }
    AntBasedProjectType t = it.next();
    MockLookup.setInstances(t);
    scratch = TestUtil.makeScratchDir(this);
    projdir = scratch.createFolder("proj");
    ProjectGenerator.createProject(projdir, t.getType());
    pm = ProjectManager.getDefault();
}
 

import org.openide.util.lookup.Lookups; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
    lookup = Lookup.EMPTY;
    lookupProxy = Lookups.proxy(this);
    
    a1 = context(new SimpleCookieAction(), null, ContextSelection.EXACTLY_ONE, lookupProxy, Openable.class);
    a2 = context(new SimpleCookieAction(), this, ContextSelection.ANY, lookupProxy, Openable.class);
    any = context(new SimpleCookieAction(), null, ContextSelection.ANY, lookupProxy, Openable.class);
    each = context(new SimpleCookieAction(), null, ContextSelection.EACH, lookupProxy, Openable.class);
    all = context(new SimpleCookieAction(), null, ContextSelection.ALL, lookupProxy, Openable.class);
    n1 = new LookupWithOpenable();
    n2 = new LookupWithOpenable();
    n3 = new LookupWithOpenable(false);
    n4 = new LookupWithOpenable(n1.lookup(Openable.class)); // share the same cookie instance with n1
    
    SimpleCookieAction.runOn.clear();
}
 

import org.openide.util.lookup.Lookups; //导入依赖的package包/类
public void testArgsChanges() {
    final CompilerOptionsQueryImpl impl1 = new CompilerOptionsQueryImpl();
    final CompilerOptionsQueryImpl impl2 = new CompilerOptionsQueryImpl();
    impl1.addRoot(root1).addArgs("a1");   //NOI18N
    impl2.addRoot(root1).addArgs("b1");   //NOI18N
    final Lookup baseLkp = Lookups.fixed(
            impl1,
            impl2);
    final CompilerOptionsQueryImplementation merged =
            LookupMergerSupport.createCompilerOptionsQueryMerger()
            .merge(baseLkp);
    final CompilerOptionsQueryImplementation.Result res = merged.getOptions(root1);
    assertEquals(
            Arrays.asList("a1","b1"), //NOI18N
            res.getArguments());
    impl1.addArgs("a2");    //NOI18N
    assertEquals(
            Arrays.asList("a1","a2","b1"), //NOI18N
            res.getArguments());
    impl2.addArgs("b2");    //NOI18N
    assertEquals(
            Arrays.asList("a1","a2","b1","b2"), //NOI18N
            res.getArguments());
}
 

import org.openide.util.lookup.Lookups; //导入依赖的package包/类
public void test200843() throws IOException, InterruptedException, ExecutionException {
    FileObject testFile = projectDir.getFileObject("/src/simplej2seapp/D.java");
    JavaSource src = JavaSource.forFileObject(testFile);
    final WhereUsedQuery[] wuq = new WhereUsedQuery[1];
    src.runWhenScanFinished(new Task<CompilationController>() {

        @Override
        public void run(CompilationController controller) throws Exception {
            controller.toPhase(JavaSource.Phase.RESOLVED);
            ClassTree klass = (ClassTree) controller.getCompilationUnit().getTypeDecls().get(0);
            MethodTree runTree = (MethodTree) klass.getMembers().get(1);
            TreePath path = controller.getTrees().getPath(controller.getCompilationUnit(), runTree);
            TreePathHandle element = TreePathHandle.create(path, controller);
            Element method = controller.getTrees().getElement(path);
            Collection<ExecutableElement> overridens = JavaRefactoringUtils.getOverriddenMethods((ExecutableElement)method, controller);
            wuq[0] = new WhereUsedQuery(Lookups.singleton(TreePathHandle.create(overridens.iterator().next(), controller)));
            wuq[0].getContext().add(element);
        }
    }, false).get();
    setParameters(wuq, true, false, false, false, false, true);

    doRefactoring("test200843", wuq, 1);
}
 

import org.openide.util.lookup.Lookups; //导入依赖的package包/类
public void testChangeOfDefaultLookupAppliedToRPTask() throws Exception {
    Lookup prev = Lookup.getDefault();
    final Lookup my = new AbstractLookup(new InstanceContent());
    final Thread myThread = Thread.currentThread();
    final RequestProcessor.Task[] task = { null };
    final boolean[] ok = { false };
    
    Lookups.executeWith(my, new Runnable() {
        @Override
        public void run() {
            assertSame("Default lookup has been changed", my, Lookup.getDefault());

            if (task[0] == null) {
                assertSame("We are being executed in the same thread", myThread, Thread.currentThread());
                // once again in the RP
                task[0] = RequestProcessor.getDefault().post(this, 500);
            } else {
                ok[0] = true;
            }
        }
    });
    assertNotNull("In my lookup code executed OK", task[0]);
    assertEquals("Current lookup back to normal", prev, Lookup.getDefault());
    task[0].waitFinished();
    assertTrue("Even RP task had the right lookup", ok[0]);
}
 

import org.openide.util.lookup.Lookups; //导入依赖的package包/类
public void testDatabaseNotExtractedToExistingDirectoryIssue80122() {
    final Holder<Boolean> exceptionHappend = new Holder<>(false);
    
    Lookups.executeWith(sampleDBLookup, new Runnable() {

        @Override
        public void run() {
            try {
                File sampleDir = new File(systemHome, "sample");
                sampleDir.mkdirs();
                
                FileUtil.toFileObject(sampleDir).createData("test.file");

                assertEquals("There should be no files in the sample directory", 1, sampleDir.listFiles().length);

                DerbyDatabasesImpl.getDefault().extractSampleDatabase("sample", false);
            } catch (IOException ex) {
                exceptionHappend.value = true;
            }
        }
    });
    
    assertTrue("Extracting sample db was interrupted", exceptionHappend.value);
}
 

import org.openide.util.lookup.Lookups; //导入依赖的package包/类
public void testDatabaseNotExtractedIfDBExists() {
    final Holder<Boolean> exceptionHappend = new Holder<>(false);
    
    Lookups.executeWith(sampleDBLookup, new Runnable() {

        @Override
        public void run() {
            try {
                DerbyDatabasesImpl.getDefault().extractSampleDatabase("sample1", true);
                DerbyDatabasesImpl.getDefault().extractSampleDatabase("sample1", true);
            } catch (IOException ex) {
                exceptionHappend.value = true;
            }
        }
    });
    
    assertTrue("Extracting sample db was interrupted", exceptionHappend.value);
}
 

import org.openide.util.lookup.Lookups; //导入依赖的package包/类
public void mousePressed(MouseEvent ev) {
    if (ev.isPopupTrigger()) {
        int x = ev.getX();
        int y = ev.getY();
        TreePath path = view.getClosestPathForLocation(x, y);
        if (path != null) {
            LookTreeNode n = (LookTreeNode)path.getLastPathComponent();
            clicked = new WeakReference<LookTreeNode>(n);
            @SuppressWarnings("unchecked")
            Action[] actions = n.getLook().getActions(n.getData(), n.getLookup() );
            // XXX handle multiselects...
            Node selection = makeNode( n );
            Lookup context = Lookups.fixed(new Object[] {selection, actionMap});
            JPopupMenu menu = Utilities.actionsToPopup(actions, context);
            menu.show(view, x, y);
            // XXX selection does not appear to be collected... do we need to
            // also destroy the popup menu?
        }
    }
}
 

import org.openide.util.lookup.Lookups; //导入依赖的package包/类
public synchronized Collection<? extends String> getMimeTypes() {
    if (mimeTypes == null) {
        mimeTypes = new HashSet<String>();
        mimeTypes.add(""); //NOI18N

        // filter out mime types that don't supply customizers
        for(String mimeType : EditorSettings.getDefault().getAllMimeTypes()) {
            Lookup l = Lookups.forPath(FORMATTING_CUSTOMIZERS_FOLDER + mimeType);
            Collection<? extends PreferencesCustomizer.Factory> factories = l.lookupAll(PreferencesCustomizer.Factory.class);
            if (!factories.isEmpty()) {
                if (allowedMimeTypes == null || allowedMimeTypes.contains(mimeType)) {
                    mimeTypes.add(mimeType);
                }
            } else if (acceptOldControllers) {
                Collection<? extends OptionsPanelController> controllers = l.lookupAll(OptionsPanelController.class);
                if (!controllers.isEmpty()) {
                    if (allowedMimeTypes == null || allowedMimeTypes.contains(mimeType)) {
                        mimeTypes.add(mimeType);
                    }
                }
            }
        }
    }
    return mimeTypes;
}
 

import org.openide.util.lookup.Lookups; //导入依赖的package包/类
public ModelSource createTestModelSource(FileObject fo, boolean editable) throws CatalogModelException{
    final DataObject dobj;
    final CatalogModel catalogModel = createCatalogModel(fo);
    try {
        dobj = DataObject.find(fo);
    } catch (DataObjectNotFoundException ex) {
        throw new CatalogModelException(ex);
    }
    Lookup lookup = Lookups.proxy(new Lookup.Provider() {
        public Lookup getLookup() {
                    return Lookups.fixed(new Object[] {
                        dobj.getPrimaryFile(),
                        getDocument(dobj.getPrimaryFile()),
                        dobj,
                        catalogModel
                    });
        }
    } );
    return new ModelSource(lookup, editable);
}
 

import org.openide.util.lookup.Lookups; //导入依赖的package包/类
private Problem setParameters(boolean checkOnly) {
    if (panel == null) {
        return null;
    }
    URL url = URLMapper.findURL(panel.getRootFolder(), URLMapper.EXTERNAL);
    try {
        refactoring.setTarget(Lookups.singleton(new URL(url.toExternalForm() + panel.getPackageName().replace('.', '/')))); // NOI18N
    } catch (MalformedURLException ex) {
        Exceptions.printStackTrace(ex);
    }
    if (checkOnly) {
        return refactoring.fastCheckParameters();
    } else {
        return refactoring.checkParameters();
    }
}
 

import org.openide.util.lookup.Lookups; //导入依赖的package包/类
public void testCanBeReclaimedWithSimpleLookup() throws Exception {
    Project prj1 = new DummyProject();
    Project prj2 = new DummyProject();
    Lookup projects = Lookups.fixed(new Object[] {
        prj1,
        prj2,
    });
    
    ActionsUtil.getProjectsFromLookup(projects, null);
    
    WeakReference<?> ref1 = new WeakReference<Object>(prj1);
    WeakReference<?> ref2 = new WeakReference<Object>(prj2);
    WeakReference<?> lookup = new WeakReference<Object>(projects);
    
    prj1 = null;
    prj2 = null;
    projects = null;
    
    assertGC("the projects can be reclaimed", ref1);
    assertGC("the projects can be reclaimed", ref2);
    assertGC("the lookup can be reclaimed", lookup);
}
 

import org.openide.util.lookup.Lookups; //导入依赖的package包/类
public FixNode(ErrorDescription ed, FixDescription fix) {
    super(Children.LEAF, Lookups.fixed(new OpenCookieImpl(ed), fix));
    this.fix = fix;

    int line = -1;
    try {
        line = ed.getRange().getBegin().getLine();
    } catch (IOException ex) {
        Exceptions.printStackTrace(ex);
    }
    
    setDisplayName((line != (-1) ? (line + ":") : "") + fix.getText() + "(" + ed.getDescription() + ")");
    setIconBaseWithExtension("org/netbeans/modules/java/hints/analyzer/ui/suggestion.png");
    
    fix.addChangeListener(this);
}
 

import org.openide.util.lookup.Lookups; //导入依赖的package包/类
@Override
public void run() {
    err.fine("Warmup starting..."); // NOI18N
    StartLog.logStart("Warmup"); // NOI18N
    try {

    Collection<? extends Lookup.Item<Runnable>> warmObjects =
        Lookups.forPath("WarmUp").lookupResult(Runnable.class).allItems(); // NOI18N
    err.log(Level.FINE, "Found {0} warm up task(s)", warmObjects.size()); // NOI18N

    for (Lookup.Item<Runnable> warmer : warmObjects) {
        try {
            Runnable r = warmer.getInstance();
            r.run();
            StartLog.logProgress("Warmup task executed " + warmer.getId()); // NOI18N
        } catch (Exception ex) {
            Logger.getLogger(WarmUpSupport.class.getName()).log(Level.WARNING, null, ex);
        }
    }
    err.fine("Warmup done."); // NOI18N
    } finally {
    StartLog.logEnd("Warmup"); // NOI18N
    StartLog.impl.flush();
    }
}
 

import org.openide.util.lookup.Lookups; //导入依赖的package包/类
public void testContextInstancesDoNotInterfereWithEachOtherOrParent() throws Exception {
    System.out.println("testContextInstancesDoNotInterfereWithEachOtherOrParent");
    A a = new A();
    assertNull(Utilities.actionsGlobalContext().lookup(String.class)); //sanity check
    assertEquals("A", a.getValue(Action.NAME));
    Action a1 = a.createContextAwareInstance(Lookup.EMPTY);
    assertFalse(a.isEnabled());
    assertEquals("A", a1.getValue(Action.NAME));
    Action a2 = a.createContextAwareInstance(Lookups.fixed("testGeneralBehavior"));
    assertTrue(a2.isEnabled());
    assertFalse(a.isEnabled());
    setContent("foo");
    assertTrue(a.isEnabled());
    assertFalse(a1.isEnabled());
    assertTrue(a2.isEnabled());
    clearContent();
    assertFalse(a.isEnabled());
    assertTrue(a2.isEnabled());
}