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[] getExtendableSourceGroups() {

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

        assert s != null;

        return s.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);

    }

    protected String[] getExtendableClassPathTypes (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 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);

    }

    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.Extendable[] extendables = ProjectClassPathModifier.findExtendables(this.prj);

        assertNotNull (extendables);

        assertEquals(4,extendables.length);

        ProjectClassPathModifier.Extendable se=null, te=null;

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

            if (extendables[i].getSourceGroup().getRootFolder().getName().equals("src") && extendables[i].getClassPathType().equals(ClassPath.COMPILE)) {

                se = extendables[i];

            }

            else if (extendables[i].getSourceGroup().getRootFolder().getName().equals("test") && extendables[i].getClassPathType().equals(ClassPath.EXECUTE)) {

                te = extendables[i];

            }

        }

        assertNotNull(se);

        assertNotNull(te);

        ProjectClassPathModifier.addRoots (new URL[] {rootFolder.getURL()},se);

        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()},se);

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

        assertNotNull (cp);

        cpRoots = PropertyUtils.tokenizePath (cp);

        assertNotNull (cpRoots);

        assertEquals(0,cpRoots.length);

        ProjectClassPathModifier.addRoots(new URL[] {jarRoot.getURL()},te);

        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.Extendable[] extendables = ProjectClassPathModifier.findExtendables(this.prj);

        assertNotNull (extendables);

        assertEquals(4,extendables.length);

        ProjectClassPathModifier.Extendable se = null;

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

            if (extendables[i].getSourceGroup().getRootFolder().getName().equals("src") && extendables[i].getClassPathType().equals(ClassPath.COMPILE)) {

                se = extendables[i];

                break;

            }

        }                                

        ProjectClassPathModifier.addAntArtifacts(new AntArtifact[] {output}, new URI[] {output.getArtifactLocations()[0]},se);

        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]},se);

        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.Extendable[] extendables = ProjectClassPathModifier.findExtendables(this.prj);

        assertNotNull (extendables);

        assertEquals(4,extendables.length);

        ProjectClassPathModifier.Extendable se = null;

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

            if (extendables[i].getSourceGroup().getRootFolder().getName().equals("src") && extendables[i].getClassPathType().equals(ClassPath.COMPILE)) {

                se = extendables[i];

                break;

            }

        }        

        assertNotNull (se);

        ProjectClassPathModifier.addLibraries(libs,se);

        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,se);

        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 SPI for modification of project's classpath</summary>

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

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

        <author login="tzezula"/>

        <compatibility addition="yes"/>

        <description>

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

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

        project's classpath.

        </description>

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

         <issue number="74356"/>

         <issue number="75469"/>

         <issue number="60852"/>

    </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 or remove classpath element (folder, archive, library, subproject)

 * from the project's classpath. Not all operations on all project's classpath are supported. The client firstly

 * needs to obtain the list of {@link ProjectClassPathModifier#Extendable} representing the compilation unit's

 * classpaths which are allowed to change. Then the client may use the Extendable to change the project classpath.

 * <div class="nonnormative">

 * <p>

 * Typical usage would be:

 * </p>

 * <pre>

 * ProjectClassPathModifier.Extendable[] extendables = ProjectClassPathModifier.findExtendables (project);

 * if (extendables.length > 0) {

 *   //Select the right extendable - representing ClassPath.COMPILE on the sources

 *   ProjectClassPathModifier.Extendable extendable = null;

 *   for (ProjectClassPathModifier.Extendable e : extendables) {

 *       if (ClassPath.COMPILE.equals(e.getClassPathType()) && (e.getSourceGroup() == null || sources.equals(e.getSourceGroup()))) {

 *          extendable = e;

 *          break;

 *       }

 *   }

 *   if (extendable != null) {

 *      ProjectClassPathModifier.addLibrary (library, extendable);

 *   }

 * }

 * </pre>

 * </div>

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

 */

public class ProjectClassPathModifier {

    private ProjectClassPathModifier () {

    }

    /**

     * Returns {@link ProjectClassPathModifier#Extendable}s for given project. An Extendable

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

     * of Extendable.

     * @param project a project for which the Extendable should be found

     * @return an array (may be empty) of Extendable, never returns null. In case when the

     * project supports the {@link ProjectClassPathModifierImplementation}, the interface is

     * used to create the Extendables. If this interface is not provided, but project provides

     * the deprecated {@link ProjectClassPathExtender} interface, the single Extendable, which

     * {@link ProjectClassPathExtender#Extendable#getSourceGroup} method returns null, is returned.

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

     * is supported an empty array is returned.

     */

    public static Extendable[] findExtendables (final Project project) {

        final List/*<Extendable>*/ result = new ArrayList/*<Externalizable>*/();

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

        if (pm != null) {            

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

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

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

                final String[] types = ProjectClassPathModifierAccessor.INSTANCE.getExtendableClassPathTypes(pm,sgs[i]);

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

                for (int j=0; j<types.length; j++) {

                    result.add (new Extendable (pm, sgs[i], types[j]));

                }

            }

        }

        else {

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

            if (pe != null) {

                result.add (new Extendable (pe));

            }

        }

        return (Extendable[]) result.toArray(new Extendable[result.size()]);

    }

    /**

     * Adds libraries into the project's classpath if the

     * libraries are not already included.

     * @param libraries to be added

     * @param extendable to add the libraries into.

     * @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.

     */

    public static boolean addLibraries (final Library[] libraries, final Extendable extendable) throws IOException, UnsupportedOperationException {

        if (extendable.pcmi != null) {

            assert extendable.sg != null;

            assert extendable.classPathType != null;

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

        }

        else if (extendable.pcpe != null) {

            boolean result = false;

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

                result |= extendable.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 extendable to remove the libraries from

     * @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 Extendable extendable) throws IOException, UnsupportedOperationException {

        if (extendable.pcmi != null) {

            assert extendable.sg != null;

            assert extendable.classPathType != null;

            return ProjectClassPathModifierAccessor.INSTANCE.removeLibraries (libraries, extendable.pcmi, extendable.sg, extendable.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 extendable to add the classPathRoots into.

     * @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.

     */

    public static boolean addRoots (final URL[] classPathRoots, final Extendable extendable) throws IOException, UnsupportedOperationException {

        if (extendable.pcmi != null) {

            assert extendable.sg != null;

            assert extendable.classPathType != null;

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

        }

        else if (extendable.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 |= extendable.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 extendable to remove the classPathRoots from

     * @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 Extendable extendable) throws IOException, UnsupportedOperationException {

        if (extendable.pcmi != null) {

            assert extendable.sg != null;

            assert extendable.classPathType != null;

            return ProjectClassPathModifierAccessor.INSTANCE.removeRoots (classPathRoots, extendable.pcmi, extendable.sg, extendable.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 extendable to add the artifacts into.     

     * @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.

     */

    public static boolean addAntArtifacts (final AntArtifact[] artifacts, final URI[] artifactElements, final Extendable extendable) throws IOException, UnsupportedOperationException {

        assert artifacts.length == artifactElements.length;

        if (extendable.pcmi != null) {

            assert extendable.sg != null;

            assert extendable.classPathType != null;

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

        }

        else if (extendable.pcpe != null) {

            boolean result = false;

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

                result |= extendable.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 extendable to remove the artifacts from

     * @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 Extendable extendable) throws IOException, UnsupportedOperationException {

        if (extendable.pcmi != null) {

            assert extendable.sg != null;

            assert extendable.classPathType != null;

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

        }

        throw new UnsupportedOperationException ();

    }

    /**

     * Extendable represents a classpath which may be changed by the

     * {@link ProjectClassPathModifier}. It encapsulates the compilation

     * unit and class path type, @see ClassPath.

     */

    public static final class Extendable {

        private final String classPathType;       

        private final SourceGroup sg;

        private final ProjectClassPathModifierImplementation pcmi;

        private final ProjectClassPathExtender pcpe;

        private Extendable (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;

        }

        private Extendable (final ProjectClassPathExtender pcpe) {

            assert pcpe != null;

            this.pcpe = pcpe;

            this.pcmi = null;

            this.sg = null;

            this.classPathType = ClassPath.COMPILE;

        }        

        /**

         *Returns the type of classpath which may be changed by the

         *{@link ProjectClassPathModifier}, @see ClassPath.

         * @return the classpath type, never returns null

         */

        public String getClassPathType() {

            return this.classPathType;

        }

        /**

         * Returns the {@link SourceGroup} representing the

         * compilation unit which classpath may be changed by {@link ProjectClassPathModifier}

         * or null in the case when the project does not support compilation unit sensitive

         * classpath modification, in other words the project does not support {@link ProjectClassPathModifierImplementation}

         * interface but it provides the deprecated {@link ProjectClassPathExtender} interface.

         * @return the {@link SourceGroup} or null

         */

        public SourceGroup getSourceGroup () {

            return this.sg;

        }

    }    

}

/*

 *                 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[] getExtendableSourceGroups (ProjectClassPathModifierImplementation m);

    public abstract String[] getExtendableClassPathTypes (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 [] getExtendableSourceGroups ();

    /**

     * 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[] getExtendableClassPathTypes (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[] getExtendableSourceGroups(final ProjectClassPathModifierImplementation m) {

            assert m != null;

            return m.getExtendableSourceGroups();

        }

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

            assert m != null;

            assert sg != null;

            return m.getExtendableClassPathTypes(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);

        }       

    }

}