// EachListItemWithAlloc works like EachListItem, but avoids retaining references to the items slice in obj.
// It does this by making a shallow copy of non-pointer items in obj.
//
// If the items passed to fn are not retained, or are retained for the same duration, use EachListItem instead for memory efficiency.
func EachListItemWithAlloc(obj runtime.Object, fn func(runtime.Object) error) error {
	return eachListItem(obj, fn, true)
}

	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			t.Run("EachListItem", func(t *testing.T) {
				expectObjectNames := map[string]struct{}{}
				for i := 0; i < tc.expectObjectNum; i++ {
					expectObjectNames[strconv.Itoa(i)] = struct{}{}
				}
				list := tc.generateFunc(tc.expectObjectNum)
				err := EachListItem(list, func(object runtime.Object) error {
					o, err := Accessor(object)
					if err != nil {

			return err
		}
	}
	return nil
}

func (obj *Unstructured) EachListItemWithAlloc(fn func(runtime.Object) error) error {
	// EachListItem has allocated a new Object for the user, we can use it directly.
	return obj.EachListItem(fn)
}

func (obj *Unstructured) NewEmptyInstance() runtime.Unstructured {
	out := new(Unstructured)
	if obj != nil {

	}

	ret := &UnstructuredList{}
	ret.Object = obj.Object

	err := obj.EachListItem(func(item runtime.Object) error {
		castItem := item.(*Unstructured)
		ret.Items = append(ret.Items, *castItem)
		return nil
	})
	if err != nil {
		return nil, err
	}

	return ret, nil
}

func (obj *Unstructured) EachListItem(fn func(runtime.Object) error) error {
	field, ok := obj.Object["items"]
	if !ok {

func (p *OmitManagedFieldsPrinter) PrintObj(obj runtime.Object, w io.Writer) error {
	if obj == nil {
		return p.Delegate.PrintObj(obj, w)
	}
	if meta.IsListType(obj) {
		obj = obj.DeepCopyObject()
		_ = meta.EachListItem(obj, func(item runtime.Object) error {
			omitManagedFields(item)
			return nil
		})
	} else if _, err := meta.Accessor(obj); err == nil {
		obj = omitManagedFields(obj.DeepCopyObject())
	}

	IsList() bool
	// EachListItem should pass a single item out of the list as an Object to the provided function. Any
	// error should terminate the iteration. If IsList() returns false, this method should return an error
	// instead of calling the provided function.
	EachListItem(func(Object) error) error
	// EachListItemWithAlloc works like EachListItem, but avoids retaining references to a slice of items.

	if meta.IsListType(obj) {
		rows := make([]metav1.TableRow, 0, 16)
		err := meta.EachListItem(obj, func(obj runtime.Object) error {
			nestedRows, err := MetaToTableRow(obj, rowFn)
			if err != nil {
				return err
			}
			rows = append(rows, nestedRows...)
			return nil
		})
		if err != nil {

			Object: runtime.RawExtension{Object: obj},
		})
		return nil
	}
	switch {
	case meta.IsListType(object):
		if err := meta.EachListItem(object, fn); err != nil {
			return nil, err
		}
	default:
		if err := fn(object); err != nil {
			return nil, err
		}
	}
	if m, err := meta.ListAccessor(object); err == nil {

	Items []Unstructured `json:"items"`
}

func (u *UnstructuredList) GetObjectKind() schema.ObjectKind { return u }

func (u *UnstructuredList) IsList() bool { return true }

func (u *UnstructuredList) EachListItem(fn func(runtime.Object) error) error {
	for i := range u.Items {
		if err := fn(&u.Items[i]); err != nil {
			return err
		}
	}
	return nil
}

	}

	gvk := groupVersion.WithKind("PartialObjectMetadata")
	switch {
	case groupVersion == metav1beta1.SchemeGroupVersion:
		list := &metav1beta1.PartialObjectMetadataList{}
		err := meta.EachListItem(result, func(obj runtime.Object) error {
			m, err := meta.Accessor(obj)
			if err != nil {
				return err
			}
			partial := meta.AsPartialObjectMetadata(m)
			partial.GetObjectKind().SetGroupVersionKind(gvk)