func (s Set[T]) String() string {
	return fmt.Sprintf("%v", s.UnsortedList())
}

// InsertOrNew inserts t into the set if the set exists, or returns a new set with t if not.
// Works well with DeleteCleanupLast.
// Example:
//
//	InsertOrNew(m, key, value)
func InsertOrNew[K comparable, T comparable](m map[K]Set[T], k K, v T) {
	s, f := m[k]
	if !f {
		m[k] = New(v)
	} else {

			b.StopTimer()
			s := New(sortOrder...)
			b.StartTimer()
			SortedList(s)
		}
	})
}

func TestMapOfSet(t *testing.T) {
	m := map[int]String{}
	InsertOrNew(m, 1, "a")
	InsertOrNew(m, 1, "b")
	InsertOrNew(m, 2, "c")
	assert.Equal(t, m, map[int]String{1: New("a", "b"), 2: New("c")})

	DeleteCleanupLast(m, 1, "a")
	assert.Equal(t, m, map[int]String{1: New("b"), 2: New("c")})

// multiple values.
type MultiValueMap map[string]sets.String

// Insert adds given (key, value) pair into the map.
func (m MultiValueMap) Insert(key, value string) MultiValueMap {
	sets.InsertOrNew(m, key, value)
	return m
}

// Delete removes given (key, value) pair out of the map.
func (m MultiValueMap) Delete(key, value string) MultiValueMap {
	sets.DeleteCleanupLast(m, key, value)
	return m

				sets.DeleteCleanupLast(idx.objects, indexKey, key)
			}
		}
		if o.New != nil {
			obj := *o.New
			key := GetKey(obj)
			for _, indexKey := range extract(obj) {
				sets.InsertOrNew(idx.objects, indexKey, key)
			}
		}
	})

	return &idx

		mu:      sync.RWMutex{},
	}
	addObj := func(obj any) {
		ro := controllers.ExtractObject(obj)
		o := ro.(O)
		objectKey := config.NamespacedName(o)
		for _, indexKey := range extract(o) {
			sets.InsertOrNew(idx.objects, indexKey, objectKey)
		}
	}
	deleteObj := func(obj any) {
		ro := controllers.ExtractObject(obj)
		o := ro.(O)
		objectKey := config.NamespacedName(o)
		for _, indexKey := range extract(o) {

		return
	}
	if current, f := pc.IPByPods[key]; f {
		// The pod already exists, but with another IP Address. We need to clean up that
		sets.DeleteCleanupLast(pc.podsByIP, current, key)
	}
	sets.InsertOrNew(pc.podsByIP, ip, key)
	pc.IPByPods[key] = ip

	if endpointsToUpdate, f := pc.needResync[ip]; f {
		delete(pc.needResync, ip)
		for epKey := range endpointsToUpdate {
			pc.queueEndpointEvent(epKey)
		}

	filter := map[string]sets.String{}
	for _, name := range names {
		dir, _, hn, p := model.ParseSubsetKey(name)
		defaultKey := model.BuildSubsetKey(dir, "", hn, p)
		sets.InsertOrNew(filter, defaultKey, name)
	}
	return filter
}

// clusterBuilder is responsible for building a single default and subset clusters for a service
// TODO re-use the v1alpha3.ClusterBuilder:

	r.deleteKeyFromReverseMap(key)
	var version string
	if len(nonce) > 12 {
		version = nonce[:xds.VersionLen]
	} else {
		version = nonce
	}
	// touch
	r.status[key] = version
	sets.InsertOrNew(r.reverseStatus, version, key)
}

// This is a helper function for keeping our reverseStatus map in step with status.
// must have write lock before calling.
func (r *Reporter) deleteKeyFromReverseMap(key string) {

	l.evictQueue = append(l.evictQueue, evictKeyConfigs[K]{k, v.dependentConfigs})
}

func (l *lruCache[K]) updateConfigIndex(k K, dependentConfigs []ConfigHash) {
	for _, cfg := range dependentConfigs {
		sets.InsertOrNew(l.configIndex, cfg, k)
	}
}

func (l *lruCache[K]) clearConfigIndex(k K, dependentConfigs []ConfigHash) {
	c, exists := l.store.Get(k)
	if exists {
		newDependents := c.dependentConfigs

			// So deletedClusters.Difference(builtClusters) would give us the correct deleted inbound clusters.
			deletedClusters.Insert(cluster)
		} else {
			if subset == "" {
				sets.InsertOrNew(serviceClusters, string(svcHost), cluster)
			} else {
				sets.InsertOrNew(subsetClusters, string(svcHost), cluster)
			}
			if servicePortClusters[string(svcHost)] == nil {
				servicePortClusters[string(svcHost)] = make(map[int]string)
			}