<change id="Lookups.getLookupForPath">

        <api name="util"/>

        <summary>Added <code>Lookups.forPath(String)</code> method</summary>

        <version major="7" minor="7"/>

        <date day="11" month="1" year="2007"/>

        <author login="tboudreau"/>

        <compatibility addition="yes"/>

        <description>

            <p>

                Frequently modules create registries of objects in folders the system

                filesystem.  The process of creating a Lookup that contains all

                objects registered there has so far been rather arduous:

                <code>new FolderLookup (DataFolder.findFolder(

                Repository.getDefault().getDefaultFileSystem().getRoot().getFileObject(

                &quot;com/foo/bar&quot;))).getLookup()</code>

            </p>

            <p>

                Added the method <code>Lookups.forPath(String)</code>

                which simply does the same thing as the above code if

                the DataSystems API is on the path.  Added the interface

                org.openide.util.lookup.PathBasedLookupProvider, which the

                DataSystems API now implements (that's where FolderLookup lives).

                This should considerably simplify creation of registries of

                objects in the system filesystem, and also not require a hard

                dependency on the DataSystems API for anyone who wants to do

                such a thing.

            </p>

        </description>

        <class package="org.openide.util.lookup" name="Lookups"/>

        <class package="org.openide.util.lookup" name="PathBasedLookupProvider"/>

        <issue number="98426"/>

    </change>

import java.util.logging.Level;

import java.util.logging.Logger;

    }

    /**

     * Get a Lookup over a folder in the system filesystem which may have

     * objects registered in it (as <code>.instance</code>, <code>.settings</code>,

     * or any other file type whose DataObject provides an InstanceCookie).  

     * If your module defines a system filesystem folder which other modules

     * will register objects into, this is a convenient way of getting a 

     * Lookup containing all registered objects.

     * <p>

     * Note that this method is not entirely tied

     * to the system filesystem - whatever implements 

     * <a href="PathBasedLookupProvider.html">PathBasedLookupProvider</a>

     * provides what is returned by this method.

     * 

     * @since 7.8

     */ 

    public static Lookup forPath (String path) {

        PathBasedLookupProvider provider = Lookup.getDefault().lookup (

                PathBasedLookupProvider.class);

        if (provider == null) {

            Logger.getLogger(Lookups.class.getPackage().getName()).log(

                    Level.SEVERE,

                    "No PathBasedLookupProvider registered.  Probably " + //NOI18N

                    "the DataSystems API is not on the classpath"); //NOI18N

        }

        return provider == null ? Lookup.EMPTY : provider.getLookup(path);

/*

 * PathBasedLookupProvider.java

 *

 * Created on March 20, 2007, 10:06 PM

 *

 * To change this template, choose Tools | Template Manager

 * and open the template in the editor.

 */

package org.openide.util.lookup;

import org.openide.util.Lookup;

/**

 * Interface for the core system to install a factory for Lookups over the

 * system filesystem or other hierarchical namespace.  

 * <p>

 * <b>If you are implementing this interface, you are probably doing something

 * wrong.</b>

 * It is very unusual to need to implement this interface - 

 * by default the implementation is the DataSystems API module, and uses

 * FolderLookup over the system filesystem.  Implement only if you plan

 * to place it in the default lookup to entirely replace the backing storage

 * for registries of objects provided by the system filesystem (at least for

 * those modules which use <code>Lookups.forPath()</code>).

 * 

 * @since 7.8

 * @see org.openide.util.lookup.Lookups#forPath(java.lang.String)

 *

 * @author Tim Boudreau

 */

public interface PathBasedLookupProvider {

    /**

     * Get a Lookup over a named "folder" in a hierarchical

     * registry things can be registered into.  The default implementation

     * provides a Lookup over the specified folder in the system filesystem.

     * The specified path uses / for separators with no leading or trailing

     * /'s.

     * @param path A string path, such as <code>com/foo/bar</code>

     * @return A Lookup instance over that folder.

     */ 

    public Lookup getLookup (String path);

}

/*

 * PathBasedTest.java

 *

 * Created on March 20, 2007, 10:46 PM

 *

 * To change this template, choose Tools | Template Manager

 * and open the template in the editor.

 */

package org.openide.util.lookup;

import java.util.HashMap;

import java.util.Map;

import org.netbeans.junit.MockServices;

import org.netbeans.junit.NbTestCase;

import org.openide.util.Lookup;

/**

 * This is a class

 *

 * @author Tim Boudreau

 */

public class PathBasedTest extends NbTestCase {

    public PathBasedTest(String name) {

        super (name);

    }

    public void setUp() {

        MockServices.setServices (PBImpl.class);

    }

    public void testFindImpl() {

        assertNotNull(Lookup.getDefault().lookup (PathBasedLookupProvider.class));

    }

    public void testFindLookup() {

        String path = "com/foo/bar";

        Lookup lkp = Lookups.forPath(path);

        Lookup lkp2 = Lookups.forPath (path);

        assertSame (lkp, lkp2);

        InstanceContent ic = impl.contentFor(lkp);

        assertNotNull (ic);

    }

    static PBImpl impl = null;

    public static final class PBImpl implements PathBasedLookupProvider {

        Map <String, Lookup> m = new HashMap <String, Lookup> ();

        Map <Lookup, InstanceContent> l2ic = new HashMap<Lookup, InstanceContent>();

        public PBImpl() {

            PathBasedTest.impl = this;

        }

        InstanceContent contentFor (Lookup lkp) {

            return l2ic.get(lkp);

        }

        public Lookup getLookup(String path) {

            Lookup result = m.get (path);

            if (result == null) {

                InstanceContent content = new InstanceContent();

                result = new AbstractLookup(content);

                l2ic.put (result, content);

                m.put (path, result);

            }

            return result;

        }

    }

}

org.netbeans.modules.openide.loaders.PathLookupProvider

/*

 * PathLookupProvider.java

 *

 * Created on March 20, 2007, 10:10 PM

 *

 * To change this template, choose Tools | Template Manager

 * and open the template in the editor.

 */

package org.netbeans.modules.openide.loaders;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileUtil;

import org.openide.loaders.DataFolder;

import org.openide.loaders.FolderLookup;

import org.openide.util.Lookup;

import org.openide.util.lookup.Lookups;

import org.openide.util.lookup.PathBasedLookupProvider;

/**

 * This is a class

 *

 * @author Tim Boudreau

 */

public class PathLookupProvider implements PathBasedLookupProvider {

    public PathLookupProvider() {

    }

    public Lookup getLookup(String path) {

        Lookup result = null;

        FileObject ob = FileUtil.getConfigurationFolder(path, false);

        if (ob != null) {

            DataFolder fld = DataFolder.findFolder (ob);

            FolderLookup flookup = new FolderLookup (fld);

            result = fld.getLookup();

        }

        return result == null ? Lookup.EMPTY : result;

    }

}

/*

 * PathLookupProviderTest.java

 *

 * Created on March 20, 2007, 10:58 PM

 *

 * To change this template, choose Tools | Template Manager

 * and open the template in the editor.

 */

package org.openide.loaders;

import java.io.IOException;

import java.util.Collection;

import org.netbeans.junit.MockServices;

import org.netbeans.junit.NbTestCase;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileSystem;

import org.openide.filesystems.FileUtil;

import org.openide.filesystems.Repository;

import org.openide.loaders.PathLookupProviderTest.O;

import org.openide.util.Lookup;

import org.openide.util.lookup.Lookups;

/**

 * This is a class

 *

 * @author Tim Boudreau

 */

public class PathLookupProviderTest extends NbTestCase {

    /** Creates a new instance of PathLookupProviderTest */

    public PathLookupProviderTest(String name) {

        super (name);

    }

    FileObject data;

    static boolean objCreated = false;

    public void setUp() throws IOException {

        objCreated = false;

        MockServices.setServices (MyRepo.class);

        FileObject fld = FileUtil.getConfigurationFolder("somewhere/or/other", true);

        assertNotNull (fld);

        data = fld.createData ("org-openide-loaders-PathLookupProviderTest$O.instance");

    }

    public void testInstanceIsFound() {

        System.out.println("testInstanceIsFound");

        Lookup lkp = Lookups.forPath ("somewhere/or/other");

        assertNotNull (lkp);

        assertNotSame (Lookup.EMPTY, lkp);

        Collection <? extends O> c = lkp.lookupAll(O.class);

        assertTrue (objCreated);

        assertFalse (c.isEmpty());

    }

    public static class MyRepo extends Repository {

        static FileSystem sysfs;

        public MyRepo () {

            super(sysfs = FileUtil.createMemoryFileSystem());

        }

    }

    static char ch = 'A';

    public static final class O {

        private final String s;

        public O () {

            this ("" + (ch++));

        }

        O (String s) {

            this.s = s;

            objCreated = true;

        }

        public String toString() {

            return s;

        }

    }

}