*
 * While [onReset] may occur at any time, the following callbacks are expected in order,
 * correlated by stream ID.
 *
 *  * [onRequest]
 *  * [onHeaders] (unless canceled)
 *  * [onData] (optional sequence of data frames)
 *
 * As a stream ID is scoped to a single HTTP/2 connection, implementations which target multiple
 * connections should expect repetition of stream IDs.

    }
  }

  internal fun pushHeadersLater(
    streamId: Int,
    requestHeaders: List<Header>,
    inFinished: Boolean,
  ) {
    pushQueue.execute("$connectionName[$streamId] onHeaders") {
      val cancel = pushObserver.onHeaders(streamId, requestHeaders, inFinished)
      ignoreIoExceptions {
        if (cancel) writer.rstStream(streamId, ErrorCode.CANCEL)
        if (cancel || inFinished) {
          this.withLock {

    ): Boolean {
      assertThat(streamId).isEqualTo(2)
      events.add(requestHeaders)
      notifyAll()
      return false
    }

    @Synchronized override fun onHeaders(
      streamId: Int,
      responseHeaders: List<Header>,
      last: Boolean,
    ): Boolean {
      assertThat(streamId).isEqualTo(2)
      assertThat(last).isTrue()
      events.add(responseHeaders)

func (c TableConvertor) ConvertToTable(ctx context.Context, obj runtime.Object, tableOptions runtime.Object) (*metav1.Table, error) {
	noHeaders := false
	if tableOptions != nil {
		switch t := tableOptions.(type) {
		case *metav1.TableOptions:
			if t != nil {
				noHeaders = t.NoHeaders
			}
		default:
			return nil, fmt.Errorf("unrecognized type %T for table options, can't display tabular output", tableOptions)
		}
	}

				{Cells: []interface{}{"test1", "1/1", "podPhase", int64(5), "20h"}},
			},
			// Print with no headers.
			options:  PrintOptions{NoHeaders: true},
			expected: "test1   1/1   podPhase   5     20h\n",
		},
		// Test a multi-row table row table with "NoHeaders" option, doesn't print columns.
		{
			columns: []metav1.TableColumnDefinition{
				{Name: "Name", Type: "string"},
				{Name: "Ready", Type: "string"},

func (c *convertor) ConvertToTable(ctx context.Context, obj runtime.Object, tableOptions runtime.Object) (*metav1.Table, error) {
	table := &metav1.Table{}
	opt, ok := tableOptions.(*metav1.TableOptions)
	noHeaders := ok && opt != nil && opt.NoHeaders
	if !noHeaders {
		table.ColumnDefinitions = c.headers
	}

	if m, err := meta.ListAccessor(obj); err == nil {
		table.ResourceVersion = m.GetResourceVersion()
		table.Continue = m.GetContinue()

	// PrintObj receives a runtime object, formats it and prints it to a writer.
	PrintObj(runtime.Object, io.Writer) error
}

// PrintOptions struct defines a struct for various print options
type PrintOptions struct {
	NoHeaders     bool
	WithNamespace bool
	WithKind      bool
	Wide          bool
	ShowLabels    bool
	Kind          schema.GroupKind
	ColumnLabels  []string

	SortBy string

	// we should print headers only on the first object - headers should be
	// omitted on subsequent events.
	if e.tableOptions != nil && !e.tableOptions.NoHeaders {
		e.tableOptions.NoHeaders = true
		// With options change, we should recompute the identifier.
		// Clearing this will trigger lazy recompute when needed.
		e.identifier = ""
	}

	return e.encoder.Encode(result, w)
}

	"k8s.io/apimachinery/pkg/runtime"
	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
)

// GenerateOptions encapsulates attributes for table generation.
type GenerateOptions struct {
	NoHeaders bool
	Wide      bool
}

// TableGenerator - an interface for generating metav1.Table provided a runtime.Object
type TableGenerator interface {

		handler = statusHandlerEntry
	} else {
		handler = defaultHandlerEntry
	}

	includeHeaders := h.lastType != handler && !h.options.NoHeaders

	if h.lastType != nil && h.lastType != handler && !h.options.NoHeaders {
		fmt.Fprintln(output)
	}

	if err := printRowsForHandlerEntry(output, handler, eventType, obj, h.options, includeHeaders); err != nil {
		return err
	}