if w == nil {
		return nil
	}
	w.mutex.RLock()
	defer w.mutex.RUnlock()
	return w.prevNetworks
}

// SetNetworks will use the given value for mesh networks and notify all handlers of the change
func (w *internalNetworkWatcher) SetNetworks(meshNetworks *meshconfig.MeshNetworks) {
	var handlers []*WatcherHandlerRegistration

	w.mutex.Lock()

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.enterprise;

import org.gradle.internal.operations.notify.BuildOperationNotificationListener;

/**
 * A service for a particular build invocation
 *
 * Implemented by the Enterprise plugin.
 */
public interface GradleEnterprisePluginService {

    /**

         */
        BuildScanResult execute(BuildResult buildResult);
    }

    void notify(Listener listener);

	if _, _, err := syscall.AllThreadsSyscall(syscall.SYS_PRCTL, prSetKeepCaps, 0, 0); err == syscall.ENOTSUP {
		t.Skip("AllThreadsSyscall disabled with cgo")
	}

	sig := make(chan os.Signal, 1)
	Notify(sig, os.Interrupt)

	for i := 0; i <= 100; i++ {
		if _, _, errno := syscall.AllThreadsSyscall(syscall.SYS_PRCTL, prSetKeepCaps, uintptr(i&1), 0); errno != 0 {
			t.Fatalf("[%d] failed to set KEEP_CAPS=%d: %v", i, i&1, errno)

// The channel used to read SIGIO signals.
var sigioChan chan os.Signal

// CatchSIGIO starts catching SIGIO signals.
//
//export CatchSIGIO
func CatchSIGIO() {
	sigioChan = make(chan os.Signal, 1)
	signal.Notify(sigioChan, syscall.SIGIO)
}

// ResetSIGIO stops catching SIGIO signals.
//
//export ResetSIGIO
func ResetSIGIO() {
	signal.Reset(syscall.SIGIO)
}

        graphNotifyOps.size() == 2
        graphNotifyOps[0].displayName == "Notify task graph whenReady listeners (:${buildName})"
        graphNotifyOps[0].details.buildPath == ":${buildName}"
        graphNotifyOps[0].parentId == treeGraphOps[0].id
        graphNotifyOps[1].displayName == 'Notify task graph whenReady listeners'
        graphNotifyOps[1].details.buildPath == ':'

                            release.notify()
                        }
                    })
                    lease.leaseFinish()
                }
            }

            leaseAcquiredLatch.await()

            // release the first queue to submit its work
            synchronized (release) {
                release.notify()
            }

	"istio.io/istio/pkg/log"
)

func main() {
	// Create context that cancels on termination signal
	ctx, cancel := context.WithCancel(context.Background())
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
	go func(sigChan chan os.Signal, cancel context.CancelFunc) {
		sig := <-sigChan
		log.Infof("Exit signal received: %s", sig)
		cancel()
	}(sigChan, cancel)

// The channel used to read SIGIO signals.
var sigioChan chan os.Signal

// CatchSIGIO starts catching SIGIO signals.
//
//export CatchSIGIO
func CatchSIGIO() {
	sigioChan = make(chan os.Signal, 1)
	signal.Notify(sigioChan, syscall.SIGIO)
}

// ResetSIGIO stops catching SIGIO signals.
//
//export ResetSIGIO
func ResetSIGIO() {
	signal.Reset(syscall.SIGIO)
}

// SawSIGIO reports whether we saw a SIGIO.
//

/**
 * Signal that a file lock has been released.
 *
 * @see org.gradle.cache.internal.locklistener.FileLockContentionHandler
 */
public interface FileLockReleasedSignal {

    /**
     * Triggers this signal to notify the lock requesters that the file
     * lock has been released.
     *
     * <p>Returns once the signal has been emitted but not necessarily
     * received by the lock requesters.
     */
    void trigger();