/*
Copyright The Kubernetes Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

// Code generated by informer-gen. DO NOT EDIT.

package v1

import (
	context "context"
	time "time"

	apicorev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	runtime "k8s.io/apimachinery/pkg/runtime"
	schema "k8s.io/apimachinery/pkg/runtime/schema"
	watch "k8s.io/apimachinery/pkg/watch"
	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
	kubernetes "k8s.io/client-go/kubernetes"
	corev1 "k8s.io/client-go/listers/core/v1"
	cache "k8s.io/client-go/tools/cache"
)

// PodInformer provides access to a shared informer and lister for
// Pods. Prefer using the type-safe variant (see [TypedPodInformer]).
type PodInformer interface {
	Informer() cache.SharedIndexInformer
	Lister() corev1.PodLister
}

// TypedPodInformer provides access to a shared informer and lister for
// Pods, including the type-safe TypedInformer variant.
// It is a superset of PodInformer.
type TypedPodInformer interface {
	Informer() cache.SharedIndexInformer
	TypedInformer() PodIndexInformer
	Lister() corev1.PodLister
}

// PodIndexInformer is a wrapper around the underlying [cache.SharedIndexInformer]
// with type-safe variants of several methods.
type PodIndexInformer cache.TypedSharedIndexInformer[*apicorev1.Pod]

// PodHandlerFuncs is a specialization of [cache.TypedResourceEventHandlerFuncs] for Pod.
type PodHandlerFuncs = cache.TypedResourceEventHandlerFuncs[*apicorev1.Pod]

// PodDetailedHandlerFuncs is a specialization of [cache.TypedResourceEventHandlerDetailedFuncs] for Pod.
type PodDetailedHandlerFuncs = cache.TypedResourceEventHandlerDetailedFuncs[*apicorev1.Pod]

// PodFilteringHandler is a specialization of [cache.TypedFilteringResourceEventHandler] for Pod.
type PodFilteringHandler = cache.TypedFilteringResourceEventHandler[*apicorev1.Pod]

// PodIndexers is a specialization of [cache.TypedIndexers] for Pod.
type PodIndexers = cache.TypedIndexers[*apicorev1.Pod]

// DeletedPod is a specialization of [cache.DeletedObject] for Pod.
type DeletedPod = cache.DeletedObject[*apicorev1.Pod]

type podInformer struct {
	factory          internalinterfaces.SharedInformerFactory
	tweakListOptions internalinterfaces.TweakListOptionsFunc
	namespace        string
}

// NewPodInformer constructs a new informer for Pod type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
// If you really need an independent one, prefer using the type-safe variant (see [NewTypedPodInformer]).
func NewPodInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
	return NewPodInformerWithOptions(client, namespace, internalinterfaces.InformerOptions{ResyncPeriod: resyncPeriod, Indexers: indexers})
}

// NewTypedPodInformer constructs a new informer for Pod type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewTypedPodInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers PodIndexers) PodIndexInformer {
	return NewTypedPodInformerWithOptions(client, namespace, internalinterfaces.InformerOptions{ResyncPeriod: resyncPeriod, Indexers: cache.TypedIndexersToIndexers(indexers)})
}

// NewFilteredPodInformer constructs a new informer for Pod type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
// If you really need an independent one, prefer using the type-safe variant (see [NewTypedFilteredPodInformer]).
func NewFilteredPodInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
	return NewTypedPodInformerWithOptions(client, namespace, internalinterfaces.InformerOptions{ResyncPeriod: resyncPeriod, Indexers: indexers, TweakListOptions: tweakListOptions})
}

// NewTypedFilteredPodInformer constructs a new informer for Pod type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewTypedFilteredPodInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers PodIndexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) PodIndexInformer {
	return NewTypedPodInformerWithOptions(client, namespace, internalinterfaces.InformerOptions{ResyncPeriod: resyncPeriod, Indexers: cache.TypedIndexersToIndexers(indexers), TweakListOptions: tweakListOptions})
}

// NewPodInformerWithOptions constructs a new informer for Pod type with additional options.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
// If you really need an independent one, prefer using the type-safe variant (see [NewTypedPodInformerWithOptions]).
func NewPodInformerWithOptions(client kubernetes.Interface, namespace string, options internalinterfaces.InformerOptions) cache.SharedIndexInformer {
	return NewTypedPodInformerWithOptions(client, namespace, options)
}

// NewTypedPodInformerWithOptions constructs a new informer for Pod type with additional options.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewTypedPodInformerWithOptions(client kubernetes.Interface, namespace string, options internalinterfaces.InformerOptions) PodIndexInformer {
	gvr := schema.GroupVersionResource{Group: "", Version: "v1", Resource: "pods"}
	identifier := options.InformerName.WithResource(gvr)
	tweakListOptions := options.TweakListOptions
	return cache.NewTypedSharedIndexInformer[*apicorev1.Pod](cache.NewSharedIndexInformerWithOptions(
		cache.ToListWatcherWithWatchListSemantics(&cache.ListWatch{
			ListFunc: func(opts metav1.ListOptions) (runtime.Object, error) {
				if tweakListOptions != nil {
					tweakListOptions(&opts)
				}
				return client.CoreV1().Pods(namespace).List(context.Background(), opts)
			},
			WatchFunc: func(opts metav1.ListOptions) (watch.Interface, error) {
				if tweakListOptions != nil {
					tweakListOptions(&opts)
				}
				return client.CoreV1().Pods(namespace).Watch(context.Background(), opts)
			},
			ListWithContextFunc: func(ctx context.Context, opts metav1.ListOptions) (runtime.Object, error) {
				if tweakListOptions != nil {
					tweakListOptions(&opts)
				}
				return client.CoreV1().Pods(namespace).List(ctx, opts)
			},
			WatchFuncWithContext: func(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) {
				if tweakListOptions != nil {
					tweakListOptions(&opts)
				}
				return client.CoreV1().Pods(namespace).Watch(ctx, opts)
			},
		}, client),
		&apicorev1.Pod{},
		cache.SharedIndexInformerOptions{
			ResyncPeriod: options.ResyncPeriod,
			Indexers:     options.Indexers,
			Identifier:   identifier,
		},
	))
}

func (f *podInformer) defaultInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
	return NewTypedPodInformerWithOptions(client, f.namespace, internalinterfaces.InformerOptions{ResyncPeriod: resyncPeriod, Indexers: cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, InformerName: f.factory.InformerName(), TweakListOptions: f.tweakListOptions})
}

func (f *podInformer) Informer() cache.SharedIndexInformer {
	return f.TypedInformer()
}

func (f *podInformer) TypedInformer() PodIndexInformer {
	return cache.NewTypedSharedIndexInformer[*apicorev1.Pod](f.factory.InformerFor(&apicorev1.Pod{}, f.defaultInformer))
}

func (f *podInformer) Lister() corev1.PodLister {
	return corev1.NewPodLister(f.Informer().GetIndexer())
}

// ToTypedPodInformer converts an untyped informer into a TypedPodInformer.
//
// WARNING: this conversion is only safe if the informer handles objects of type
// *Pod. If that is not the case, calling type-safe methods of the returned
// TypedPodInformer leads to runtime panics. A safer alternative is to pass
// around a TypedPodInformer instances that was obtained from a
// SharedInformerFactory.
func ToTypedPodInformer(informer PodInformer) TypedPodInformer {
	if informer, ok := informer.(TypedPodInformer); ok {
		return informer
	}
	return &podTypedInformerAdapter{informer}
}

type podTypedInformerAdapter struct {
	PodInformer
}

func (a *podTypedInformerAdapter) TypedInformer() PodIndexInformer {
	return cache.NewTypedSharedIndexInformer[*apicorev1.Pod](a.Informer())
}

// ToPodIndexInformer converts an untyped informer into a PodIndexInformer.
//
// WARNING: this conversion is only safe if the informer handles objects of type
// *Pod. If that is not the case, calling type-safe methods of the returned
// PodIndexInformer leads to runtime panics. A safer alternative is to pass
// around a PodIndexInformer instances that was obtained from a
// SharedInformerFactory.
func ToPodIndexInformer(informer cache.SharedIndexInformer) PodIndexInformer {
	if informer, ok := informer.(PodIndexInformer); ok {
		return informer
	}
	return cache.NewTypedSharedIndexInformer[*apicorev1.Pod](informer)
}
