import org.netbeans.api.project.SourceGroup;

import org.netbeans.api.project.Sources;

import org.netbeans.modules.java.j2seproject.classpath.J2SEProjectClassPathModifier;

        final J2SEProjectClassPathModifier cpMod = new J2SEProjectClassPathModifier(this, this.updateHelper, eval, refHelper);

import org.netbeans.api.project.SourceGroup;

    private static final String JAVAC_CLASSPATH = "javac.classpath";    //NOI18N

    private static final String JAVAC_TEST_CLASSPATH = "javac.test.classpath";  //NOI18N

    private static final String RUN_CLASSPATH = "run.classpath";    //NOI18N

    private static final String RUN_TEST_CLASSPATH = "run.test.classpath";  //NOI18N

    }

    public String getPropertyName (SourceGroup sg, String classPathId) {

        FileObject root = sg.getRootFolder();

        FileObject[] path = getPrimarySrcPath();

        for (int i=0; i<path.length; i++) {

            if (root.equals(path[i])) {

                if (ClassPath.COMPILE.equals(classPathId)) {

                    return JAVAC_CLASSPATH;

                }

                else if (ClassPath.EXECUTE.equals(classPathId)) {

                    return RUN_CLASSPATH;

                }

                else {

                    return null;

                }

            }

        }

        path = getTestSrcDir();

        for (int i=0; i<path.length; i++) {

            if (root.equals(path[i])) {

                if (ClassPath.COMPILE.equals(classPathId)) {

                    return JAVAC_TEST_CLASSPATH;

                }

                else if (ClassPath.EXECUTE.equals(classPathId)) {

                    return RUN_TEST_CLASSPATH;

                }

                else {

                    return null;

                }

            }

        }

        return null;

import java.net.URL;

        return this.delegate.handleRoots(new URL[] {archiveFile.getURL()},classPathId,J2SEProjectClassPathModifier.ADD);

/*

 *                 Sun Public License Notice

 *

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 *

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.modules.java.j2seproject.classpath;

import java.beans.PropertyChangeListener;

import java.io.File;

import java.io.IOException;

import java.net.URI;

import java.net.URL;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import javax.swing.Icon;

import org.netbeans.api.java.classpath.ClassPath;

import org.netbeans.api.java.project.JavaProjectConstants;

import org.netbeans.api.project.Project;

import org.netbeans.api.project.ProjectManager;

import org.netbeans.api.project.SourceGroup;

import org.netbeans.api.project.Sources;

import org.netbeans.api.project.ant.AntArtifact;

import org.netbeans.api.project.libraries.Library;

import org.netbeans.modules.java.j2seproject.UpdateHelper;

import org.netbeans.modules.java.j2seproject.ui.customizer.J2SEProjectProperties;

import org.netbeans.spi.java.project.classpath.ProjectClassPathModifierImplementation;

import org.netbeans.spi.project.support.ant.AntProjectHelper;

import org.netbeans.spi.project.support.ant.EditableProperties;

import org.netbeans.spi.project.support.ant.PropertyEvaluator;

import org.netbeans.spi.project.support.ant.ReferenceHelper;

import org.openide.ErrorManager;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileUtil;

import org.openide.util.Mutex;

import org.openide.util.MutexException;

/**

 *@author Tomas Zezula

 *

 */

public class J2SEProjectClassPathModifier extends ProjectClassPathModifierImplementation {

    static final int ADD = 1;

    static final int REMOVE = 2;

    private final Project project;

    private final UpdateHelper helper;

    private final ReferenceHelper refHelper;

    private final PropertyEvaluator eval;    

    private final ClassPathSupport cs;    

    /** Creates a new instance of J2SEProjectClassPathModifier */

    public J2SEProjectClassPathModifier(final Project project, final UpdateHelper helper, final PropertyEvaluator eval, final ReferenceHelper refHelper) {

        assert project != null;

        assert helper != null;

        assert eval != null;

        assert refHelper != null;

        this.project = project;

        this.helper = helper;

        this.eval = eval;

        this.refHelper = refHelper;        

        this.cs = new ClassPathSupport( eval, refHelper, helper.getAntProjectHelper(), 

                                        J2SEProjectProperties.WELL_KNOWN_PATHS, 

                                        J2SEProjectProperties.LIBRARY_PREFIX, 

                                        J2SEProjectProperties.LIBRARY_SUFFIX, 

                                        J2SEProjectProperties.ANT_ARTIFACT_PREFIX );

    }

    protected SourceGroup[] getExtensibleSourceGroups() {

        Sources s = (Sources) this.project.getLookup().lookup(Sources.class);

        assert s != null;

        return s.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);

    }

    protected String[] getExtensibleClassPathTypes (SourceGroup sg) {

        return new String[] {

            ClassPath.COMPILE,

            ClassPath.EXECUTE

        };

    }

    protected boolean removeRoots(final URL[] classPathRoots, final SourceGroup sourceGroup, final String classPathId) throws IOException, UnsupportedOperationException {

        return handleRoots (classPathRoots, getClassPathProperty(sourceGroup, classPathId), REMOVE);

    }

    protected boolean addRoots (final URL[] classPathRoots, final SourceGroup sourceGroup, final String classPathId) throws IOException, UnsupportedOperationException {        

        return handleRoots (classPathRoots, getClassPathProperty(sourceGroup, classPathId), ADD);

    }

    boolean handleRoots (final URL[] classPathRoots, final String classPathProperty, final int operation) throws IOException, UnsupportedOperationException {

        assert classPathRoots != null : "The classPathRoots cannot be null";      //NOI18N        

        assert classPathProperty != null;

        try {

            return ((Boolean)ProjectManager.mutex().writeAccess(

                    new Mutex.ExceptionAction () {

                        public Object run() throws Exception {

                            EditableProperties props = helper.getProperties (AntProjectHelper.PROJECT_PROPERTIES_PATH);

                            String raw = props.getProperty(classPathProperty);                            

                            List resources = cs.itemsList( raw );

                            boolean changed = false;

                            for (int i=0; i< classPathRoots.length; i++) {

                                assert classPathRoots[i] != null;

                                assert classPathRoots[i].toExternalForm().endsWith("/");    //NOI18N

                                URL toAdd = FileUtil.getArchiveFile(classPathRoots[i]);

                                if (toAdd == null) {

                                    toAdd = classPathRoots[i];

                                }

                                File f = FileUtil.normalizeFile( new File (URI.create(toAdd.toExternalForm())));

                                if (f == null ) {

                                    throw new IllegalArgumentException ("The file must exist on disk");     //NOI18N

                                }

                                ClassPathSupport.Item item = ClassPathSupport.Item.create( f, null );

                                if (operation == ADD && !resources.contains(item)) {

                                    resources.add (item);

                                    changed = true;

                                }                            

                                else if (operation == REMOVE && resources.contains(item)) {

                                    resources.remove(item);

                                    changed = true;

                                }

                            }                                                                                                                

                            if (changed) {

                                String itemRefs[] = cs.encodeToStrings( resources.iterator() );

                                props = helper.getProperties (AntProjectHelper.PROJECT_PROPERTIES_PATH);  //PathParser may change the EditableProperties

                                props.setProperty(classPathProperty, itemRefs);

                                helper.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, props);

                                ProjectManager.getDefault().saveProject(project);

                                return Boolean.TRUE;

                            }

                            return Boolean.FALSE;

                        }

                    }

            )).booleanValue();

        } catch (Exception e) {

            if (e instanceof IOException) {

                throw (IOException) e;

            }

            else {

                Exception t = new IOException ();

                throw (IOException) ErrorManager.getDefault().annotate(t,e);

            }

        }

    }

    protected boolean removeAntArtifacts(final AntArtifact[] artifacts, final URI[] artifactElements, final SourceGroup sourceGroup, final String classPathId) throws IOException, UnsupportedOperationException {

        return handleAntArtifacts (artifacts, artifactElements, getClassPathProperty(sourceGroup, classPathId), REMOVE);

    }

    protected boolean addAntArtifacts(final AntArtifact[] artifacts, final URI[] artifactElements, final SourceGroup sourceGroup, final String classPathId) throws IOException, UnsupportedOperationException {

        return handleAntArtifacts (artifacts, artifactElements, getClassPathProperty(sourceGroup, classPathId), ADD);

    }

    boolean handleAntArtifacts (final AntArtifact[] artifacts, final URI[] artifactElements, final String classPathProperty, final int operation) throws IOException, UnsupportedOperationException {

        assert artifacts != null : "Artifacts cannot be null";    //NOI18N

        assert artifactElements != null : "ArtifactElements cannot be null";  //NOI18N

        assert artifacts.length == artifactElements.length : "Each artifact has to have corresponding artifactElement"; //NOI18N

        assert classPathProperty != null;

        try {

            return ((Boolean)ProjectManager.mutex().writeAccess(

                    new Mutex.ExceptionAction () {

                        public Object run() throws Exception {

                            EditableProperties props = helper.getProperties (AntProjectHelper.PROJECT_PROPERTIES_PATH);

                            String raw = props.getProperty (classPathProperty);

                            List resources = cs.itemsList( raw );

                            boolean changed = false;

                            for (int i=0; i<artifacts.length; i++) {

                                assert artifacts[i] != null;

                                assert artifactElements[i] != null;

                                ClassPathSupport.Item item = ClassPathSupport.Item.create( artifacts[i], artifactElements[i], null );

                                if (operation == ADD && !resources.contains(item)) {

                                    resources.add (item);

                                    changed = true;

                                }

                                else if (operation == REMOVE && resources.contains(item)) {

                                    resources.remove(item);

                                    changed = true;

                                }

                            }                            

                            if (changed) {

                                String itemRefs[] = cs.encodeToStrings( resources.iterator() );                                

                                props = helper.getProperties (AntProjectHelper.PROJECT_PROPERTIES_PATH);    //Reread the properties, PathParser changes them

                                props.setProperty (classPathProperty, itemRefs);

                                helper.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, props);

                                ProjectManager.getDefault().saveProject(project);

                                return Boolean.TRUE;

                            }

                            return Boolean.FALSE;

                        }

                    }

            )).booleanValue();

        } catch (Exception e) {

            if (e instanceof IOException) {

                throw (IOException) e;

            }

            else {

                Exception t = new IOException ();

                throw (IOException) ErrorManager.getDefault().annotate(t,e);

            }

        }

    }

    protected boolean removeLibraries(final Library[] libraries, final SourceGroup sourceGroup, final String classPathId) throws IOException, UnsupportedOperationException {

        return handleLibraries (libraries, getClassPathProperty(sourceGroup, classPathId), REMOVE);

    }

    protected boolean addLibraries(final Library[] libraries, final SourceGroup sourceGroup, final String classPathId) throws IOException, UnsupportedOperationException {

        return handleLibraries (libraries, getClassPathProperty(sourceGroup, classPathId), ADD);

    }

    boolean handleLibraries (final Library[] libraries, final String classPathProperty, final int operation) throws IOException, UnsupportedOperationException {

        assert libraries != null : "Libraries cannot be null";  //NOI18N

        assert classPathProperty != null;

        try {

            return ((Boolean)ProjectManager.mutex().writeAccess(

                    new Mutex.ExceptionAction () {

                        public Object run() throws IOException {

                            EditableProperties props = helper.getProperties (AntProjectHelper.PROJECT_PROPERTIES_PATH);

                            String raw = props.getProperty(classPathProperty);

                            List resources = cs.itemsList( raw );

                            List/*<ClassPathSupport.Item>*/ changed = new ArrayList/*<ClassPathSupport.Item>*/ (libraries.length);

                            for (int i=0; i< libraries.length; i++) {

                                assert libraries[i] != null;

                                ClassPathSupport.Item item = ClassPathSupport.Item.create( libraries[i], null );

                                if (operation == ADD && !resources.contains(item)) {

                                    resources.add (item);                                

                                    changed.add(item);

                                }

                                else if (operation == REMOVE && resources.contains(item)) {

                                    resources.remove(item);

                                    changed.add(item);

                                }

                            }

                            if (!changed.isEmpty()) {

                                String itemRefs[] = cs.encodeToStrings( resources.iterator() );                                

                                props = helper.getProperties (AntProjectHelper.PROJECT_PROPERTIES_PATH);    //PathParser may change the EditableProperties                                

                                props.setProperty(classPathProperty, itemRefs);                                

                                if (operation == ADD) {

                                    for (Iterator/*<ClassPathSupport.Item>*/ it = changed.iterator(); it.hasNext();) {

                                        String prop = cs.getLibraryReference( (ClassPathSupport.Item) it.next() );

                                        prop = prop.substring(2, prop.length()-1); // XXX make a PropertyUtils method for this!

                                        ClassPathSupport.relativizeLibraryClassPath(props, helper.getAntProjectHelper(), prop);

                                    }

                                }

                                helper.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, props);

                                ProjectManager.getDefault().saveProject(project);

                                return Boolean.TRUE;

                            }

                            return Boolean.FALSE;

                        }

                    }

            )).booleanValue();

        } catch (MutexException e) {

            throw (IOException) e.getException();

        }

    }

    private String getClassPathProperty (final SourceGroup sg, final String classPathId) throws UnsupportedOperationException {

        assert sg != null : "SourceGroup cannot be null";  //NOI18N

        assert classPathId != null : "ClassPathId cannot be null";  //NOI18N

        final String classPathProperty = ((ClassPathProviderImpl)project.getLookup().lookup(ClassPathProviderImpl.class)).getPropertyName (sg, classPathId);

        if (classPathProperty == null) {

            throw new UnsupportedOperationException ("Modification of [" + sg.getRootFolder().getPath() +", " + classPathId + "] is not supported"); //NOI8N

        }

        return classPathProperty;

    }

}

/*

 *                 Sun Public License Notice

 * 

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 * 

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.modules.java.j2seproject.classpath;

import java.beans.Customizer;

import java.beans.PropertyChangeListener;

import java.io.OutputStream;

import java.net.URL;

import java.util.Arrays;

import java.util.Collections;

import java.util.jar.JarFile;

import java.util.jar.JarOutputStream;

import java.util.zip.ZipEntry;

import java.util.zip.ZipOutputStream;

import junit.framework.*;

import java.io.File;

import java.io.IOException;

import java.net.URI;

import java.util.List;

import org.netbeans.api.java.classpath.ClassPath;

import org.netbeans.api.java.project.JavaProjectConstants;

import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;

import org.netbeans.api.project.FileOwnerQuery;

import org.netbeans.api.project.Project;

import org.netbeans.api.project.ProjectManager;

import org.netbeans.api.project.SourceGroup;

import org.netbeans.api.project.Sources;

import org.netbeans.api.project.TestUtil;

import org.netbeans.api.project.ant.AntArtifact;

import org.netbeans.api.project.libraries.Library;

import org.netbeans.api.project.libraries.LibraryManager;

import org.netbeans.junit.NbTestCase;

import org.netbeans.modules.java.j2seproject.J2SEProjectGenerator;

import org.netbeans.modules.java.j2seproject.UpdateHelper;

import org.netbeans.modules.java.j2seproject.ui.customizer.J2SEProjectProperties;

import org.netbeans.spi.java.project.classpath.ProjectClassPathExtender;

import org.netbeans.spi.project.ant.AntArtifactProvider;

import org.netbeans.spi.project.libraries.LibraryImplementation;

import org.netbeans.spi.project.libraries.LibraryProvider;

import org.netbeans.spi.project.libraries.LibraryTypeProvider;

import org.netbeans.spi.project.support.ant.AntProjectHelper;

import org.netbeans.spi.project.support.ant.EditableProperties;

import org.netbeans.spi.project.support.ant.PropertyEvaluator;

import org.netbeans.spi.project.support.ant.PropertyUtils;

import org.netbeans.spi.project.support.ant.ReferenceHelper;

import org.openide.ErrorManager;

import org.openide.filesystems.FileLock;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileUtil;

import org.openide.modules.SpecificationVersion;

import org.openide.util.Lookup;

import org.openide.util.Mutex;

import org.openide.util.MutexException;

/**

 *

 * @author tom

 */

public class J2SEProjectClassPathModifierTest extends NbTestCase {

    private FileObject scratch;

    private AntProjectHelper helper;

    private PropertyEvaluator eval;

    private FileObject src;

    private FileObject test;

    private Project prj;

    public J2SEProjectClassPathModifierTest(String testName) {

        super(testName);

    }       

    protected void setUp() throws Exception {

        super.setUp();

        TestUtil.setLookup(new Object[] {

            new org.netbeans.modules.java.j2seproject.J2SEProjectType(),

            new org.netbeans.modules.projectapi.SimpleFileOwnerQueryImplementation(),

            new TestLibraryProvider (),

        });

        this.scratch = TestUtil.makeScratchDir(this);

        FileObject projdir = scratch.createFolder("proj");  //NOI18N

        J2SEProjectGenerator.setDefaultSourceLevel(new SpecificationVersion ("1.4"));   //NOI18N    

        this.helper = J2SEProjectGenerator.createProject(FileUtil.toFile(projdir),"proj",null,null); //NOI18N

        this.eval = this.helper.getStandardPropertyEvaluator();

        J2SEProjectGenerator.setDefaultSourceLevel(null);

        this.prj = FileOwnerQuery.getOwner(projdir);

        assertNotNull (this.prj);

        this.src = projdir.getFileObject("src");

        assertNotNull (this.src);

        this.test = projdir.getFileObject("test");

        assertNotNull (this.test);

    }

    protected void tearDown() throws Exception {

    }

    public void testAddRemoveRoot () throws Exception {        

        final FileObject rootFolder = this.scratch.createFolder("Root");

        final FileObject jarFile = this.scratch.createData("archive","jar");

        FileLock lck = jarFile.lock();

        try {

            ZipOutputStream jf = new ZipOutputStream (jarFile.getOutputStream(lck));            

            try {

                jf.putNextEntry(new ZipEntry("Test.properties"));

            }finally {

                jf.close();

            }

        } finally {

            lck.releaseLock();

        }

        final FileObject jarRoot = FileUtil.getArchiveRoot(jarFile);

        ProjectClassPathModifier.addRoots (new URL[] {rootFolder.getURL()}, this.src, ClassPath.COMPILE);

        String cp = this.eval.getProperty("javac.classpath");

        assertNotNull (cp);

        String[] cpRoots = PropertyUtils.tokenizePath (cp);

        assertNotNull (cpRoots);

        assertEquals(1,cpRoots.length);

        assertEquals(rootFolder,this.helper.resolveFileObject(cpRoots[0]));

        ProjectClassPathModifier.removeRoots (new URL[] {rootFolder.getURL()},this.src, ClassPath.COMPILE);

        cp = this.eval.getProperty("javac.classpath");

        assertNotNull (cp);

        cpRoots = PropertyUtils.tokenizePath (cp);

        assertNotNull (cpRoots);

        assertEquals(0,cpRoots.length);

        ProjectClassPathModifier.addRoots(new URL[] {jarRoot.getURL()},this.test,ClassPath.EXECUTE);

        cp = this.eval.getProperty("run.test.classpath");

        assertNotNull (cp);

        cpRoots = PropertyUtils.tokenizePath (cp);

        assertNotNull (cpRoots);

        assertEquals(4,cpRoots.length);

        assertEquals(this.helper.resolveFileObject(cpRoots[3]),jarFile);

    }

    public void testAddRemoveArtifact () throws Exception {

        FileObject projdir = scratch.createFolder("libPrj");  //NOI18N

        J2SEProjectGenerator.setDefaultSourceLevel(new SpecificationVersion ("1.4"));   //NOI18N    

        AntProjectHelper helper = J2SEProjectGenerator.createProject(FileUtil.toFile(projdir),"libProj",null,null); //NOI18N        

        J2SEProjectGenerator.setDefaultSourceLevel(null);

        Project libPrj = FileOwnerQuery.getOwner(projdir);

        assertNotNull (this.prj);

        AntArtifactProvider ap = (AntArtifactProvider) libPrj.getLookup().lookup(AntArtifactProvider.class);

        AntArtifact[] aas = ap.getBuildArtifacts();

        AntArtifact output = null;

        for (int i=0; i<aas.length; i++) {

            if (JavaProjectConstants.ARTIFACT_TYPE_JAR.equals(aas[i].getType())) {

                output = aas[i];

                break;

            }

        }

        assertNotNull (output);

        ProjectClassPathModifier.addAntArtifacts(new AntArtifact[] {output}, new URI[] {output.getArtifactLocations()[0]}, this.src, ClassPath.COMPILE);

        String cp = this.eval.getProperty("javac.classpath");

        assertNotNull (cp);

        String[] cpRoots = PropertyUtils.tokenizePath (cp);

        assertNotNull (cpRoots);

        assertEquals(1,cpRoots.length);

        URI projectURI = URI.create(output.getProject().getProjectDirectory().getURL().toExternalForm());

        URI expected = projectURI.resolve(output.getArtifactLocations()[0]);

        assertEquals(expected,this.helper.resolveFile(cpRoots[0]).toURI());

        ProjectClassPathModifier.removeAntArtifacts(new AntArtifact[] {output}, new URI[] {output.getArtifactLocations()[0]},this.src, ClassPath.COMPILE);

        cp = this.eval.getProperty("javac.classpath");

        assertNotNull (cp);

        cpRoots = PropertyUtils.tokenizePath (cp);

        assertNotNull (cpRoots);

        assertEquals(0,cpRoots.length);

    }

    public void testAddRemoveLibrary () throws Exception {

        LibraryProvider lp = (LibraryProvider) Lookup.getDefault().lookup(LibraryProvider.class);

        assertNotNull (lp);

        LibraryImplementation[] impls = lp.getLibraries();

        assertNotNull (impls);

        assertEquals(1,impls.length);

        FileObject libRoot = this.scratch.createFolder("libRoot");

        impls[0].setContent("classpath",Collections.singletonList(libRoot.getURL()));

        Library[] libs =LibraryManager.getDefault().getLibraries();

        assertNotNull (libs);

        assertEquals(1,libs.length);                       

        ProjectClassPathModifier.addLibraries(libs, this.src, ClassPath.COMPILE);

        String cp = this.eval.getProperty("javac.classpath");

        assertNotNull (cp);

        String[] cpRoots = PropertyUtils.tokenizePath (cp);

        assertNotNull (cpRoots);

        assertEquals(1,cpRoots.length);

        assertEquals("${libs.Test.classpath}",cpRoots[0]);    //There is no build.properties filled, the libraries are not resolved

        ProjectClassPathModifier.removeLibraries(libs,this.src, ClassPath.COMPILE);

        cp = this.eval.getProperty("javac.classpath");

        assertNotNull (cp);

        cpRoots = PropertyUtils.tokenizePath (cp);

        assertNotNull (cpRoots);

        assertEquals(0,cpRoots.length);

    }

    public void testClassPathExtenderCompatibility () throws Exception {

        final FileObject rootFolder = this.scratch.createFolder("Root");

        final FileObject jarFile = this.scratch.createData("archive","jar");

        FileLock lck = jarFile.lock();

        try {

            ZipOutputStream jf = new ZipOutputStream (jarFile.getOutputStream(lck));            

            try {

                jf.putNextEntry(new ZipEntry("Test.properties"));

            }finally {

                jf.close();

            }

        } finally {

            lck.releaseLock();

        }

        final FileObject jarRoot = FileUtil.getArchiveRoot(jarFile);

        ProjectClassPathExtender extender = (ProjectClassPathExtender) this.prj.getLookup().lookup(ProjectClassPathExtender.class);

        assertNotNull (extender);

        extender.addArchiveFile(rootFolder);

        extender.addArchiveFile(jarFile);

        String cp = this.eval.getProperty("javac.classpath");

        assertNotNull (cp);

        String[] cpRoots = PropertyUtils.tokenizePath (cp);

        assertNotNull (cpRoots);

        assertEquals(2,cpRoots.length);

        assertEquals(rootFolder,this.helper.resolveFileObject(cpRoots[0]));

        assertEquals(jarFile,this.helper.resolveFileObject(cpRoots[1]));

    }

    private static class TestLibraryProvider implements LibraryProvider {

        private LibraryImplementation[] libs;

        public void removePropertyChangeListener(PropertyChangeListener listener) {

        }

        public void addPropertyChangeListener(PropertyChangeListener listener) {

        }

        public LibraryImplementation[] getLibraries() {

            if (libs == null) {

                this.libs = new LibraryImplementation[] { new TestLibrary ("Test")};

            }

            return this.libs;

        }

    }    

    private static class TestLibrary implements LibraryImplementation {

        private String name;

        private List cp = Collections.EMPTY_LIST;

        private List src = Collections.EMPTY_LIST;

        private List jdoc = Collections.EMPTY_LIST;

        public TestLibrary (String name) {

            this.name = name;

        }

        public void setName(String name) {

        }

        public void setLocalizingBundle(String resourceName) {

        }

        public void setDescription(String text) {

        }

        public List getContent(String volumeType) throws IllegalArgumentException {

            if ("classpath".equals(volumeType)) {

                return this.cp; 

            }

            else if ("src".equals(volumeType)) {

                return this.src;

            }

            else if ("jdoc".equals(volumeType)) {

                return this.jdoc;

            }

            throw new IllegalArgumentException ();

        }

        public void removePropertyChangeListener(PropertyChangeListener l) {

        }

        public void addPropertyChangeListener(PropertyChangeListener l) {

        }

        public void setContent(String volumeType, List path) throws IllegalArgumentException {

            if ("classpath".equals(volumeType)) {

                this.cp = path;

            }

            else if ("src".equals(volumeType)) {

                this.src = path;

            }

            else if ("jdoc".equals(volumeType)) {

                this.jdoc = path;

            }

            else {

                throw new IllegalArgumentException ();

            }

        }

        public String getType() {

            return "j2se";

        }

        public String getName() {

            return this.name;

        }

        public String getLocalizingBundle() {

            return null;

        }

        public String getDescription() {

            return null;

        }

    }

}

    <change id="ProjectClassPathModifier">

        <api name="classpath"/>

        <summary>New ProjectClassPathModifier API/SPI for modification of project's classpath</summary>

        <version major="1" minor="10"/>

        <date day="15" month="5" year="2006"/>

        <author login="tzezula"/>

        <compatibility addition="yes"/>

        <description>

        The new SPI interface ProjectClassPathModifierImplementation was created to allow extension modules to

        add or remove classpath elements (archive files, folders, libraries, subprojects) from the

        project's classpath. The ProjectClassPathModifierImplementation is provided by the project types in the

        project's Lookup. The API client uses the static methods of ProjectClassPathModifier which delegate to

        the SPI.

        </description>

        <class package="org.netbeans.api.java.project.classpath" name="ProjectClassPathModifier"/>

        <class package="org.netbeans.spi.java.project.classpath" name="ProjectClassPathModifierImplementation"/>

         <issue number="74356"/>

         <issue number="75469"/>

         <issue number="60852"/>

         <issue number="73197"/>

         <issue number="73198"/>

    </change>

javac.source=1.5

/*

 *                 Sun Public License Notice

 * 

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 * 

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.api.java.project.classpath;

import java.io.Externalizable;

import java.io.IOException;

import java.net.URI;

import java.net.URL;

import java.util.ArrayList;

import java.util.List;

import org.netbeans.api.java.classpath.ClassPath;

import org.netbeans.api.project.FileOwnerQuery;

import org.netbeans.api.project.Project;

import org.netbeans.api.project.SourceGroup;

import org.netbeans.api.project.ant.AntArtifact;

import org.netbeans.api.project.libraries.Library;

import org.netbeans.modules.java.project.classpath.ProjectClassPathModifierAccessor;

import org.netbeans.spi.java.project.classpath.ProjectClassPathExtender;

import org.netbeans.spi.java.project.classpath.ProjectClassPathModifierImplementation;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileUtil;

import org.openide.filesystems.URLMapper;

/**

 * An API for project's classpaths modification.

 * An client can use this interface to add/remove classpath element (folder, archive, library, subproject)

 * to/from the project's classpath. Not all operations on all project's classpath are supported, if the project

 * type does not support a modification of a given classpath the UnsupportedOperationException is thrown.

 * @since org.netbeans.modules.java.project/1 1.10

 */

public class ProjectClassPathModifier {

    private ProjectClassPathModifier () {

    }        

    /**

     * Adds libraries into the project's classpath if the

     * libraries are not already included.

     * @param libraries to be added

     * @param projectArtifact a file which classpath should be extended

     * @param classPathType the type of classpath to be extended, @see ClassPath

     * @return true in case the classpath was changed (at least one library was added to the classpath),

     * the value false is returned when all the libraries are already included on the classpath.

     * @exception IOException in case the project metadata cannot be changed

     * @exception UnsupportedOperationException is thrown when the project does not support

     * adding of a library to the classpath of the given id.

     */

    @SuppressWarnings("deprecation")    //NOI18N

    public static  boolean addLibraries (final Library[] libraries, final FileObject projectArtfact, final String classPathType) throws IOException, UnsupportedOperationException {

        final Extensible extensible = findExtensible (projectArtfact, classPathType);

        if (extensible != null) {            

            if (extensible.pcmi != null) {

                assert extensible.sg != null;

                assert extensible.classPathType != null;

                return ProjectClassPathModifierAccessor.INSTANCE.addLibraries (libraries, extensible.pcmi, extensible.sg, extensible.classPathType);

            }

            else if (extensible.pcpe != null) {

                boolean result = false;

                for (int i=0; i< libraries.length; i++) {

                    result |= extensible.pcpe.addLibrary (libraries[i]);

                }

                return result;

            }

        }

        throw new UnsupportedOperationException ();

    }

    /**

     * Removes libraries from the project's classpath if the

     * libraries are included on it.

     * @param libraries to be removed

     * @param projectArtfact a file from whose classpath the libraries should be removed

     * @param classPathType the type of classpath, @see ClassPath

     * @return true in case the classpath was changed, (at least one library was removed from the classpath),

     * the value false is returned when none of the libraries was included on the classpath.

     * @exception IOException in case the project metadata cannot be changed

     * @exception UnsupportedOperationException is thrown when the project does not support

     * removing of a library from the classpath of the given id.

     */

    public static boolean removeLibraries (final Library[] libraries, final FileObject projectArtfact, final String classPathType) throws IOException, UnsupportedOperationException {

        final Extensible extensible = findExtensible (projectArtfact, classPathType);

        if (extensible != null && extensible.pcmi != null) {

            assert extensible.sg != null;

            assert extensible.classPathType != null;

            return ProjectClassPathModifierAccessor.INSTANCE.removeLibraries (libraries, extensible.pcmi, extensible.sg, extensible.classPathType);

        }

        throw new UnsupportedOperationException ();

    }

    /**

     * Adds archive files or folders into the project's classpath if the

     * entries are not already there.

     * @param classPathRoots roots to be added, each root has to be either a root of an archive or a folder

     * @param projectArtfact a file which classpath should be extended

     * @param classPathType the type of classpath to be extended, @see ClassPath

     * @return true in case the classpath was changed, (at least one classpath root was added to the classpath),

     * the value false is returned when all the classpath roots are already included on the classpath.

     * @exception IOException in case the project metadata cannot be changed

     * @exception UnsupportedOperationException is thrown when the project does not support

     * adding of a root to the classpath of the given id.

     */

    @SuppressWarnings("deprecation")        //NOI18N

    public static boolean addRoots (final URL[] classPathRoots, final FileObject projectArtfact, final String classPathType) throws IOException, UnsupportedOperationException {

        final Extensible extensible = findExtensible(projectArtfact, classPathType);

        if (extensible != null) {

            if (extensible.pcmi != null) {

                assert extensible.sg != null;

                assert extensible.classPathType != null;

                return ProjectClassPathModifierAccessor.INSTANCE.addRoots (classPathRoots, extensible.pcmi, extensible.sg, extensible.classPathType);

            }

            else if (extensible.pcpe != null) {

                boolean result = false;

                for (int i=0; i< classPathRoots.length; i++) {

                    URL urlToAdd = classPathRoots[i];

                    if ("jar".equals(urlToAdd.getProtocol())) {

                        urlToAdd = FileUtil.getArchiveFile (urlToAdd);

                    }

                    final FileObject fo = URLMapper.findFileObject(urlToAdd);

                    if (fo == null) {

                        throw new UnsupportedOperationException ("Adding of a non existent root is not supported by project.");  //NOI18N

                    }

                    result |= extensible.pcpe.addArchiveFile (fo);

                }

                return result;

            }

        }

        throw new UnsupportedOperationException ();

    }

    /**

     * Removes archive files or folders from the project's classpath if the

     * entries are included on it.

     * @param classPathRoots roots to be removed, each root has to be either a root of an archive or a folder

     * @param projectArtfact a file from whose classpath the roots should be removed

     * @param classPathType the type of classpath, @see ClassPath

     * @return true in case the classpath was changed, (at least one classpath root was removed from the classpath),

     * the value false is returned when none of the classpath roots was included on the classpath.

     * @exception IOException in case the project metadata cannot be changed

     * @exception UnsupportedOperationException is thrown when the project does not support

     * removing of a root from the classpath of the given id.

     */

    public static boolean removeRoots (final URL[] classPathRoots, final FileObject projectArtfact, final String classPathType) throws IOException, UnsupportedOperationException {

        final Extensible extensible = findExtensible (projectArtfact, classPathType);

        if (extensible != null && extensible.pcmi != null) {

            assert extensible.sg != null;

            assert extensible.classPathType != null;

            return ProjectClassPathModifierAccessor.INSTANCE.removeRoots (classPathRoots, extensible.pcmi, extensible.sg, extensible.classPathType);

        }

        throw new UnsupportedOperationException ();

    }

    /**

     * Adds artifacts (e.g. subprojects) into project's classpath if the

     * artifacts are not already on it.

     * @param artifacts to be added

     * @param artifactElements the URIs of the build output, the artifactElements has to have the same length

     * as artifacts. 

     * (must be owned by the artifact and be relative to it)

     * @param projectArtfact a file which classpath should be extended

     * @param classPathType the type of classpath to be extended, @see ClassPath

     * @return true in case the classpath was changed, (at least one artifact was added to the classpath),

     * the value false is returned when all the artifacts are already included on the classpath.

     * @exception IOException in case the project metadata cannot be changed

     * @exception UnsupportedOperationException is thrown when the project does not support

     * adding of an artifact to the classpath of the given id.

     */

    @SuppressWarnings("deprecation")        //NOI18N

    public static boolean addAntArtifacts (final AntArtifact[] artifacts, final URI[] artifactElements,

            final FileObject projectArtfact, final String classPathType) throws IOException, UnsupportedOperationException {

        final Extensible extensible = findExtensible (projectArtfact, classPathType);

        if (extensible != null) {

            assert artifacts.length == artifactElements.length;

            if (extensible.pcmi != null) {

                assert extensible.sg != null;

                assert extensible.classPathType != null;

                return ProjectClassPathModifierAccessor.INSTANCE.addAntArtifacts (artifacts, artifactElements, extensible.pcmi, extensible.sg, extensible.classPathType);

            }

            else if (extensible.pcpe != null) {

                boolean result = false;

                for (int i=0; i< artifacts.length; i++) {

                    result |= extensible.pcpe.addAntArtifact (artifacts[i], artifactElements[i]);

                }

                return result;

            }

        }

        throw new UnsupportedOperationException ();

    }

    /**

     * Removes artifacts (e.g. subprojects) from project's classpath if the

     * artifacts are included on it.

     * @param artifacts to be added

     * @param artifactElements the URIs of the build output, the artifactElements has to have the same length

     * as artifacts.

     * (must be owned by the artifact and be relative to it)

     * @param projectArtfact a file from whose classpath the dependent projects should be removed

     * @param classPathType the type of classpath, @see ClassPath

     * @return true in case the classpath was changed, (at least one artifact was removed from the classpath),

     * the value false is returned when none of the artifacts was included on the classpath.

     * @exception IOException in case the project metadata cannot be changed

     * @exception UnsupportedOperationException is thrown when the project does not support

     * removing of an artifact from the classpath of the given id.

     */

    public static boolean removeAntArtifacts (final AntArtifact[] artifacts, final URI[] artifactElements,

            final FileObject projectArtifact, final String classPathType) throws IOException, UnsupportedOperationException {

        final Extensible extensible = findExtensible (projectArtifact, classPathType);

        if (extensible != null && extensible.pcmi != null) {

            assert extensible.sg != null;

            assert extensible.classPathType != null;

            return ProjectClassPathModifierAccessor.INSTANCE.removeAntArtifacts (artifacts, artifactElements, extensible.pcmi, extensible.sg, extensible.classPathType);

        }

        throw new UnsupportedOperationException ();

    }

    /**

     * Returns {@link ProjectClassPathModifier#Extensible} for given project artifact and classpath type. 

     * An Extensible implies a classpath to be extended. Different project type may provide different types

     * of Extensible.

     * @param projectArtifact a file owned by SourceGroup which classpath should be changed

     * @param classPathType a classpath type, @see ClassPath

     * @return an  Extensible or null. In case when the project supports the {@link ProjectClassPathModifierImplementation},

     * this interface is used to find an Extensible. If this interface is not provided, but project provides

     * the deprecated {@link ProjectClassPathExtender} interface and classpath type is {@link ClassPath@COMPILE} the 

     * single Extensible, without assigned SourceGroup, is returned.

     * In case when neither {@link ProjectClassPathModifierImplementation} nor {@link ProjectClassPathExtender}

     * is supported null is returned.

     */

    @SuppressWarnings("deprecation")        //NOI18N

    private static Extensible findExtensible (final FileObject fo, final String classPathType) {

        assert fo != null;

        assert classPathType != null;

        final Project project = FileOwnerQuery.getOwner(fo);

        if (project == null) {

            return null;

        }

        final ProjectClassPathModifierImplementation pm = (ProjectClassPathModifierImplementation) project.getLookup().lookup(ProjectClassPathModifierImplementation.class);

        if (pm != null) {            

            final SourceGroup[] sgs = ProjectClassPathModifierAccessor.INSTANCE.getExtensibleSourceGroups(pm);

            assert sgs != null   : "Class: " + pm.getClass() + " returned null as source groups.";    //NOI18N

            for (SourceGroup sg : sgs) {

                if ((fo == sg.getRootFolder() || FileUtil.isParentOf(sg.getRootFolder(),fo)) && sg.contains(fo)) {

                    final String[] types = ProjectClassPathModifierAccessor.INSTANCE.getExtensibleClassPathTypes(pm,sg);

                    assert types != null : "Class: " + pm.getClass() + " returned null as classpath types.";    //NOI18N

                    for (String type : types) {

                        if (classPathType.equals(type)) {

                            return new Extensible (pm, sg, type);

                        }

                    }

                }

            }

        }

        else if (classPathType.equals(ClassPath.COMPILE)) {

            final ProjectClassPathExtender pe = (ProjectClassPathExtender) project.getLookup().lookup(ProjectClassPathExtender.class);

            if (pe != null) {

                return new Extensible (pe);

            }

        }

        return null;

    }

    /**

     * Extensible represents a classpath which may be changed by the

     * {@link ProjectClassPathModifier}. It encapsulates the compilation

     * unit and class path type, @see ClassPath.

     */

    private static final class Extensible {

        private final String classPathType;       

        private final SourceGroup sg;

        private final ProjectClassPathModifierImplementation pcmi;

        @SuppressWarnings("deprecation")        //NOI18N

        private final ProjectClassPathExtender pcpe;

        private Extensible (final ProjectClassPathModifierImplementation pcmi , final SourceGroup sg, final String classPathType) {

            assert pcmi != null;

            assert sg != null;

            assert classPathType != null;

            this.pcmi = pcmi;

            this.sg = sg;

            this.classPathType = classPathType;

            this.pcpe = null;

        }

        @SuppressWarnings("deprecation")        //NOI18N

        private Extensible (final ProjectClassPathExtender pcpe) {

            assert pcpe != null;

            this.pcpe = pcpe;

            this.pcmi = null;

            this.sg = null;

            this.classPathType = ClassPath.COMPILE;

        }

    }    

}

/*

 *                 Sun Public License Notice

 * 

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 * 

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.modules.java.project.classpath;

import java.io.IOException;

import java.net.URI;

import java.net.URL;

import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;

import org.netbeans.api.project.SourceGroup;

import org.netbeans.api.project.ant.AntArtifact;

import org.netbeans.api.project.libraries.Library;

import org.netbeans.spi.java.project.classpath.ProjectClassPathModifierImplementation;

import org.openide.ErrorManager;

/**

 *

 * @author tom

 */

public abstract class ProjectClassPathModifierAccessor {

    public static ProjectClassPathModifierAccessor INSTANCE;

    static {

        Class c = ProjectClassPathModifierImplementation.class;

        try {

            Class.forName (c.getName(), true, c.getClassLoader());

        } catch (Exception ex) {

            ErrorManager.getDefault().notify(ex);

        }

    }

    /** Creates a new instance of ProjectClassPathModifierAccessor */

    public ProjectClassPathModifierAccessor() {

    }

    public abstract SourceGroup[] getExtensibleSourceGroups (ProjectClassPathModifierImplementation m);

    public abstract String[] getExtensibleClassPathTypes (ProjectClassPathModifierImplementation m, SourceGroup sg);

    public abstract boolean addLibraries (Library[] libraries, ProjectClassPathModifierImplementation m, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException;

    public abstract boolean removeLibraries (Library[] libraries, ProjectClassPathModifierImplementation m, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException;

    public abstract boolean addRoots (URL[] classPathRoots, ProjectClassPathModifierImplementation m, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException;

    public abstract boolean removeRoots (URL[] classPathRoots, ProjectClassPathModifierImplementation m, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException;

    public abstract boolean addAntArtifacts (AntArtifact[] artifacts, URI[] artifactElements, ProjectClassPathModifierImplementation m, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException;

    public abstract boolean removeAntArtifacts (AntArtifact[] artifacts, URI[] artifactElements, ProjectClassPathModifierImplementation m, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException;

}

     * @deprecated Please use {@link ProjectClassPathModifier#addLibrary} instead.

     * @deprecated Please use {@link ProjectClassPathModifier#addArchive} instead.

     * @deprecated Please use {@link ProjectClassPathModifier#addAntArtifact} instead.

/*

 *                 Sun Public License Notice

 *

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 *

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.spi.java.project.classpath;

import java.io.IOException;

import java.net.URI;

import java.net.URL;

import org.netbeans.api.project.SourceGroup;

import org.netbeans.api.project.ant.AntArtifact;

import org.netbeans.api.project.libraries.Library;

import org.netbeans.modules.java.project.classpath.ProjectClassPathModifierAccessor;

import org.openide.filesystems.FileObject;

/**

 * An SPI for project's classpaths modification.

 * A project can provide subclass of this class in its {@link org.netbeans.api.project.Project#getLookup lookup} to

 * allow clients to add or remove new classpath elements (JAR, folder, dependent project, or library) to its 

 * classpaths.

 * @since org.netbeans.modules.java.project/1 1.10

 */

public abstract class ProjectClassPathModifierImplementation {

    static {

        ProjectClassPathModifierAccessor.INSTANCE = new Accessor ();

    }    

    protected ProjectClassPathModifierImplementation () {

    }

    /**

     * Returns the {@link SourceGroup}s providing classpath(s)

     * which may be modified.

     * @return (possibly empty) array of {@link SourceGroup}, never returns null

     */

    protected abstract SourceGroup [] getExtensibleSourceGroups ();

    /**

     * Returns the types of classpaths for given {@link SourceGroup} which may be modified.

     * @param sourceGroup for which the classpath types should be returned

     * @return (possibly empty) array of classpath types, never returns null

     */

    protected abstract String[] getExtensibleClassPathTypes (SourceGroup sourceGroup);

    /**

     * Adds libraries into the project's classpath if the

     * libraries are not already included.

     * @param libraries to be added

     * @param sourceGroup of type {@link org.netbeans.api.java.project.JavaProjectConstants#SOURCES_TYPE_JAVA}

     * identifying the compilation unit to change

     * @param type the type of the classpath the library should be added to,

     * eg {@link org.netbeans.api.java.classpath.ClassPath.COMPILE}

     * @return true in case the classpath was changed (at least one library was added to the classpath),

     * the value false is returned when all the libraries are already included on the classpath.

     * @exception IOException in case the project metadata cannot be changed

     * @exception UnsupportedOperationException is thrown when the project does not support

     * adding of a library to the classpath of the given id.

     */

    protected abstract boolean addLibraries (Library[] libraries, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException;

    /**

     * Removes libraries from the project's classpath if the

     * libraries are included on it.

     * @param libraries to be removed

     * @param sourceGroup of type {@link org.netbeans.api.java.project.JavaProjectConstants#SOURCES_TYPE_JAVA}

     * identifying the compilation unit to change

     * @param type the type of the classpath the library should be removed from,

     * eg {@link org.netbeans.api.java.classpath.ClassPath.COMPILE}

     * @return true in case the classpath was changed, (at least one library was removed from the classpath),

     * the value false is returned when none of the libraries was included on the classpath.

     * @exception IOException in case the project metadata cannot be changed

     * @exception UnsupportedOperationException is thrown when the project does not support

     * removing of a library from the classpath of the given id.

     */

    protected abstract boolean removeLibraries (Library[] libraries, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException;

    /**

     * Adds archive files or folders into the project's classpath if the

     * entries are not already there.

     * @param classPathRoots roots to be added, each root has to be either a root of an archive or a folder

     * @param sourceGroup of type {@link org.netbeans.api.java.project.JavaProjectConstants#SOURCES_TYPE_JAVA}

     * identifying the compilation unit to change

     * @param type the type of the classpath the root should be added to,

     * eg {@link org.netbeans.api.java.classpath.ClassPath.COMPILE}

     * @return true in case the classpath was changed, (at least one classpath root was added to the classpath),

     * the value false is returned when all the classpath roots are already included on the classpath.

     * @exception IOException in case the project metadata cannot be changed

     * @exception UnsupportedOperationException is thrown when the project does not support

     * adding of a root to the classpath of the given id.

     */

    protected abstract boolean addRoots (URL[] classPathRoots, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException;

    /**

     * Removes archive files or folders from the project's classpath if the

     * entries are included on it.

     * @param classPathRoots roots to be removed, each root has to be either a root of an archive or a folder

     * @param sourceGroup of type {@link org.netbeans.api.java.project.JavaProjectConstants#SOURCES_TYPE_JAVA}

     * identifying the compilation unit to change

     * @param type the type of the classpath the root should be removed from,

     * eg {@link org.netbeans.api.java.classpath.ClassPath.COMPILE}

     * @return true in case the classpath was changed, (at least one classpath root was removed from the classpath),

     * the value false is returned when none of the classpath roots was included on the classpath.

     * @exception IOException in case the project metadata cannot be changed

     * @exception UnsupportedOperationException is thrown when the project does not support

     * removing of a root from the classpath of the given id.

     */

    protected abstract boolean removeRoots (URL[] classPathRoots, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException;

    /**

     * Adds artifacts (e.g. subprojects) into project's classpath if the

     * artifacts are not already on it.

     * @param artifacts to be added

     * @param artifactElements the URIs of the build output, the artifactElements has to have the same length

     * as artifacts. 

     * (must be owned by the artifact and be relative to it)

     * @param sourceGroup of type {@link org.netbeans.api.java.project.JavaProjectConstants#SOURCES_TYPE_JAVA}

     * identifying the compilation unit to change

     * @param type the type of the classpath the artifact should be added to,

     * eg {@link org.netbeans.api.java.classpath.ClassPath.COMPILE}

     * @return true in case the classpath was changed, (at least one artifact was added to the classpath),

     * the value false is returned when all the artifacts are already included on the classpath.

     * @exception IOException in case the project metadata cannot be changed

     * @exception UnsupportedOperationException is thrown when the project does not support

     * adding of an artifact to the classpath of the given id.

     */

    protected abstract boolean addAntArtifacts (AntArtifact[] artifacts, URI[] artifactElements, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException;

    /**

     * Removes artifacts (e.g. subprojects) from project's classpath if the

     * artifacts are included on it.

     * @param artifacts to be added

     * @param artifactElements the URIs of the build output, the artifactElements has to have the same length

     * as artifacts.

     * (must be owned by the artifact and be relative to it)

     * @param sourceGroup of type {@link org.netbeans.api.java.project.JavaProjectConstants#SOURCES_TYPE_JAVA}

     * identifying the compilation unit to change

     * @param type the type of the classpath the artifact should be removed from,

     * eg {@link org.netbeans.api.java.classpath.ClassPath.COMPILE}

     * @return true in case the classpath was changed, (at least one artifact was removed from the classpath),

     * the value false is returned when none of the artifacts was included on the classpath.

     * @exception IOException in case the project metadata cannot be changed

     * @exception UnsupportedOperationException is thrown when the project does not support

     * removing of an artifact from the classpath of the given id.

     */

    protected abstract boolean removeAntArtifacts (AntArtifact[] artifacts, URI[] artifactElements, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException;

    private static class Accessor extends ProjectClassPathModifierAccessor {        

        public SourceGroup[] getExtensibleSourceGroups(final ProjectClassPathModifierImplementation m) {

            assert m != null;

            return m.getExtensibleSourceGroups();

        }

        public String[] getExtensibleClassPathTypes (final ProjectClassPathModifierImplementation m, SourceGroup sg) {

            assert m != null;

            assert sg != null;

            return m.getExtensibleClassPathTypes(sg);

        }

        public boolean removeLibraries(Library[] libraries, ProjectClassPathModifierImplementation m, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException {

            assert m!= null;

            return m.removeLibraries(libraries, sourceGroup, type);

        }

        public boolean removeAntArtifacts(AntArtifact[] artifacts, URI[] artifactElements, ProjectClassPathModifierImplementation m, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException {

            assert m!= null;

            return m.removeAntArtifacts(artifacts, artifactElements, sourceGroup, type);

        }

        public boolean addLibraries (Library[] libraries, ProjectClassPathModifierImplementation m, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException {

            assert m!= null;

            return m.addLibraries(libraries, sourceGroup, type);

        }

        public boolean addAntArtifacts (AntArtifact[] artifacts, URI[] artifactElements, ProjectClassPathModifierImplementation m, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException {

            assert m!= null;

            return m.addAntArtifacts (artifacts, artifactElements, sourceGroup, type);

        }

        public boolean removeRoots (URL[] classPathRoots, ProjectClassPathModifierImplementation m, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException {

            assert m!= null;

            return m.removeRoots(classPathRoots, sourceGroup, type);

        }

        public boolean addRoots (URL[] classPathRoots, ProjectClassPathModifierImplementation m, SourceGroup sourceGroup, String type) throws IOException, UnsupportedOperationException {

            assert m!= null;

            return m.addRoots (classPathRoots, sourceGroup, type);

        }       

    }

}