package stacktrace

Import Path
	go.uber.org/zap/internal/stacktrace (on go.dev)

Dependency Relation
	imports 4 packages, and imported by one package

Involved Source Files

	  d stack.go
		Package stacktrace provides support for gathering stack traces
		efficiently.
Package-Level Type Names (total 3, all are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Depth int (basic type)
		Depth specifies how deep of a stack trace should be captured.

		As Inputs Of (at least one exported)
			func Capture(skip int, depth Depth) *Stack
		As Types Of (total 2, both are exported)
			const First
			const Full

	 type Formatter (struct)
		Formatter formats a stack trace into a readable string representation.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			b *buffer.Buffer
			nonEmpty bool
				// whehther we've written at least one frame already

		Methods (total 2, both are exported)
			(*Formatter) FormatFrame(frame runtime.Frame)
				FormatFrame formats the given frame.

			(*Formatter) FormatStack(stack *Stack)
				FormatStack formats all remaining frames in the provided stacktrace -- minus
				the final runtime.main/runtime.goexit frame.

		As Outputs Of (at least one exported)
			func NewFormatter(b *buffer.Buffer) Formatter

	 type Stack (struct)
		Stack is a captured stack trace.

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			frames *runtime.Frames
			pcs []uintptr
				// program counters; always a subslice of storage

			storage []uintptr
				The size of pcs varies depending on requirements:
				it will be one if the only the first frame was requested,
				and otherwise it will reflect the depth of the call stack.
				
				storage decouples the slice we need (pcs) from the slice we pool.
				We will always allocate a reasonably large storage, but we'll use
				only as much of it as we need.

		Methods (total 3, all are exported)
			(*Stack) Count() int
				Count reports the total number of frames in this stacktrace.
				Count DOES NOT change as Next is called.

			(*Stack) Free()
				Free releases resources associated with this stacktrace
				and returns it back to the pool.

			(*Stack) Next() (_ runtime.Frame, more bool)
				Next returns the next frame in the stack trace,
				and a boolean indicating whether there are more after it.

		As Outputs Of (at least one exported)
			func Capture(skip int, depth Depth) *Stack
		As Inputs Of (at least one exported)
			func (*Formatter).FormatStack(stack *Stack)


Package-Level Functions (total 3, all are exported)

	 func Capture(skip int, depth Depth) *Stack
		Capture captures a stack trace of the specified depth, skipping
		the provided number of frames. skip=0 identifies the caller of
		Capture.
		
		The caller must call Free on the returned stacktrace after using it.

	 func NewFormatter(b *buffer.Buffer) Formatter
		NewFormatter builds a new Formatter.

	 func Take(skip int) string
		Take returns a string representation of the current stacktrace.
		
		skip is the number of frames to skip before recording the stack trace.
		skip=0 identifies the caller of Take.


Package-Level Variables (only one, which is unexported)

	/* one unexported ... *//* one unexported: */
	  var _stackPool *pool.Pool[...]
Package-Level Constants (total 2, both are exported)

	const First Depth = 0
		First captures only the first frame.

	const Full Depth = 1
		Full captures the entire call stack, allocating more
		storage for it if needed.

The pages are generated with Golds v0.6.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.