common

type Cancelable interface {
	// Cancel asks to cancel execution asynchronously.
	//
	// If reason is nil, default ErrCanceled is used.
	// Calling more than once is a no-op: the call is ingored.
	//
	// Cancel opportunistically asks to stop execution, but does not wait
	// for execution to actually stop. It is thus suitable to be called from
	// any other goroutine and will not cause a deadlock.
	Cancel(reason error)

	// CancelationReason returns the reason provided by the first Cancel() call,
	// or nil if not yet canceled.
	CancelationReason() error
}

type Canceler interface {
	Cancelable
	// Close releases all resources and makes the instance unusable.
	// Returns error to implement io.Closer , but it is always nil.
	// Calling more than once is a no-op: the call does nothing.
	io.Closer

	// Channel returns the channel producing reason values once Cancel() is
	// called. When Close() is called, this channel is closed.
	//
	// Use it in producers to ublock when Cancel() is called:
	//	func produce(out chan <- interface{}, item interface{}) error {
	//		select {
	//			case reason, ok := <- Canceler.Channel():
	//				if !ok {
	//					// Canceler is closed; for us it's just as Canceled.
	//					return ErrCanceled
	//				}
	//				return reason // Canceled with this reason.
	//			case out := <- item:
	//				return nil
	//		}
	//	}
	Channel() <-chan error
}

type FilesystemView struct {
	// contains filtered or unexported fields
}

type Flags struct {
	Quiet     bool
	Verbose   bool
	TracePath string
}

type GoroutinePool interface {
	Canceler

	// Wait blocks until all started jobs finish.
	//
	// Returns nil if all jobs have been executed, or reason for cancelation of
	// some jobs. This call is not itself cancelable, meaning that it'll block
	// until all worker goroutines are finished.
	Wait() error
	// Schedule adds a new job for execution as a separate goroutine. If the
	// GoroutinePool is canceled, onCanceled is called instead. It is fine to
	// pass nil as onCanceled.
	Schedule(job func(), onCanceled func())
}

type GoroutinePriorityPool interface {
	Canceler

	// Wait blocks until all started jobs finish.
	//
	// Returns nil if all jobs have been executed, or reason for cancelation of
	// some jobs. This call is not itself cancelable, meaning that it'll block
	// until all worker goroutines are finished.
	Wait() error
	// Schedule adds a new job for execution as a separate goroutine.
	//
	// If the GoroutinePriorityPool is canceled, onCanceled is called instead. It
	// is fine to pass nil as onCanceled. Smaller values of priority imply earlier
	// execution.
	Schedule(priority int64, job func(), onCanceled func())
}

type Strings []string