func (i Instance) Match(that Instance) bool {
	if len(i) == 0 {
		return false
	}

	return i.SubsetOf(that)
}

// Equals returns true if the labels are equal.
func (i Instance) Equals(that Instance) bool {
	return maps.Equal(i, that)
}

// Validate ensures tag is well-formed
func (i Instance) Validate() error {
	if i == nil {
		return nil
	}

var overrideVar = env.Register("ISTIO_BOOTSTRAP", "", "")

// Instance of a configured Envoy bootstrap writer.
type Instance interface {
	// WriteTo writes the content of the Envoy bootstrap to the given writer.
	WriteTo(templateFile string, w io.Writer) error

	// CreateFile generates an Envoy bootstrap file.
	CreateFile() (string, error)
}

// New creates a new Instance of an Envoy bootstrap writer.
func New(cfg Config) Instance {

	apply(map[string]any) error
}

var _ Instance = &instance{}

type (
	convertFunc func(*instance) (any, error)
	applyFunc   func(map[string]any, *instance) error
)

type instance struct {
	name      Name
	convertFn convertFunc
	applyFn   applyFunc
}

func (i *instance) Name() Name {
	return i.name
}

func (i *instance) withConvert(fn convertFunc) *instance {
	out := *i
	out.convertFn = fn

package resource

import (
	"istio.io/istio/pkg/config"
)

// Instance is the abstract representation of a versioned config resource in Istio.
type Instance struct {
	Metadata Metadata
	Message  config.Spec
	Origin   Origin
}

// IsEmpty returns true if the resource Instance.Message is nil.
func (r *Instance) IsEmpty() bool {
	return r.Message == nil
}

type Instance interface {
	io.Closer
	Start(onReady OnReadyFunc) error
	GetConfig() Config
}

// New creates a new endpoint Instance.
func New(cfg Config) (Instance, error) {
	if cfg.Port != nil {
		switch cfg.Port.Protocol {
		case protocol.HBONE:
			return newHBONE(cfg), nil
		case protocol.HTTP, protocol.HTTPS:
			return newHTTP(cfg), nil
		case protocol.HTTP2, protocol.GRPC:
			return newGRPC(cfg), nil

package timeseries

import (
	"sync"
	"time"
)

type Instance struct {
	data  Data
	times times
	mutex sync.Mutex
}

func (ts *Instance) AddObservation(val float64, t time.Time) {
	ts.mutex.Lock()
	defer ts.mutex.Unlock()
	ts.data = append(ts.data, val)
	ts.times = append(ts.times, t)
}

func (ts *Instance) AddAll(o *Instance) {
	ts.mutex.Lock()
	defer ts.mutex.Unlock()

	}

	// Success.
	return &Instance{
		isJSON:    i.isJSON,
		structure: value,
	}
}

func (i *Instance) appendConstraint(fn func() error) *Instance {
	i.constraints = append(i.constraints, fn)
	return i
}

func (i *Instance) Equals(expected any, path string, args ...any) *Instance {
	path = fmt.Sprintf(path, args...)
	return i.appendConstraint(func() error {

	Addresses() []string

	// Restart restarts the workloads associated with this echo instance
	Restart() error

	// UpdateWorkloadLabel update pod labels of this echo instance
	UpdateWorkloadLabel(add map[string]string, remove []string) error

	// WithWorkloads returns a target with only the specified subset of workloads
	WithWorkloads(wl ...Workload) Instance

	// the server Instance is shutting down, it will wait for the component
	// to complete before exiting.
	// Note: this is best effort; a process can die at any time.
	RunComponentAsyncAndWait(name string, t Component)

	// Wait for this server Instance to shutdown.
	Wait()
}

var _ Instance = &instance{}

// New creates a new server Instance.
func New() Instance {
	return &instance{

								BytesSent:     10,
								EndpointId:    "test",
								InstanceId:    "test",
							},
						},
					},
					{
						container: hcsshim.ContainerProperties{
							ID: "c2",
						}, hcsStats: []hcsshim.NetworkStats{
							{
								BytesReceived: 2,
								BytesSent:     20,
								EndpointId:    "test2",
								InstanceId:    "test2",
							},
						},
					},
				},
			},