@Override

    public boolean canHaveDependentBreakpoints() {

        return true;

    }

    <change id="DependentBreakpoints">

        <api name="DebuggerCoreAPI"/>

        <summary>Added a possibility to enable/disable other breakpoints when one is hit.</summary>

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

        <date day="19" month="12" year="2011"/>

        <author login="mentlicher"/>

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

        <description>

            Four methods are added to the Breakpoint class, that allow to

            get or set a set of breakpoints, that are enabled or disabled when

            the breakpoint is hit. One test method is provided, which determines

            if the dependent breakpoints are supported by the implementation.

            <p>

                Added methods:<br/>

                <code>Breakpoint.canHaveDependentBreakpoints()</code>,

                <code>Breakpoint.getBreakpointsToEnable()</code>,

                <code>Breakpoint.setBreakpointsToEnable()</code>,

                <code>Breakpoint.getBreakpointsToDisable()</code>,

                <code>Breakpoint.setBreakpointsToDisable()</code>.

            </p>

        </description>

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

        <issue number="197707"/>

    </change>

                    <code-name-base>org.netbeans.api.annotations.common</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <release-version>1</release-version>

                        <specification-version>1.11</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

import java.util.Collections;

import java.util.Set;

import org.netbeans.api.annotations.common.NonNull;

    private volatile Set<Breakpoint>    breakpointsToEnable = Collections.EMPTY_SET;

    private volatile Set<Breakpoint>    breakpointsToDisable = Collections.EMPTY_SET;

    /**

     * Determines if the breakpoint supports dependent breakpoints.

     * If true, get/setBreakpointsToEnable/Disable methods can be used to get

     * or set dependent breakpoints.

     * If false, the methods throw an UnsupportedOperationException.

     * @return <code>true</code> if the dependent breakpoints are supported,

     * <code>false</code> otherwise.

     * @since 1.34

     */

    public boolean canHaveDependentBreakpoints() {

        return false;

    }

    /**

     * Get the set of breakpoints that will be enabled after this breakpoint

     * is hit.

     * <p>

     * Not all breakpoint implementations honor dependent breakpoints.

     * Use {@link #canHaveDependentBreakpoints()} to determine if the operation is supported.

     * @return The set of breakpoints.

     * @throws UnsupportedOperationException if the breakpoint does not support

     * dependent breakpoints - see {@link #canHaveDependentBreakpoints()}.

     * @since 1.34

     */

    @NonNull

    public Set<Breakpoint> getBreakpointsToEnable() {

        if (!canHaveDependentBreakpoints()) {

            throw new UnsupportedOperationException("Can not have dependent breakpoints."); // NOI18N

        }

        return breakpointsToEnable;

    }

    /**

     * Get the set of breakpoints that will be disabled after this breakpoint

     * is hit.

     * <p>

     * Not all breakpoint implementations honor dependent breakpoints.

     * Use {@link #canHaveDependentBreakpoints()} to determine if the operation is supported.

     * @throws UnsupportedOperationException if the breakpoint does not support

     * dependent breakpoints - see {@link #canHaveDependentBreakpoints()}.

     * @return The set of breakpoints.

     * @since 1.34

     */

    @NonNull

    public Set<Breakpoint> getBreakpointsToDisable() {

        if (!canHaveDependentBreakpoints()) {

            throw new UnsupportedOperationException("Can not have dependent breakpoints."); // NOI18N

        }

        return breakpointsToDisable;

    }

    /**

     * Set the set of breakpoints that will be enabled after this breakpoint

     * is hit.

     * <p>

     * Not all breakpoint implementations honor dependent breakpoints.

     * Use {@link #canHaveDependentBreakpoints()} to determine if the operation is supported.

     * @param breakpointsToEnable The set of breakpoints.

     * @throws UnsupportedOperationException if the breakpoint does not support

     * dependent breakpoints - see {@link #canHaveDependentBreakpoints()}.

     * @since 1.34

     */

    public void setBreakpointsToEnable(@NonNull Set<Breakpoint> breakpointsToEnable) {

        if (!canHaveDependentBreakpoints()) {

            throw new UnsupportedOperationException("Can not have dependent breakpoints."); // NOI18N

        }

        this.breakpointsToEnable = breakpointsToEnable;

    }

    /**

     * Set the set of breakpoints that will be disabled after this breakpoint

     * is hit.

     * <p>

     * Not all breakpoint implementations honor dependent breakpoints.

     * Use {@link #canHaveDependentBreakpoints()} to determine if the operation is supported.

     * @param breakpointsToEnable The set of breakpoints.

     * @throws UnsupportedOperationException if the breakpoint does not support

     * dependent breakpoints - see {@link #canHaveDependentBreakpoints()}.

     * @since 1.34

     */

    public void setBreakpointsToDisable(@NonNull Set<Breakpoint> breakpointsToDisable) {

        if (!canHaveDependentBreakpoints()) {

            throw new UnsupportedOperationException("Can not have dependent breakpoints."); // NOI18N

        }

        this.breakpointsToDisable = breakpointsToDisable;

    }

import java.util.Set;

        enableDisableDependentBreakpoints();

    private void enableDisableDependentBreakpoints() {

        Set<Breakpoint> breakpoints = breakpoint.getBreakpointsToEnable();

        for (Breakpoint b : breakpoints) {

            b.enable();

        }

        breakpoints = breakpoint.getBreakpointsToDisable();

        for (Breakpoint b : breakpoints) {

            b.disable();

        }

    }

/*

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

 *

 * Copyright 2011 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 2011 Sun Microsystems, Inc.

 */

package org.netbeans.modules.debugger.jpda.breakpoints;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import org.netbeans.api.debugger.Breakpoint;

import org.netbeans.api.debugger.DebuggerManager;

/**

 * Set of breakpoints from a group.

 * 

 * @author Martin

 */

public final class BreakpointsFromGroup implements Set<Breakpoint> {

    private final String groupName;

    public BreakpointsFromGroup(String groupName) {

        this.groupName = groupName;

    }

    public String getGroupName() {

        return groupName;

    }

    private List<Breakpoint> getBreakpointsFromGroup() {

        List<Breakpoint> breakpoints = new ArrayList<Breakpoint>();

        Breakpoint[] bps = DebuggerManager.getDebuggerManager().getBreakpoints();

        for (Breakpoint b : bps) {

            if (groupName.equals(b.getGroupName())) {

                breakpoints.add(b);

            }

        }

        return breakpoints;

    }

    @Override

    public int size() {

        return getBreakpointsFromGroup().size();

    }

    @Override

    public boolean isEmpty() {

        return getBreakpointsFromGroup().isEmpty();

    }

    @Override

    public boolean contains(Object o) {

        return getBreakpointsFromGroup().contains(o);

    }

    @Override

    public Iterator<Breakpoint> iterator() {

        return getBreakpointsFromGroup().iterator();

    }

    @Override

    public boolean containsAll(Collection<?> c) {

        return getBreakpointsFromGroup().containsAll(c);

    }

    @Override

    public Object[] toArray() {

        return getBreakpointsFromGroup().toArray();

    }

    @Override

    public <T> T[] toArray(T[] a) {

        return getBreakpointsFromGroup().toArray(a);

    }

    @Override

    public boolean add(Breakpoint e) {

        throw new UnsupportedOperationException("Not supported.");

    }

    @Override

    public boolean remove(Object o) {

        throw new UnsupportedOperationException("Not supported.");

    }

    @Override

    public boolean addAll(Collection<? extends Breakpoint> c) {

        throw new UnsupportedOperationException("Not supported.");

    }

    @Override

    public boolean retainAll(Collection<?> c) {

        throw new UnsupportedOperationException("Not supported.");

    }

    @Override

    public boolean removeAll(Collection<?> c) {

        throw new UnsupportedOperationException("Not supported.");

    }

    @Override

    public void clear() {

        throw new UnsupportedOperationException("Not supported.");

    }

}

import java.util.Set;

        String breakpointsToEnableGroup = properties.getString("breakpointsToEnableGroup", null);

        if (breakpointsToEnableGroup != null) {

            b.setBreakpointsToEnable(new BreakpointsFromGroup(breakpointsToEnableGroup));

        }

        String breakpointsToDisableGroup = properties.getString("breakpointsToDisableGroup", null);

        if (breakpointsToDisableGroup != null) {

            b.setBreakpointsToDisable(new BreakpointsFromGroup(breakpointsToDisableGroup));

        }

        Set<Breakpoint> breakpointsToEnable = b.getBreakpointsToEnable();

        String breakpointsToEnableGroup;

        if (breakpointsToEnable instanceof BreakpointsFromGroup) {

            breakpointsToEnableGroup = ((BreakpointsFromGroup) breakpointsToEnable).getGroupName();

        } else {

            breakpointsToEnableGroup = null;

        }

        properties.setString("breakpointsToEnableGroup", breakpointsToEnableGroup);

        Set<Breakpoint> breakpointsToDisable = b.getBreakpointsToDisable();

        String breakpointsToDisableGroup;

        if (breakpointsToDisable instanceof BreakpointsFromGroup) {

            breakpointsToDisableGroup = ((BreakpointsFromGroup) breakpointsToDisable).getGroupName();

        } else {

            breakpointsToDisableGroup = null;

        }

        properties.setString("breakpointsToDisableGroup", breakpointsToDisableGroup);