package ctxwatch

import (
	
)
ContextWatcher watches a context and performs an action when the context is canceled. It can watch one context at a time.
type ContextWatcher struct {
	onCancel             func()
	onUnwatchAfterCancel func()
	unwatchChan          chan struct{}
	watchInProgress      bool
	onCancelWasCalled    bool
}
NewContextWatcher returns a ContextWatcher. onCancel will be called when a watched context is canceled. OnUnwatchAfterCancel will be called when Unwatch is called and the watched context had already been canceled and onCancel called.
func ( func(),  func()) *ContextWatcher {
	 := &ContextWatcher{
		onCancel:             ,
		onUnwatchAfterCancel: ,
		unwatchChan:          make(chan struct{}),
	}

	return 
}
Watch starts watching ctx. If ctx is canceled then the onCancel function passed to NewContextWatcher will be called.
func ( *ContextWatcher) ( context.Context) {
	if .watchInProgress {
		panic("Watch already in progress")
	}

	.onCancelWasCalled = false

	if .Done() != nil {
		.watchInProgress = true
		go func() {
			select {
			case <-.Done():
				.onCancel()
				.onCancelWasCalled = true
				<-.unwatchChan
			case <-.unwatchChan:
			}
		}()
	} else {
		.watchInProgress = false
	}
}
Unwatch stops watching the previously watched context. If the onCancel function passed to NewContextWatcher was called then onUnwatchAfterCancel will also be called.
func ( *ContextWatcher) () {
	if .watchInProgress {
		.unwatchChan <- struct{}{}
		if .onCancelWasCalled {
			.onUnwatchAfterCancel()
		}
		.watchInProgress = false
	}