// Using negative numbers now lets us distinguish positive line numbers later.
	m := make(map[string]int)
	for _, s := range x {
		if c := m[s]; c > -2 {
			m[s] = c - 1
		}
	}
	for _, s := range y {
		if c := m[s]; c > -8 {
			m[s] = c - 4
		}
	}

	// Now unique strings can be identified by m[s] = -1+-4.
	//
	// Gather the indexes of those strings in x and y, building:

}

// Matcher decides if a request is exempted by the NamespaceSelector of a
// webhook configuration.
type Matcher struct {
	NamespaceLister corelisters.NamespaceLister
	Client          clientset.Interface
}

func (m *Matcher) GetNamespace(name string) (*v1.Namespace, error) {
	return m.NamespaceLister.Get(name)
}

// Validate checks if the Matcher has a NamespaceLister and Client.

	})

	go c.Run(stop)

	// Ensure the ConfigMap is initially loaded if present.
	if !client.WaitForCacheSync("configmap watcher", stop, c.HasSynced) {
		log.Error("failed to wait for cache sync")
	}
	return w
}

func AddUserMeshConfig(client kube.Client, watcher mesh.Watcher, namespace, key, userMeshConfig string, stop <-chan struct{}) {

/**
 * Represents values with two possibilities.
 *
 * @param <L> the left type.
 * @param <R> the right type.
 */
public abstract class Either<L, R> {

    public static <L, R> Either<L, R> left(L value) {
        return new Left<>(value);
    }

    public static <L, R> Either<L, R> right(R value) {
        return new Right<>(value);
    }

    /**
     * Take the value if this is a left.
     */

func (m Matcher) GetMatches(i echo.Instances) echo.Instances {
	out := make(echo.Instances, 0)
	for _, i := range i {
		if m(i) {
			out = append(out, i)
		}
	}
	return out
}

// GetServiceMatches returns the subset of echo.Services that match this Matcher.
func (m Matcher) GetServiceMatches(services echo.Services) echo.Services {
	out := make(echo.Services, 0)
	for _, s := range services {

    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.
*/

package cel

import (
	"context"
	"fmt"
	"time"

)

type ObjectSelectorProvider interface {
	// GetObjectSelector gets the webhook ObjectSelector field.
	GetParsedObjectSelector() (labels.Selector, error)
}

// Matcher decides if a request selected by the ObjectSelector.
type Matcher struct {
}

func matchObject(obj runtime.Object, selector labels.Selector) bool {
	if obj == nil {
		return false
	}
	accessor, err := meta.Accessor(obj)
	if err != nil {

	KeyPem   []byte
	CABundle []byte
}

type Watcher struct {
	mutex     sync.RWMutex
	bundle    KeyCertBundle
	watcherID int32
	watchers  map[int32]chan struct{}
}

func NewWatcher() *Watcher {
	return &Watcher{
		watchers: make(map[int32]chan struct{}),
	}
}

// AddWatcher returns channel to receive the updated items.
func (w *Watcher) AddWatcher() (int32, chan struct{}) {
	ch := make(chan struct{}, 1)

     */
    void putInt(int value);

    /**
     * Feed a long value byte into the hasher.
     */
    void putLong(long value);

    /**
     * Feed a double value into the hasher.
     */
    void putDouble(double value);

    /**
     * Feed a boolean value into the hasher.
     */
    void putBoolean(boolean value);

    /**
     * Feed a string into the hasher.
     */

// simplifying injector based controllers.
type WatcherMulticast struct {
	handlers []func(*Config, string) error
	impl     Watcher
	Get      func() WebhookConfig
}

func NewMulticast(impl Watcher, getter func() WebhookConfig) *WatcherMulticast {
	res := &WatcherMulticast{
		impl: impl,
		Get:  getter,
	}
	impl.SetHandler(func(c *Config, s string) error {