/*
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"
)

// ServiceInformer provides access to a shared informer and lister for
// Services. Prefer using the type-safe variant (see [TypedServiceInformer]).
type ServiceInformer interface {
	Informer() cache.SharedIndexInformer
	Lister() corev1.ServiceLister
}

// TypedServiceInformer provides access to a shared informer and lister for
// Services, including the type-safe TypedInformer variant.
// It is a superset of ServiceInformer.
type TypedServiceInformer interface {
	Informer() cache.SharedIndexInformer
	TypedInformer() ServiceIndexInformer
	Lister() corev1.ServiceLister
}

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

// ServiceHandlerFuncs is a specialization of [cache.TypedResourceEventHandlerFuncs] for Service.
type ServiceHandlerFuncs = cache.TypedResourceEventHandlerFuncs[*apicorev1.Service]

// ServiceDetailedHandlerFuncs is a specialization of [cache.TypedResourceEventHandlerDetailedFuncs] for Service.
type ServiceDetailedHandlerFuncs = cache.TypedResourceEventHandlerDetailedFuncs[*apicorev1.Service]

// ServiceFilteringHandler is a specialization of [cache.TypedFilteringResourceEventHandler] for Service.
type ServiceFilteringHandler = cache.TypedFilteringResourceEventHandler[*apicorev1.Service]

// ServiceIndexers is a specialization of [cache.TypedIndexers] for Service.
type ServiceIndexers = cache.TypedIndexers[*apicorev1.Service]

// DeletedService is a specialization of [cache.DeletedObject] for Service.
type DeletedService = cache.DeletedObject[*apicorev1.Service]

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

// NewServiceInformer constructs a new informer for Service 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 [NewTypedServiceInformer]).
func NewServiceInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
	return NewServiceInformerWithOptions(client, namespace, internalinterfaces.InformerOptions{ResyncPeriod: resyncPeriod, Indexers: indexers})
}

// NewTypedServiceInformer constructs a new informer for Service 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 NewTypedServiceInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers ServiceIndexers) ServiceIndexInformer {
	return NewTypedServiceInformerWithOptions(client, namespace, internalinterfaces.InformerOptions{ResyncPeriod: resyncPeriod, Indexers: cache.TypedIndexersToIndexers(indexers)})
}

// NewFilteredServiceInformer constructs a new informer for Service 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 [NewTypedFilteredServiceInformer]).
func NewFilteredServiceInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
	return NewTypedServiceInformerWithOptions(client, namespace, internalinterfaces.InformerOptions{ResyncPeriod: resyncPeriod, Indexers: indexers, TweakListOptions: tweakListOptions})
}

// NewTypedFilteredServiceInformer constructs a new informer for Service 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 NewTypedFilteredServiceInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers ServiceIndexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) ServiceIndexInformer {
	return NewTypedServiceInformerWithOptions(client, namespace, internalinterfaces.InformerOptions{ResyncPeriod: resyncPeriod, Indexers: cache.TypedIndexersToIndexers(indexers), TweakListOptions: tweakListOptions})
}

// NewServiceInformerWithOptions constructs a new informer for Service 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 [NewTypedServiceInformerWithOptions]).
func NewServiceInformerWithOptions(client kubernetes.Interface, namespace string, options internalinterfaces.InformerOptions) cache.SharedIndexInformer {
	return NewTypedServiceInformerWithOptions(client, namespace, options)
}

// NewTypedServiceInformerWithOptions constructs a new informer for Service 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 NewTypedServiceInformerWithOptions(client kubernetes.Interface, namespace string, options internalinterfaces.InformerOptions) ServiceIndexInformer {
	gvr := schema.GroupVersionResource{Group: "", Version: "v1", Resource: "services"}
	identifier := options.InformerName.WithResource(gvr)
	tweakListOptions := options.TweakListOptions
	return cache.NewTypedSharedIndexInformer[*apicorev1.Service](cache.NewSharedIndexInformerWithOptions(
		cache.ToListWatcherWithWatchListSemantics(&cache.ListWatch{
			ListFunc: func(opts metav1.ListOptions) (runtime.Object, error) {
				if tweakListOptions != nil {
					tweakListOptions(&opts)
				}
				return client.CoreV1().Services(namespace).List(context.Background(), opts)
			},
			WatchFunc: func(opts metav1.ListOptions) (watch.Interface, error) {
				if tweakListOptions != nil {
					tweakListOptions(&opts)
				}
				return client.CoreV1().Services(namespace).Watch(context.Background(), opts)
			},
			ListWithContextFunc: func(ctx context.Context, opts metav1.ListOptions) (runtime.Object, error) {
				if tweakListOptions != nil {
					tweakListOptions(&opts)
				}
				return client.CoreV1().Services(namespace).List(ctx, opts)
			},
			WatchFuncWithContext: func(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) {
				if tweakListOptions != nil {
					tweakListOptions(&opts)
				}
				return client.CoreV1().Services(namespace).Watch(ctx, opts)
			},
		}, client),
		&apicorev1.Service{},
		cache.SharedIndexInformerOptions{
			ResyncPeriod: options.ResyncPeriod,
			Indexers:     options.Indexers,
			Identifier:   identifier,
		},
	))
}

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

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

func (f *serviceInformer) TypedInformer() ServiceIndexInformer {
	return cache.NewTypedSharedIndexInformer[*apicorev1.Service](f.factory.InformerFor(&apicorev1.Service{}, f.defaultInformer))
}

func (f *serviceInformer) Lister() corev1.ServiceLister {
	return corev1.NewServiceLister(f.Informer().GetIndexer())
}

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

type serviceTypedInformerAdapter struct {
	ServiceInformer
}

func (a *serviceTypedInformerAdapter) TypedInformer() ServiceIndexInformer {
	return cache.NewTypedSharedIndexInformer[*apicorev1.Service](a.Informer())
}

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