<change>

        <api name="JPDADebuggerAPI"/>

        <summary>Association of breakpoints with source files.</summary>

        <version major="2" minor="46"/>

        <date day="28" month="8" year="2013"/>

        <author login="mentlicher"/>

        <compatibility addition="yes" source="compatible" binary="compatible"/>

        <description>

            getURL()/setURL() methods are added to breakpoints so that they can

            be associated with their source files. Changes in these source files

            can be then reflected in the breakpoint settings.

        </description>

        <class package="org.netbeans.api.debugger.jpda" name="ClassLoadUnloadBreakpoint" />

        <class package="org.netbeans.api.debugger.jpda" name="ExceptionBreakpoint" />

        <class package="org.netbeans.api.debugger.jpda" name="FieldBreakpoint" />

        <class package="org.netbeans.api.debugger.jpda" name="MethodBreakpoint" />

        <issue number="226437"/>

    </change>

                    <code-name-base>org.netbeans.libs.javacapi</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <specification-version>8.6</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

import org.netbeans.api.debugger.DebuggerManager;

import org.netbeans.api.debugger.jpda.JavaSourceUtils.ElementChangeListener;

import org.netbeans.api.debugger.jpda.JavaSourceUtils.ElementChangeTracker;

import org.netbeans.api.java.source.CompilationController;

import org.netbeans.api.java.source.JavaSource;

import org.netbeans.api.java.source.Task;

import org.netbeans.spi.debugger.BreakpointURLHandler;

import org.netbeans.spi.debugger.BreakpointURLHandler.URLBasedBreakpoint;

import org.openide.util.Exceptions;

    /** Property name constant

     * @since 2.46 */

    public static final String          PROP_URL = LineBreakpoint.PROP_URL;

     * Get URL of the class source file.

     * @return The URL or <code>null</code> when there is no association with the source file.

     * @since 2.46

     */

    public String getURL() {

        return null;

    }

    /**

     * Associate this breakpoint with the class source file.

     * @param url The URL of the class source file.

     * @since 2.46

     */

    public void setURL(String url) {

    }

    /**

        private final BreakpointURLHandler urlHandler;

        private ElementChangeTracker elementChangeTracker;

        private final Object elementChangeTrackerLock = new Object();

        ClassLoadUnloadBreakpointImpl() {

            super();

            urlHandler = BreakpointURLHandler.create(this);

        }

        @Override

        public void setClassFilters(String[] classFilters) {

            super.setClassFilters(classFilters);

            trackClassElement();

        }

        @Override

        public String getURL() {

            if (urlHandler == null) {

                return null;

            } else {

                return urlHandler.getURL();

            }

        }

        @Override

        public void setURL(String url) {

            String old = urlHandler.setURL(url);

            if (old == null || !old.equals(url)) {

                firePropertyChange (PROP_URL, old, url);

                if (old != null && !old.isEmpty()) {

                    DebuggerManager.getDebuggerManager().addBreakpoint(this);

                }

                firePropertyChange(PROP_GROUP_PROPERTIES, null, null);

                trackClassElement();

            }

        }

        private void trackClassElement() {

            synchronized (elementChangeTrackerLock) {

                if (elementChangeTracker != null) {

                    elementChangeTracker.destroy();

                }

            }

            String[] classFilters = getClassFilters();

            FileObject fo = urlHandler.getFileObject();

            if (classFilters.length == 1 && fo != null) {

                final String clazz = classFilters[0];

                final JavaSource js = JavaSource.forFileObject(fo);

                if (js == null) {

                    return ;

                }

                try {

                    js.runWhenScanFinished(new Task<CompilationController>() {

                        @Override

                        public void run(CompilationController parameter) throws Exception {

                            ElementChangeTracker ect = JavaSourceUtils.createElementChangeTracker(js, clazz, null, null);

                            if (ect != null) {

                                ect.setElementChangeListener(ClassLoadUnloadBreakpointImpl.this);

                                synchronized (elementChangeTrackerLock) {

                                    elementChangeTracker = ect;

                                }

                            }

                        }

                    }, true);

                } catch (IOException ex) {

                    Exceptions.printStackTrace(ex);

                }

            }

        }

        @Override

        protected void dispose() {

            super.dispose();

            synchronized (elementChangeTrackerLock) {

                if (elementChangeTracker != null) {

                    elementChangeTracker.destroy();

                }

            }

        }

        @Override

        public void removed() {

            DebuggerManager.getDebuggerManager().removeBreakpoint(this);

        }

        @Override

        public void changed(String name) {

        }

import org.netbeans.api.debugger.DebuggerManager;

import org.netbeans.api.debugger.jpda.JavaSourceUtils.ElementChangeListener;

import org.netbeans.api.debugger.jpda.JavaSourceUtils.ElementChangeTracker;

import org.netbeans.api.java.source.CompilationController;

import org.netbeans.api.java.source.JavaSource;

import org.netbeans.api.java.source.Task;

import org.netbeans.spi.debugger.BreakpointURLHandler;

import org.netbeans.spi.debugger.BreakpointURLHandler.URLBasedBreakpoint;

import org.openide.util.Exceptions;

    /** Property name constant

     * @since 2.46 */

    public static final String          PROP_URL = LineBreakpoint.PROP_URL;

     * Get URL of the exception source file.

     * @return The URL or <code>null</code> when there is no association with the source file.

     * @since 2.46

     */

    public String getURL() {

        return null;

    }

    /**

     * Associate this breakpoint with an exception source file.

     * @param url The URL of the exception source file.

     * @since  2.46

     */

    public void setURL(String url) {

    }

    /**

        public String getURL() {

            if (urlHandler == null) {

                return null;

            } else {

                return urlHandler.getURL();

            }

        }

        @Override

        public void setURL(String url) {

            String old = urlHandler.setURL(url);

            if (old == null || !old.equals(url)) {

                firePropertyChange (PROP_URL, old, url);

                if (old != null && !old.isEmpty()) {

                    DebuggerManager.getDebuggerManager().addBreakpoint(this);

                }

                firePropertyChange(PROP_GROUP_PROPERTIES, null, null);

                trackFieldElement();

            }

        }

        @Override

        public void setExceptionClassName(String cn) {

            super.setExceptionClassName(cn);

            trackFieldElement();

        }

        private void trackFieldElement() {

            synchronized (elementChangeTrackerLock) {

                if (elementChangeTracker != null) {

                    elementChangeTracker.destroy();

                }

            }

            final String clazz  = getExceptionClassName();

            FileObject fo = urlHandler.getFileObject();

            if (!clazz.isEmpty() && fo != null) {

                final JavaSource js = JavaSource.forFileObject(fo);

                if (js == null) {

                    return ;

                }

                try {

                    js.runWhenScanFinished(new Task<CompilationController>() {

                        @Override

                        public void run(CompilationController parameter) throws Exception {

                            ElementChangeTracker ect = JavaSourceUtils.createElementChangeTracker(js, clazz, null, null);

                            if (ect != null) {

                                ect.setElementChangeListener(ExceptionBreakpointImpl.this);

                                synchronized (elementChangeTrackerLock) {

                                    elementChangeTracker = ect;

                                }

                            }

                        }

                    }, true);

                } catch (IOException ex) {

                    Exceptions.printStackTrace(ex);

                }

            }

        }

        @Override

        protected void dispose() {

            super.dispose();

            synchronized (elementChangeTrackerLock) {

                if (elementChangeTracker != null) {

                    elementChangeTracker.destroy();

                }

            }

        }

        @Override

        @Override

        public void removed() {

            DebuggerManager.getDebuggerManager().removeBreakpoint(this);

        }

        @Override

        public void changed(String name) {

            setExceptionClassName(name);

        }

import static org.netbeans.api.debugger.Breakpoint.PROP_GROUP_PROPERTIES;

import org.netbeans.api.debugger.DebuggerManager;

import org.netbeans.api.debugger.jpda.JavaSourceUtils.ElementChangeListener;

import org.netbeans.api.debugger.jpda.JavaSourceUtils.ElementChangeTracker;

import org.netbeans.api.java.source.CompilationController;

import org.netbeans.api.java.source.JavaSource;

import org.netbeans.api.java.source.Task;

import org.netbeans.spi.debugger.BreakpointURLHandler;

import org.netbeans.spi.debugger.BreakpointURLHandler.URLBasedBreakpoint;

import org.openide.util.Exceptions;

    /** Property name constant

     * @since 2.46 */

    public static final String      PROP_URL = LineBreakpoint.PROP_URL;

     * Get URL of the field source file.

     * @return The URL or <code>null</code> when there is no association with the source file.

     * @since 2.46

     */

    public String getURL() {

        return null;

    }

    /**

     * Associate this breakpoint with the field source file.

     * @param url The URL of the field source file.

     * @since 2.46

     */

    public void setURL(String url) {

    }

    /**

        @Override

        public void removed() {

            DebuggerManager.getDebuggerManager().removeBreakpoint(this);

        }

        @Override

        public void changed(String name) {

            setFieldName(name);

        }

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2013 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2013 Sun Microsystems, Inc.

 */

package org.netbeans.api.debugger.jpda;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Set;

import javax.lang.model.element.Element;

import javax.lang.model.element.ElementKind;

import javax.lang.model.element.ExecutableElement;

import javax.lang.model.element.Modifier;

import javax.lang.model.element.TypeElement;

import javax.lang.model.element.VariableElement;

import javax.lang.model.type.ArrayType;

import javax.lang.model.type.DeclaredType;

import javax.lang.model.type.TypeMirror;

import javax.lang.model.util.ElementScanner6;

import javax.lang.model.util.Types;

import org.netbeans.api.java.source.ClassIndex;

import org.netbeans.api.java.source.ClassIndexListener;

import org.netbeans.api.java.source.CompilationController;

import org.netbeans.api.java.source.ElementHandle;

import org.netbeans.api.java.source.ElementUtilities;

import org.netbeans.api.java.source.JavaSource;

import org.netbeans.api.java.source.RootsEvent;

import org.netbeans.api.java.source.Task;

import org.netbeans.api.java.source.TypesEvent;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileUtil;

import org.openide.util.Exceptions;

import org.openide.util.Parameters;

/**

 * Java source utilities.

 * The main purpose is to track changes in Java elements.

 * 

 * @author Martin Entlicher

 */

final class JavaSourceUtils {

    private JavaSourceUtils() {}

    static Collection<ElementHandle<TypeElement>> getClasses (final FileObject fo) {

        Parameters.notNull("fo", fo);   //NOI18N

        if (!fo.isValid()) {

            throw new IllegalArgumentException ("FileObject : " + FileUtil.getFileDisplayName(fo) + " is not valid.");  //NOI18N

        }

        if (fo.isVirtual()) {

            throw new IllegalArgumentException ("FileObject : " + FileUtil.getFileDisplayName(fo) + " is virtual.");  //NOI18N

        }

        final JavaSource js = JavaSource.forFileObject(fo);        

        if (js == null) {

            throw new IllegalArgumentException ();

        }

        try {

            final LinkedHashSet<ElementHandle<TypeElement>> result = new LinkedHashSet<ElementHandle<TypeElement>>();

            js.runUserActionTask(new Task<CompilationController>() {            

                @Override

                public void run(final CompilationController control) throws Exception {

                    if (control.toPhase(JavaSource.Phase.ELEMENTS_RESOLVED).compareTo (JavaSource.Phase.ELEMENTS_RESOLVED)>=0) {

                        final List<TypeElement>  types = new ArrayList<TypeElement>();

                        final ElementScanner6<Void,Void> visitor = new ElementScanner6<Void, Void>() {

                            @Override

                            public Void visitType(TypeElement e, Void p) {

                                if (e.getEnclosingElement().getKind() == ElementKind.PACKAGE

                                   || e.getModifiers().contains(Modifier.STATIC)) {

                                    types.add(e);

                                    return super.visitType(e, p);

                                } else {

                                    return null;

                                }

                            }

                        };

                        visitor.scan(control.getTopLevelElements(), null);

                        for (TypeElement type : types) {

                            result.add (ElementHandle.create(type));

                        }

                    }

                }                

            }, true);

            return result;

        } catch (IOException ioe) {

            Exceptions.printStackTrace(ioe);

            return Collections.<ElementHandle<TypeElement>>emptySet();

        }		

    }

    static ElementChangeTracker createElementChangeTracker(JavaSource js, String clazz, String name, String signature) {

        ClassIndex classIndex = js.getClasspathInfo().getClassIndex();

        String packageName = "";

        int pkgIndex = clazz.lastIndexOf('.');

        if (pkgIndex > 0) {

            packageName = clazz.substring(0, pkgIndex);

        }

        ClassIndex.SearchScopeType scopeType = new JavaSourceUtils.PackageSearchType(packageName);

        String prefix = (pkgIndex > 0) ? clazz.substring(pkgIndex+1) : clazz;

        int i = prefix.lastIndexOf('$');

        if (i > 0) {

            prefix = prefix.substring(i+1);

        }

        ElementHandle<TypeElement> classElement = null;

        Set<ElementHandle<TypeElement>> declaredTypes = classIndex.getDeclaredTypes(prefix, ClassIndex.NameKind.PREFIX, Collections.singleton(scopeType));

        //System.err.println("Declared types of "+clazz+" = "+declaredTypes);

        for (ElementHandle<TypeElement> dt : declaredTypes) {

            if (clazz.equals(dt.getBinaryName())) {

                classElement = dt;

            }

        }

        //System.err.println("Class Element of "+clazz+" = "+classElement);

        if (classElement == null) {

            return null;

        }

        return new ElementChangeTracker(js, classIndex, classElement, name, signature);

    }

    static final class ElementChangeTracker {

        private final Tracker tracker = new Tracker();

        private final JavaSource js;

        private final ClassIndex classIndex;

        private final ElementHandle<TypeElement> classElement;

        private String name;

        private String signature;

        private ElementChangeListener ecl;

        private ElementChangeTracker(JavaSource js, ClassIndex classIndex, ElementHandle<TypeElement> classElement, String name, String signature) {

            assert classElement != null;

            this.js = js;

            this.classIndex = classIndex;

            this.classElement = classElement;

            this.name = name;

            this.signature = signature;

            classIndex.addClassIndexListener(tracker);

        }

        void setName(String name) {

            this.name = name;

        }

        void setSignature(String signature) {

            this.signature = signature;

        }

        void setElementChangeListener(ElementChangeListener ecl) {

            this.ecl = ecl;

        }

        void destroy() {

            classIndex.removeClassIndexListener(tracker);

        }

        class Tracker implements ClassIndexListener {

            @Override

            public void typesAdded(TypesEvent event) {

                for (ElementHandle<TypeElement> eh : event.getTypes()) {

                    String binaryName = eh.getBinaryName();

                }

            }

            @Override

            public void typesRemoved(TypesEvent event) {

                for (ElementHandle<TypeElement> eh : event.getTypes()) {

                    //String binaryName = eh.getBinaryName();

                    if (classElement.signatureEquals(eh)) {

                        ecl.removed();

                    }

                }

            }

            @Override

            public void typesChanged(TypesEvent event) {

                for (ElementHandle<TypeElement> eh : event.getTypes()) {

                    //String binaryName = eh.getBinaryName();

                    if (classElement.signatureEquals(eh)) {

                        if (name != null && !name.isEmpty()) {

                            if (!doesElementExist(js, eh, name, signature)) {

                                ecl.removed();

                            }

                        }

                        //ecl.changed(name);

                    }

                }

            }

            @Override

            public void rootsAdded(RootsEvent event) {

                event.toString();

            }

            @Override

            public void rootsRemoved(RootsEvent event) {

                event.toString();

            }

        }

    }

    static boolean doesElementExist(final JavaSource js,

                                    final ElementHandle<TypeElement> typeHandle,

                                    final String name,

                                    final String signature) {

        final boolean[] exists = new boolean[] { false };

        try {

            js.runUserActionTask(new Task<CompilationController>() {

                @Override

                public void run(CompilationController cc) throws Exception {

                    if (cc.toPhase(JavaSource.Phase.ELEMENTS_RESOLVED).compareTo (JavaSource.Phase.ELEMENTS_RESOLVED) >= 0) {

                        TypeElement type = typeHandle.resolve(cc);

                        if (type == null) {

                            return ;

                        }

                        //List<? extends Element> allMembers = cc.getElements().getAllMembers(type);

                        List<? extends Element> allMembers = type.getEnclosedElements();

                        for (Element member : allMembers) {

                            if (!member.getSimpleName().contentEquals(name)) {

                                continue;

                            }

                            if (signature == null) {

                                if (!ElementKind.FIELD.equals(member.getKind())) {

                                    continue;

                                }

                                exists[0] = true;

                                break;

                            } else {

                                if (!ElementKind.METHOD.equals(member.getKind())) {

                                    continue;

                                }

                                ExecutableElement method = (ExecutableElement) member;

                                if (!signature.isEmpty()) {

                                    if (!signature.equals(createSignature(method, cc.getTypes()))) {

                                        continue;

                                    }

                                }

                                exists[0] = true;

                                break;

                            }

                        }

                    } else {

                        exists[0] = true; // Be optimistic

                    }

                }

            }, true);

        } catch (IOException ex) {

            Exceptions.printStackTrace(ex);

        }

        return exists[0];

    }

    private static String createSignature(ExecutableElement elm, Types types) {

        StringBuilder signature = new StringBuilder("(");

        for (VariableElement param : elm.getParameters()) {

            TypeMirror pt = param.asType();

            pt = types.erasure(pt);

            String paramType = getTypeBinaryName(pt);

            signature.append(getSignature(paramType));

        }

        signature.append(')');

        String returnType = getTypeBinaryName(types.erasure(elm.getReturnType()));

        signature.append(getSignature(returnType));

        return signature.toString();

    }

    private static String getTypeBinaryName(TypeMirror t) {

        if (t instanceof ArrayType) {

            TypeMirror ct = ((ArrayType) t).getComponentType();

            return getTypeBinaryName(ct)+"[]";

        }

        if (t instanceof DeclaredType) {

            return ElementUtilities.getBinaryName((TypeElement) ((DeclaredType) t).asElement());

        }

        return t.toString();

    }

    private static String getSignature(String javaType) {

        if (javaType.equals("boolean")) {

            return "Z";

        } else if (javaType.equals("byte")) {

            return "B";

        } else if (javaType.equals("char")) {

            return "C";

        } else if (javaType.equals("short")) {

            return "S";

        } else if (javaType.equals("int")) {

            return "I";

        } else if (javaType.equals("long")) {

            return "J";

        } else if (javaType.equals("float")) {

            return "F";

        } else if (javaType.equals("double")) {

            return "D";

        } else if (javaType.equals("void")) {

            return "V";

        } else if (javaType.endsWith("[]")) {

            return "["+getSignature(javaType.substring(0, javaType.length() - 2));

        } else {

            return "L"+javaType.replace('.', '/')+";";

        }

    }

    static interface ElementChangeListener {

        void removed();

        void changed(String name);

    }

    static final class PackageSearchType implements ClassIndex.SearchScopeType {

        private final Set<? extends String> packages;

        PackageSearchType(String packageName) {

            packages = Collections.singleton(packageName);

        }

        @Override

        public Set<? extends String> getPackages() {

            return packages;

        }

        @Override

        public boolean isSources() {

            return true;

        }

        @Override

        public boolean isDependencies() {

            return false;

        }

    }

}

import org.netbeans.spi.debugger.BreakpointURLHandler;

import org.netbeans.api.debugger.DebuggerManager;

import org.netbeans.api.debugger.jpda.JavaSourceUtils.ElementChangeListener;

import org.netbeans.api.debugger.jpda.JavaSourceUtils.ElementChangeTracker;

import org.netbeans.api.java.source.CompilationController;

import org.netbeans.api.java.source.JavaSource;

import org.netbeans.api.java.source.Task;

import org.netbeans.spi.debugger.BreakpointURLHandler;

import org.netbeans.spi.debugger.BreakpointURLHandler.URLBasedBreakpoint;

import org.openide.util.Exceptions;

    /** Property name constant

     * @since 2.46 */

    public static final String          PROP_URL = LineBreakpoint.PROP_URL;

     * Get URL of the method source file.

     * @return The URL or <code>null</code> when there is no association with the source file.

     * @since 2.46

     */

    public String getURL() {

        return null;

    }

    /**

     * Associate this breakpoint with the method source file.

     * @param url The URL of the method source file.

     * @since 2.46

     */

    public void setURL(String url) {

    }

    /**

        @Override

        public void removed() {

            DebuggerManager.getDebuggerManager().removeBreakpoint(this);

        }

        @Override

        public void changed(String name) {

            setMethodName(name);

        }

    <change id="BreakpointURLHandler">

        <api name="DebuggerCoreAPI"/>

        <summary>Handling of breakpoint's URL updates.</summary>

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

        <date day="28" month="8" year="2013"/>

        <author login="mentlicher"/>

        <compatibility binary="compatible" source="compatible" addition="yes" deletion="no"/>

        <description>

            A class BreakpointURLHandler is added to automatically update

            breakpoint's URL property when the breakpoint's source URL changes.

        </description>

        <class package="org.netbeans.spi.debugger" name="BreakpointURLHandler"/>

        <issue number="226437"/>

    </change>

                    <code-name-base>org.openide.loaders</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <specification-version>7.50</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.openide.nodes</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <specification-version>7.36</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2013 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2013 Sun Microsystems, Inc.

 */

package org.netbeans.spi.debugger;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.net.MalformedURLException;

import java.net.URL;

import java.util.Collection;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ChangeListener;

import org.netbeans.api.debugger.Breakpoint;

import org.netbeans.api.debugger.DebuggerManager;

import org.openide.ErrorManager;

import org.openide.filesystems.FileAttributeEvent;

import org.openide.filesystems.FileChangeListener;

import org.openide.filesystems.FileEvent;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileRenameEvent;

import org.openide.filesystems.URLMapper;

import org.openide.loaders.DataObject;

import org.openide.util.WeakListeners;

/**

 * A utility class, that keeps an association of the breakpoint with an URL

 * and reflects the changes of the URL to the breakpoint.

 * 

 * @author Martin Entlicher

 * @since 1.44

 */

public final class BreakpointURLHandler {

    private final URLBasedBreakpoint breakpoint;

    private String url;

    private FileObject fo;

    private Listener listener;

    private BreakpointURLHandler(URLBasedBreakpoint breakpoint) {

        this.breakpoint = breakpoint;

        setURL(breakpoint.getURL());

    }

    /**

     * Creates a handler from an URL-based breakpoint.

     * @param breakpoint The URL-based breakpoint

     * @return a new instance of the handler

     */

    public static BreakpointURLHandler create(URLBasedBreakpoint breakpoint) {

        return new BreakpointURLHandler(breakpoint);

    }

    /**

     * Gets a string representation of URL of the source file,

     * which contains the breakpoint.

     *

     * @return URL of the breakpoint source file.

     */

    public String getURL() {

        return url;

    }

    /**

     * Set a string representation of URL of the source file containing the breakpoint.

     * @param url the URL of the breakpoint source file.

     * @return an old URL, or <code>null</code>.

     */

    public String setURL(String url) {

        String old;

        synchronized (this) {

            if (url == null) {

                url = "";

            }

            if (url.equals(this.url)) {

                return this.url;

            }

            old = this.url;

            this.url = url;

            if (listener != null) {

                listener.removeFrom(fo);

            }

            if (url.length() > 0) {

                try {

                    fo = URLMapper.findFileObject(new URL(url));

                    if (fo != null) {

                        if (listener == null) {

                            listener = new Listener();

                        }

                        listener.addTo(fo);

                    }

                } catch (MalformedURLException ex) {

                    ErrorManager.getDefault().notify(new IllegalArgumentException("URL = '"+url+"'", ex));

                } catch (IllegalArgumentException ex) {

                    ErrorManager.getDefault().notify(new IllegalArgumentException("URL = '"+url+"'", ex));

                }

            }

        }

        return old;

    }

    /**

     * Get the FileObject that corresponds to the current URL.

     * @return The FileObject or <code>null</code>.

     */

    public FileObject getFileObject() {

        return fo;

    }

    void setFileObject(FileObject newFO) {

        synchronized (this) {

            if (listener != null) {

                if (fo != null) {

                    listener.removeFrom(fo);

                }

                listener.addTo(newFO);

            }

            fo = newFO;

        }

        breakpoint.setURL(newFO.toURL().toString());

    }

    private class Listener implements FileChangeListener, ChangeListener, PropertyChangeListener {

        private FileChangeListener fileListener;

        private ChangeListener registryListener;

        public Listener() {

            registryListener = WeakListeners.change(this, DataObject.getRegistry());

            DataObject.getRegistry().addChangeListener(registryListener);

        }

        void addTo(FileObject fo) {

            fileListener = WeakListeners.create(FileChangeListener.class, this, fo);

            fo.addFileChangeListener(fileListener);

        }

        void removeFrom(FileObject fo) {

            fo.removeFileChangeListener(fileListener);

        }

        @Override

        public void fileFolderCreated(FileEvent fe) {

        }

        @Override

        public void fileDataCreated(FileEvent fe) {

        }

        @Override

        public void fileChanged(FileEvent fe) {

        }

        @Override

        public void fileDeleted(FileEvent fe) {

            if (breakpoint instanceof Breakpoint) {

                DebuggerManager.getDebuggerManager().removeBreakpoint((Breakpoint) breakpoint);

            }

            fo = null;

        }

        @Override

        public void fileRenamed(FileRenameEvent fe) {

            breakpoint.setURL(((FileObject) fe.getSource()).toURL().toString());

        }

        @Override

        public void fileAttributeChanged(FileAttributeEvent fe) {

        }

        @Override

        public void stateChanged(ChangeEvent chev) {

            Object source = chev.getSource();

            if (source instanceof Collection) {

                for (Object obj : ((Collection) source)) {

                    DataObject dobj = (DataObject) obj;

                    if (registryListener != null) {

                        FileObject fileObject = fo;

                        if (fileObject == null) {

                            DataObject.getRegistry().removeChangeListener(registryListener);

                            registryListener = null;

                            return ;

                        }

                        FileObject primary = dobj.getPrimaryFile();

                        if (fileObject.equals(primary)) {

                            dobj.addPropertyChangeListener(WeakListeners.propertyChange(this, dobj));

                            DataObject.getRegistry().removeChangeListener(registryListener);

                            registryListener = null;

                        }

                    }

                }

            }

        }

        @Override

        public void propertyChange(PropertyChangeEvent evt) {

            if (DataObject.PROP_PRIMARY_FILE.equals(evt.getPropertyName())) {

                FileObject newFO = ((DataObject) evt.getSource()).getPrimaryFile();

                setFileObject(newFO);

                //DebuggerManager.getDebuggerManager().addBreakpoint(this);

                //firePropertyChange(PROP_GROUP_PROPERTIES, null, null);

            }

        }

    }

    /**

     * Breakpoints that are associated with an URL should implement this

     * interface so that they can be updated as the underlying source file changes.

     */

    public static interface URLBasedBreakpoint {

        /**

         * Get the breakpoint's URL.

         * @return The URL.

         */

        String getURL();

        /**

         * Set the breakpoint to a new URL.

         * @param url The new URL.

         */

        void setURL(String url);

    }

}

                        ((FieldBreakpoint) b).setURL(sourceURL);

                        ((MethodBreakpoint) b).setURL(sourceURL);

                        ((ClassLoadUnloadBreakpoint) b).setURL(sourceURL);

import org.netbeans.spi.debugger.ui.EditorContextDispatcher;