text:
package envoy_api_v2_core

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import any "github.com/golang/protobuf/ptypes/any"
import _struct "github.com/golang/protobuf/ptypes/struct"
import wrappers "github.com/golang/protobuf/ptypes/wrappers"
import percent "google.golang.org/grpc/xds/internal/proto/envoy/type/percent"
import _ "google.golang.org/grpc/xds/internal/proto/validate"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

type RoutingPriority int32

const (
	RoutingPriority_DEFAULT RoutingPriority = 0
	RoutingPriority_HIGH    RoutingPriority = 1
)

var RoutingPriority_name = map[int32]string{
	0: "DEFAULT",
	1: "HIGH",
}
var RoutingPriority_value = map[string]int32{
	"DEFAULT": 0,
	"HIGH":    1,
}

func (x RoutingPriority) String() string {
	return proto.EnumName(RoutingPriority_name, int32(x))
}
func (RoutingPriority) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_base_12218511885b7551, []int{0}
}

type RequestMethod int32

const (
	RequestMethod_METHOD_UNSPECIFIED RequestMethod = 0
	RequestMethod_GET                RequestMethod = 1
	RequestMethod_HEAD               RequestMethod = 2
	RequestMethod_POST               RequestMethod = 3
	RequestMethod_PUT                RequestMethod = 4
	RequestMethod_DELETE             RequestMethod = 5
	RequestMethod_CONNECT            RequestMethod = 6
	RequestMethod_OPTIONS            RequestMethod = 7
	RequestMethod_TRACE              RequestMethod = 8
	RequestMethod_PATCH              RequestMethod = 9
)

var RequestMethod_name = map[int32]string{
	0: "METHOD_UNSPECIFIED",
	1: "GET",
	2: "HEAD",
	3: "POST",
	4: "PUT",
	5: "DELETE",
	6: "CONNECT",
	7: "OPTIONS",
	8: "TRACE",
	9: "PATCH",
}
var RequestMethod_value = map[string]int32{
	"METHOD_UNSPECIFIED": 0,
	"GET":                1,
	"HEAD":               2,
	"POST":               3,
	"PUT":                4,
	"DELETE":             5,
	"CONNECT":            6,
	"OPTIONS":            7,
	"TRACE":              8,
	"PATCH":              9,
}

func (x RequestMethod) String() string {
	return proto.EnumName(RequestMethod_name, int32(x))
}
func (RequestMethod) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_base_12218511885b7551, []int{1}
}

type SocketOption_SocketState int32

const (
	SocketOption_STATE_PREBIND   SocketOption_SocketState = 0
	SocketOption_STATE_BOUND     SocketOption_SocketState = 1
	SocketOption_STATE_LISTENING SocketOption_SocketState = 2
)

var SocketOption_SocketState_name = map[int32]string{
	0: "STATE_PREBIND",
	1: "STATE_BOUND",
	2: "STATE_LISTENING",
}
var SocketOption_SocketState_value = map[string]int32{
	"STATE_PREBIND":   0,
	"STATE_BOUND":     1,
	"STATE_LISTENING": 2,
}

func (x SocketOption_SocketState) String() string {
	return proto.EnumName(SocketOption_SocketState_name, int32(x))
}
func (SocketOption_SocketState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_base_12218511885b7551, []int{9, 0}
}

type Locality struct {
	Region               string   `protobuf:"bytes,1,opt,name=region,proto3" json:"region,omitempty"`
	Zone                 string   `protobuf:"bytes,2,opt,name=zone,proto3" json:"zone,omitempty"`
	SubZone              string   `protobuf:"bytes,3,opt,name=sub_zone,json=subZone,proto3" json:"sub_zone,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Locality) Reset()         { *m = Locality{} }
func (m *Locality) String() string { return proto.CompactTextString(m) }
func (*Locality) ProtoMessage()    {}
func (*Locality) Descriptor() ([]byte, []int) {
	return fileDescriptor_base_12218511885b7551, []int{0}
}
func (m *Locality) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Locality.Unmarshal(m, b)
}
func (m *Locality) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Locality.Marshal(b, m, deterministic)
}
func (dst *Locality) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Locality.Merge(dst, src)
}
func (m *Locality) XXX_Size() int {
	return xxx_messageInfo_Locality.Size(m)
}
func (m *Locality) XXX_DiscardUnknown() {
	xxx_messageInfo_Locality.DiscardUnknown(m)
}

var xxx_messageInfo_Locality proto.InternalMessageInfo

func (m *Locality) GetRegion() string {
	if m != nil {
		return m.Region
	}
	return ""
}

func (m *Locality) GetZone() string {
	if m != nil {
		return m.Zone
	}
	return ""
}

func (m *Locality) GetSubZone() string {
	if m != nil {
		return m.SubZone
	}
	return ""
}

type Node struct {
	Id                   string          `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster              string          `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	Metadata             *_struct.Struct `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Locality             *Locality       `protobuf:"bytes,4,opt,name=locality,proto3" json:"locality,omitempty"`
	BuildVersion         string          `protobuf:"bytes,5,opt,name=build_version,json=buildVersion,proto3" json:"build_version,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *Node) Reset()         { *m = Node{} }
func (m *Node) String() string { return proto.CompactTextString(m) }
func (*Node) ProtoMessage()    {}
func (*Node) Descriptor() ([]byte, []int) {
	return fileDescriptor_base_12218511885b7551, []int{1}
}
func (m *Node) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Node.Unmarshal(m, b)
}
func (m *Node) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Node.Marshal(b, m, deterministic)
}
func (dst *Node) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Node.Merge(dst, src)
}
func (m *Node) XXX_Size() int {
	return xxx_messageInfo_Node.Size(m)
}
func (m *Node) XXX_DiscardUnknown() {
	xxx_messageInfo_Node.DiscardUnknown(m)
}

var xxx_messageInfo_Node proto.InternalMessageInfo

func (m *Node) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Node) GetCluster() string {
	if m != nil {
		return m.Cluster
	}
	return ""
}

func (m *Node) GetMetadata() *_struct.Struct {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *Node) GetLocality() *Locality {
	if m != nil {
		return m.Locality
	}
	return nil
}

func (m *Node) GetBuildVersion() string {
	if m != nil {
		return m.BuildVersion
	}
	return ""
}

type Metadata struct {
	FilterMetadata       map[string]*_struct.Struct `protobuf:"bytes,1,rep,name=filter_metadata,json=filterMetadata,proto3" json:"filter_metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *Metadata) Reset()         { *m = Metadata{} }
func (m *Metadata) String() string { return proto.CompactTextString(m) }
func (*Metadata) ProtoMessage()    {}
func (*Metadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_base_12218511885b7551, []int{2}
}
func (m *Metadata) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Metadata.Unmarshal(m, b)
}
func (m *Metadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Metadata.Marshal(b, m, deterministic)
}
func (dst *Metadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Metadata.Merge(dst, src)
}
func (m *Metadata) XXX_Size() int {
	return xxx_messageInfo_Metadata.Size(m)
}
func (m *Metadata) XXX_DiscardUnknown() {
	xxx_messageInfo_Metadata.DiscardUnknown(m)
}

var xxx_messageInfo_Metadata proto.InternalMessageInfo

func (m *Metadata) GetFilterMetadata() map[string]*_struct.Struct {
	if m != nil {
		return m.FilterMetadata
	}
	return nil
}

type RuntimeUInt32 struct {
	DefaultValue         uint32   `protobuf:"varint,2,opt,name=default_value,json=defaultValue,proto3" json:"default_value,omitempty"`
	RuntimeKey           string   `protobuf:"bytes,3,opt,name=runtime_key,json=runtimeKey,proto3" json:"runtime_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RuntimeUInt32) Reset()         { *m = RuntimeUInt32{} }
func (m *RuntimeUInt32) String() string { return proto.CompactTextString(m) }
func (*RuntimeUInt32) ProtoMessage()    {}
func (*RuntimeUInt32) Descriptor() ([]byte, []int) {
	return fileDescriptor_base_12218511885b7551, []int{3}
}
func (m *RuntimeUInt32) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RuntimeUInt32.Unmarshal(m, b)
}
func (m *RuntimeUInt32) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RuntimeUInt32.Marshal(b, m, deterministic)
}
func (dst *RuntimeUInt32) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RuntimeUInt32.Merge(dst, src)
}
func (m *RuntimeUInt32) XXX_Size() int {
	return xxx_messageInfo_RuntimeUInt32.Size(m)
}
func (m *RuntimeUInt32) XXX_DiscardUnknown() {
	xxx_messageInfo_RuntimeUInt32.DiscardUnknown(m)
}

var xxx_messageInfo_RuntimeUInt32 proto.InternalMessageInfo

func (m *RuntimeUInt32) GetDefaultValue() uint32 {
	if m != nil {
		return m.DefaultValue
	}
	return 0
}

func (m *RuntimeUInt32) GetRuntimeKey() string {
	if m != nil {
		return m.RuntimeKey
	}
	return ""
}

type HeaderValue struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *HeaderValue) Reset()         { *m = HeaderValue{} }
func (m *HeaderValue) String() string { return proto.CompactTextString(m) }
func (*HeaderValue) ProtoMessage()    {}
func (*HeaderValue) Descriptor() ([]byte, []int) {
	return fileDescriptor_base_12218511885b7551, []int{4}
}
func (m *HeaderValue) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HeaderValue.Unmarshal(m, b)
}
func (m *HeaderValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HeaderValue.Marshal(b, m, deterministic)
}
func (dst *HeaderValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HeaderValue.Merge(dst, src)
}
func (m *HeaderValue) XXX_Size() int {
	return xxx_messageInfo_HeaderValue.Size(m)
}
func (m *HeaderValue) XXX_DiscardUnknown() {
	xxx_messageInfo_HeaderValue.DiscardUnknown(m)
}

var xxx_messageInfo_HeaderValue proto.InternalMessageInfo

func (m *HeaderValue) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *HeaderValue) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type HeaderValueOption struct {
	Header               *HeaderValue        `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	Append               *wrappers.BoolValue `protobuf:"bytes,2,opt,name=append,proto3" json:"append,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *HeaderValueOption) Reset()         { *m = HeaderValueOption{} }
func (m *HeaderValueOption) String() string { return proto.CompactTextString(m) }
func (*HeaderValueOption) ProtoMessage()    {}
func (*HeaderValueOption) Descriptor() ([]byte, []int) {
	return fileDescriptor_base_12218511885b7551, []int{5}
}
func (m *HeaderValueOption) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HeaderValueOption.Unmarshal(m, b)
}
func (m *HeaderValueOption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HeaderValueOption.Marshal(b, m, deterministic)
}
func (dst *HeaderValueOption) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HeaderValueOption.Merge(dst, src)
}
func (m *HeaderValueOption) XXX_Size() int {
	return xxx_messageInfo_HeaderValueOption.Size(m)
}
func (m *HeaderValueOption) XXX_DiscardUnknown() {
	xxx_messageInfo_HeaderValueOption.DiscardUnknown(m)
}

var xxx_messageInfo_HeaderValueOption proto.InternalMessageInfo

func (m *HeaderValueOption) GetHeader() *HeaderValue {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *HeaderValueOption) GetAppend() *wrappers.BoolValue {
	if m != nil {
		return m.Append
	}
	return nil
}

type HeaderMap struct {
	Headers              []*HeaderValue `protobuf:"bytes,1,rep,name=headers,proto3" json:"headers,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *HeaderMap) Reset()         { *m = HeaderMap{} }
func (m *HeaderMap) String() string { return proto.CompactTextString(m) }
func (*HeaderMap) ProtoMessage()    {}
func (*HeaderMap) Descriptor() ([]byte, []int) {
	return fileDescriptor_base_12218511885b7551, []int{6}
}
func (m *HeaderMap) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HeaderMap.Unmarshal(m, b)
}
func (m *HeaderMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HeaderMap.Marshal(b, m, deterministic)
}
func (dst *HeaderMap) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HeaderMap.Merge(dst, src)
}
func (m *HeaderMap) XXX_Size() int {
	return xxx_messageInfo_HeaderMap.Size(m)
}
func (m *HeaderMap) XXX_DiscardUnknown() {
	xxx_messageInfo_HeaderMap.DiscardUnknown(m)
}

var xxx_messageInfo_HeaderMap proto.InternalMessageInfo

func (m *HeaderMap) GetHeaders() []*HeaderValue {
	if m != nil {
		return m.Headers
	}
	return nil
}

type DataSource struct {
	// Types that are valid to be assigned to Specifier:
	//	*DataSource_Filename
	//	*DataSource_InlineBytes
	//	*DataSource_InlineString
	Specifier            isDataSource_Specifier `protobuf_oneof:"specifier"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *DataSource) Reset()         { *m = DataSource{} }
func (m *DataSource) String() string { return proto.CompactTextString(m) }
func (*DataSource) ProtoMessage()    {}
func (*DataSource) Descriptor() ([]byte, []int) {
	return fileDescriptor_base_12218511885b7551, []int{7}
}
func (m *DataSource) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DataSource.Unmarshal(m, b)
}
func (m *DataSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DataSource.Marshal(b, m, deterministic)
}
func (dst *DataSource) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DataSource.Merge(dst, src)
}
func (m *DataSource) XXX_Size() int {
	return xxx_messageInfo_DataSource.Size(m)
}
func (m *DataSource) XXX_DiscardUnknown() {
	xxx_messageInfo_DataSource.DiscardUnknown(m)
}

var xxx_messageInfo_DataSource proto.InternalMessageInfo

type isDataSource_Specifier interface {
	isDataSource_Specifier()
}

type DataSource_Filename struct {
	Filename string `protobuf:"bytes,1,opt,name=filename,proto3,oneof"`
}

type DataSource_InlineBytes struct {
	InlineBytes []byte `protobuf:"bytes,2,opt,name=inline_bytes,json=inlineBytes,proto3,oneof"`
}

type DataSource_InlineString struct {
	InlineString string `protobuf:"bytes,3,opt,name=inline_string,json=inlineString,proto3,oneof"`
}

func (*DataSource_Filename) isDataSource_Specifier() {}

func (*DataSource_InlineBytes) isDataSource_Specifier() {}

func (*DataSource_InlineString) isDataSource_Specifier() {}

func (m *DataSource) GetSpecifier() isDataSource_Specifier {
	if m != nil {
		return m.Specifier
	}
	return nil
}

func (m *DataSource) GetFilename() string {
	if x, ok := m.GetSpecifier().(*DataSource_Filename); ok {
		return x.Filename
	}
	return ""
}

func (m *DataSource) GetInlineBytes() []byte {
	if x, ok := m.GetSpecifier().(*DataSource_InlineBytes); ok {
		return x.InlineBytes
	}
	return nil
}

func (m *DataSource) GetInlineString() string {
	if x, ok := m.GetSpecifier().(*DataSource_InlineString); ok {
		return x.InlineString
	}
	return ""
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*DataSource) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _DataSource_OneofMarshaler, _DataSource_OneofUnmarshaler, _DataSource_OneofSizer, []interface{}{
		(*DataSource_Filename)(nil),
		(*DataSource_InlineBytes)(nil),
		(*DataSource_InlineString)(nil),
	}
}

func _DataSource_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*DataSource)
	// specifier
	switch x := m.Specifier.(type) {
	case *DataSource_Filename:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.Filename)
	case *DataSource_InlineBytes:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		b.EncodeRawBytes(x.InlineBytes)
	case *DataSource_InlineString:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.InlineString)
	case nil:
	default:
		return fmt.Errorf("DataSource.Specifier has unexpected type %T", x)
	}
	return nil
}

func _DataSource_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*DataSource)
	switch tag {
	case 1: // specifier.filename
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Specifier = &DataSource_Filename{x}
		return true, err
	case 2: // specifier.inline_bytes
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		m.Specifier = &DataSource_InlineBytes{x}
		return true, err
	case 3: // specifier.inline_string
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Specifier = &DataSource_InlineString{x}
		return true, err
	default:
		return false, nil
	}
}

func _DataSource_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*DataSource)
	// specifier
	switch x := m.Specifier.(type) {
	case *DataSource_Filename:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Filename)))
		n += len(x.Filename)
	case *DataSource_InlineBytes:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.InlineBytes)))
		n += len(x.InlineBytes)
	case *DataSource_InlineString:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.InlineString)))
		n += len(x.InlineString)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type TransportSocket struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Types that are valid to be assigned to ConfigType:
	//	*TransportSocket_Config
	//	*TransportSocket_TypedConfig
	ConfigType           isTransportSocket_ConfigType `protobuf_oneof:"config_type"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

func (m *TransportSocket) Reset()         { *m = TransportSocket{} }
func (m *TransportSocket) String() string { return proto.CompactTextString(m) }
func (*TransportSocket) ProtoMessage()    {}
func (*TransportSocket) Descriptor() ([]byte, []int) {
	return fileDescriptor_base_12218511885b7551, []int{8}
}
func (m *TransportSocket) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TransportSocket.Unmarshal(m, b)
}
func (m *TransportSocket) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TransportSocket.Marshal(b, m, deterministic)
}
func (dst *TransportSocket) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TransportSocket.Merge(dst, src)
}
func (m *TransportSocket) XXX_Size() int {
	return xxx_messageInfo_TransportSocket.Size(m)
}
func (m *TransportSocket) XXX_DiscardUnknown() {
	xxx_messageInfo_TransportSocket.DiscardUnknown(m)
}

var xxx_messageInfo_TransportSocket proto.InternalMessageInfo

func (m *TransportSocket) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type isTransportSocket_ConfigType interface {
	isTransportSocket_ConfigType()
}

type TransportSocket_Config struct {
	Config *_struct.Struct `protobuf:"bytes,2,opt,name=config,proto3,oneof"`
}

type TransportSocket_TypedConfig struct {
	TypedConfig *any.Any `protobuf:"bytes,3,opt,name=typed_config,json=typedConfig,proto3,oneof"`
}

func (*TransportSocket_Config) isTransportSocket_ConfigType() {}

func (*TransportSocket_TypedConfig) isTransportSocket_ConfigType() {}

func (m *TransportSocket) GetConfigType() isTransportSocket_ConfigType {
	if m != nil {
		return m.ConfigType
	}
	return nil
}

func (m *TransportSocket) GetConfig() *_struct.Struct {
	if x, ok := m.GetConfigType().(*TransportSocket_Config); ok {
		return x.Config
	}
	return nil
}

func (m *TransportSocket) GetTypedConfig() *any.Any {
	if x, ok := m.GetConfigType().(*TransportSocket_TypedConfig); ok {
		return x.TypedConfig
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*TransportSocket) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _TransportSocket_OneofMarshaler, _TransportSocket_OneofUnmarshaler, _TransportSocket_OneofSizer, []interface{}{
		(*TransportSocket_Config)(nil),
		(*TransportSocket_TypedConfig)(nil),
	}
}

func _TransportSocket_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*TransportSocket)
	// config_type
	switch x := m.ConfigType.(type) {
	case *TransportSocket_Config:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Config); err != nil {
			return err
		}
	case *TransportSocket_TypedConfig:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.TypedConfig); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("TransportSocket.ConfigType has unexpected type %T", x)
	}
	return nil
}

func _TransportSocket_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*TransportSocket)
	switch tag {
	case 2: // config_type.config
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(_struct.Struct)
		err := b.DecodeMessage(msg)
		m.ConfigType = &TransportSocket_Config{msg}
		return true, err
	case 3: // config_type.typed_config
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(any.Any)
		err := b.DecodeMessage(msg)
		m.ConfigType = &TransportSocket_TypedConfig{msg}
		return true, err
	default:
		return false, nil
	}
}

func _TransportSocket_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*TransportSocket)
	// config_type
	switch x := m.ConfigType.(type) {
	case *TransportSocket_Config:
		s := proto.Size(x.Config)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *TransportSocket_TypedConfig:
		s := proto.Size(x.TypedConfig)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type SocketOption struct {
	Description string `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"`
	Level       int64  `protobuf:"varint,2,opt,name=level,proto3" json:"level,omitempty"`
	Name        int64  `protobuf:"varint,3,opt,name=name,proto3" json:"name,omitempty"`
	// Types that are valid to be assigned to Value:
	//	*SocketOption_IntValue
	//	*SocketOption_BufValue
	Value                isSocketOption_Value     `protobuf_oneof:"value"`
	State                SocketOption_SocketState `protobuf:"varint,6,opt,name=state,proto3,enum=envoy.api.v2.core.SocketOption_SocketState" json:"state,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (m *SocketOption) Reset()         { *m = SocketOption{} }
func (m *SocketOption) String() string { return proto.CompactTextString(m) }
func (*SocketOption) ProtoMessage()    {}
func (*SocketOption) Descriptor() ([]byte, []int) {
	return fileDescriptor_base_12218511885b7551, []int{9}
}
func (m *SocketOption) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SocketOption.Unmarshal(m, b)
}
func (m *SocketOption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SocketOption.Marshal(b, m, deterministic)
}
func (dst *SocketOption) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SocketOption.Merge(dst, src)
}
func (m *SocketOption) XXX_Size() int {
	return xxx_messageInfo_SocketOption.Size(m)
}
func (m *SocketOption) XXX_DiscardUnknown() {
	xxx_messageInfo_SocketOption.DiscardUnknown(m)
}

var xxx_messageInfo_SocketOption proto.InternalMessageInfo

func (m *SocketOption) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *SocketOption) GetLevel() int64 {
	if m != nil {
		return m.Level
	}
	return 0
}

func (m *SocketOption) GetName() int64 {
	if m != nil {
		return m.Name
	}
	return 0
}

type isSocketOption_Value interface {
	isSocketOption_Value()
}

type SocketOption_IntValue struct {
	IntValue int64 `protobuf:"varint,4,opt,name=int_value,json=intValue,proto3,oneof"`
}

type SocketOption_BufValue struct {
	BufValue []byte `protobuf:"bytes,5,opt,name=buf_value,json=bufValue,proto3,oneof"`
}

func (*SocketOption_IntValue) isSocketOption_Value() {}

func (*SocketOption_BufValue) isSocketOption_Value() {}

func (m *SocketOption) GetValue() isSocketOption_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *SocketOption) GetIntValue() int64 {
	if x, ok := m.GetValue().(*SocketOption_IntValue); ok {
		return x.IntValue
	}
	return 0
}

func (m *SocketOption) GetBufValue() []byte {
	if x, ok := m.GetValue().(*SocketOption_BufValue); ok {
		return x.BufValue
	}
	return nil
}

func (m *SocketOption) GetState() SocketOption_SocketState {
	if m != nil {
		return m.State
	}
	return SocketOption_STATE_PREBIND
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*SocketOption) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _SocketOption_OneofMarshaler, _SocketOption_OneofUnmarshaler, _SocketOption_OneofSizer, []interface{}{
		(*SocketOption_IntValue)(nil),
		(*SocketOption_BufValue)(nil),
	}
}

func _SocketOption_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*SocketOption)
	// value
	switch x := m.Value.(type) {
	case *SocketOption_IntValue:
		b.EncodeVarint(4<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.IntValue))
	case *SocketOption_BufValue:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		b.EncodeRawBytes(x.BufValue)
	case nil:
	default:
		return fmt.Errorf("SocketOption.Value has unexpected type %T", x)
	}
	return nil
}

func _SocketOption_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*SocketOption)
	switch tag {
	case 4: // value.int_value
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Value = &SocketOption_IntValue{int64(x)}
		return true, err
	case 5: // value.buf_value
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		m.Value = &SocketOption_BufValue{x}
		return true, err
	default:
		return false, nil
	}
}

func _SocketOption_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*SocketOption)
	// value
	switch x := m.Value.(type) {
	case *SocketOption_IntValue:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.IntValue))
	case *SocketOption_BufValue:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.BufValue)))
		n += len(x.BufValue)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type RuntimeFractionalPercent struct {
	DefaultValue         *percent.FractionalPercent `protobuf:"bytes,1,opt,name=default_value,json=defaultValue,proto3" json:"default_value,omitempty"`
	RuntimeKey           string                     `protobuf:"bytes,2,opt,name=runtime_key,json=runtimeKey,proto3" json:"runtime_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *RuntimeFractionalPercent) Reset()         { *m = RuntimeFractionalPercent{} }
func (m *RuntimeFractionalPercent) String() string { return proto.CompactTextString(m) }
func (*RuntimeFractionalPercent) ProtoMessage()    {}
func (*RuntimeFractionalPercent) Descriptor() ([]byte, []int) {
	return fileDescriptor_base_12218511885b7551, []int{10}
}
func (m *RuntimeFractionalPercent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RuntimeFractionalPercent.Unmarshal(m, b)
}
func (m *RuntimeFractionalPercent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RuntimeFractionalPercent.Marshal(b, m, deterministic)
}
func (dst *RuntimeFractionalPercent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RuntimeFractionalPercent.Merge(dst, src)
}
func (m *RuntimeFractionalPercent) XXX_Size() int {
	return xxx_messageInfo_RuntimeFractionalPercent.Size(m)
}
func (m *RuntimeFractionalPercent) XXX_DiscardUnknown() {
	xxx_messageInfo_RuntimeFractionalPercent.DiscardUnknown(m)
}

var xxx_messageInfo_RuntimeFractionalPercent proto.InternalMessageInfo

func (m *RuntimeFractionalPercent) GetDefaultValue() *percent.FractionalPercent {
	if m != nil {
		return m.DefaultValue
	}
	return nil
}

func (m *RuntimeFractionalPercent) GetRuntimeKey() string {
	if m != nil {
		return m.RuntimeKey
	}
	return ""
}

type ControlPlane struct {
	Identifier           string   `protobuf:"bytes,1,opt,name=identifier,proto3" json:"identifier,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ControlPlane) Reset()         { *m = ControlPlane{} }
func (m *ControlPlane) String() string { return proto.CompactTextString(m) }
func (*ControlPlane) ProtoMessage()    {}
func (*ControlPlane) Descriptor() ([]byte, []int) {
	return fileDescriptor_base_12218511885b7551, []int{11}
}
func (m *ControlPlane) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ControlPlane.Unmarshal(m, b)
}
func (m *ControlPlane) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ControlPlane.Marshal(b, m, deterministic)
}
func (dst *ControlPlane) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ControlPlane.Merge(dst, src)
}
func (m *ControlPlane) XXX_Size() int {
	return xxx_messageInfo_ControlPlane.Size(m)
}
func (m *ControlPlane) XXX_DiscardUnknown() {
	xxx_messageInfo_ControlPlane.DiscardUnknown(m)
}

var xxx_messageInfo_ControlPlane proto.InternalMessageInfo

func (m *ControlPlane) GetIdentifier() string {
	if m != nil {
		return m.Identifier
	}
	return ""
}

func init() {
	proto.RegisterType((*Locality)(nil), "envoy.api.v2.core.Locality")
	proto.RegisterType((*Node)(nil), "envoy.api.v2.core.Node")
	proto.RegisterType((*Metadata)(nil), "envoy.api.v2.core.Metadata")
	proto.RegisterMapType((map[string]*_struct.Struct)(nil), "envoy.api.v2.core.Metadata.FilterMetadataEntry")
	proto.RegisterType((*RuntimeUInt32)(nil), "envoy.api.v2.core.RuntimeUInt32")
	proto.RegisterType((*HeaderValue)(nil), "envoy.api.v2.core.HeaderValue")
	proto.RegisterType((*HeaderValueOption)(nil), "envoy.api.v2.core.HeaderValueOption")
	proto.RegisterType((*HeaderMap)(nil), "envoy.api.v2.core.HeaderMap")
	proto.RegisterType((*DataSource)(nil), "envoy.api.v2.core.DataSource")
	proto.RegisterType((*TransportSocket)(nil), "envoy.api.v2.core.TransportSocket")
	proto.RegisterType((*SocketOption)(nil), "envoy.api.v2.core.SocketOption")
	proto.RegisterType((*RuntimeFractionalPercent)(nil), "envoy.api.v2.core.RuntimeFractionalPercent")
	proto.RegisterType((*ControlPlane)(nil), "envoy.api.v2.core.ControlPlane")
	proto.RegisterEnum("envoy.api.v2.core.RoutingPriority", RoutingPriority_name, RoutingPriority_value)
	proto.RegisterEnum("envoy.api.v2.core.RequestMethod", RequestMethod_name, RequestMethod_value)
	proto.RegisterEnum("envoy.api.v2.core.SocketOption_SocketState", SocketOption_SocketState_name, SocketOption_SocketState_value)
}

func init() { proto.RegisterFile("envoy/api/v2/core/base.proto", fileDescriptor_base_12218511885b7551) }

var fileDescriptor_base_12218511885b7551 = []byte{
	// 1125 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x55, 0xcd, 0x72, 0x1b, 0x45,
	0x10, 0xf6, 0xea, 0xcf, 0x52, 0x4b, 0xb2, 0x37, 0x93, 0x54, 0xa2, 0x98, 0x38, 0x31, 0xe2, 0x80,
	0x2b, 0x14, 0x2b, 0x50, 0xa8, 0x22, 0x70, 0xf3, 0x4a, 0xeb, 0x48, 0x85, 0x2d, 0x29, 0xab, 0x75,
	0xa0, 0x72, 0x11, 0x23, 0xed, 0xc8, 0x99, 0xca, 0x66, 0x67, 0x99, 0x9d, 0x15, 0x28, 0xa7, 0x14,
	0x37, 0xc8, 0xa3, 0x50, 0xdc, 0x29, 0x4e, 0xa9, 0xe2, 0xc4, 0xa3, 0xe4, 0x2d, 0xa8, 0xf9, 0x91,
	0x23, 0x47, 0x2e, 0x72, 0x9b, 0xf9, 0xfa, 0xfb, 0x7a, 0xbb, 0x7b, 0xba, 0x7b, 0xe1, 0x0e, 0x89,
	0x17, 0x6c, 0xd9, 0xc2, 0x09, 0x6d, 0x2d, 0xda, 0xad, 0x19, 0xe3, 0xa4, 0x35, 0xc5, 0x29, 0x71,
	0x12, 0xce, 0x04, 0x43, 0xd7, 0x94, 0xd5, 0xc1, 0x09, 0x75, 0x16, 0x6d, 0x47, 0x5a, 0xf7, 0x6e,
	0x9f, 0x33, 0x76, 0x1e, 0x91, 0x96, 0x22, 0x4c, 0xb3, 0x79, 0x0b, 0xc7, 0x4b, 0xcd, 0xde, 0xbb,
	0xf3, 0xbe, 0x29, 0x15, 0x3c, 0x9b, 0x09, 0x63, 0xbd, 0xfb, 0xbe, 0xf5, 0x67, 0x8e, 0x93, 0x84,
	0xf0, 0xd4, 0xd8, 0x6f, 0x2d, 0x70, 0x44, 0x43, 0x2c, 0x48, 0x6b, 0x75, 0x30, 0x86, 0x86, 0x0e,
	0x51, 0x2c, 0x13, 0xd2, 0x4a, 0x08, 0x9f, 0x91, 0xd8, 0xb8, 0x6c, 0x3e, 0x86, 0xf2, 0x09, 0x9b,
	0xe1, 0x88, 0x8a, 0x25, 0xba, 0x09, 0x25, 0x4e, 0xce, 0x29, 0x8b, 0x1b, 0xd6, 0x81, 0x75, 0x58,
	0xf1, 0xcd, 0x0d, 0x21, 0x28, 0xbc, 0x64, 0x31, 0x69, 0xe4, 0x14, 0xaa, 0xce, 0xe8, 0x36, 0x94,
	0xd3, 0x6c, 0x3a, 0x51, 0x78, 0x5e, 0xe1, 0xdb, 0x69, 0x36, 0x7d, 0xca, 0x62, 0xd2, 0xfc, 0xc7,
	0x82, 0xc2, 0x80, 0x85, 0x04, 0xed, 0x40, 0x8e, 0x86, 0xc6, 0x57, 0x8e, 0x86, 0xa8, 0x01, 0xdb,
	0xb3, 0x28, 0x4b, 0x05, 0xe1, 0xc6, 0xd5, 0xea, 0x8a, 0x1e, 0x40, 0xf9, 0x05, 0x11, 0x38, 0xc4,
	0x02, 0x2b, 0x6f, 0xd5, 0xf6, 0x2d, 0x47, 0xe7, 0xea, 0xac, 0x72, 0x75, 0xc6, 0xaa, 0x12, 0xfe,
	0x05, 0x11, 0x7d, 0x0d, 0xe5, 0xc8, 0x84, 0xde, 0x28, 0x28, 0xd1, 0x47, 0xce, 0x46, 0xb1, 0x9d,
	0x55, 0x76, 0xfe, 0x05, 0x19, 0x7d, 0x02, 0xf5, 0x69, 0x46, 0xa3, 0x70, 0xb2, 0x20, 0x3c, 0x95,
	0xe9, 0x16, 0x55, 0x34, 0x35, 0x05, 0x3e, 0xd1, 0x58, 0xf3, 0x8d, 0x05, 0xe5, 0xd3, 0xd5, 0xa7,
	0x7e, 0x80, 0xdd, 0x39, 0x8d, 0x04, 0xe1, 0x93, 0x8b, 0x30, 0xad, 0x83, 0xfc, 0x61, 0xb5, 0xdd,
	0xba, 0xe2, 0x8b, 0x2b, 0x95, 0x73, 0xac, 0x24, 0xab, 0xab, 0x17, 0x0b, 0xbe, 0xf4, 0x77, 0xe6,
	0x97, 0xc0, 0xbd, 0xa7, 0x70, 0xfd, 0x0a, 0x1a, 0xb2, 0x21, 0xff, 0x9c, 0x2c, 0x4d, 0xed, 0xe4,
	0x11, 0x7d, 0x0e, 0xc5, 0x05, 0x8e, 0x32, 0xfd, 0x0a, 0xff, 0x53, 0x1f, 0xcd, 0xfa, 0x36, 0xf7,
	0xd0, 0x6a, 0xfe, 0x08, 0x75, 0x3f, 0x8b, 0x05, 0x7d, 0x41, 0xce, 0xfa, 0xb1, 0x78, 0xd0, 0x96,
	0x89, 0x87, 0x64, 0x8e, 0xb3, 0x48, 0x4c, 0xde, 0xf9, 0xaa, 0xfb, 0x35, 0x03, 0x3e, 0x91, 0x18,
	0xba, 0x0f, 0x55, 0xae, 0x55, 0x13, 0x19, 0x82, 0x7a, 0x5c, 0xb7, 0xf2, 0xf7, 0xdb, 0x37, 0xf9,
	0x02, 0xcf, 0x1d, 0x58, 0x3e, 0x18, 0xeb, 0x77, 0x64, 0xd9, 0x7c, 0x0c, 0xd5, 0x1e, 0xc1, 0x21,
	0xe1, 0x5a, 0x7a, 0x6f, 0x2d, 0x6a, 0xb7, 0x2e, 0x25, 0x65, 0x5e, 0x3a, 0xb0, 0x0e, 0x5f, 0xbd,
	0xb2, 0x74, 0x12, 0x1f, 0xaf, 0x27, 0x51, 0x71, 0xab, 0x92, 0x52, 0xe2, 0x05, 0x45, 0xd0, 0x96,
	0xe6, 0x6b, 0x0b, 0xae, 0xad, 0xf9, 0x1c, 0x26, 0x42, 0xb6, 0xa0, 0x0b, 0xa5, 0x67, 0x0a, 0x54,
	0xce, 0xab, 0xed, 0xbb, 0x57, 0xd4, 0x7d, 0x4d, 0xe5, 0x82, 0xf4, 0x5c, 0xfc, 0xdd, 0xca, 0xd9,
	0x96, 0x6f, 0x94, 0xa8, 0x0d, 0x25, 0x39, 0x2d, 0x71, 0x68, 0x4a, 0xb8, 0xb7, 0x51, 0x42, 0x97,
	0xb1, 0x48, 0xe9, 0x7d, 0xc3, 0x6c, 0x7a, 0x50, 0xd1, 0x6e, 0x4f, 0x71, 0x82, 0x1e, 0xc2, 0xb6,
	0x76, 0x95, 0x9a, 0xd7, 0xff, 0x40, 0x14, 0xfe, 0x8a, 0xde, 0xfc, 0xc3, 0x02, 0xe8, 0x62, 0x81,
	0xc7, 0x2c, 0xe3, 0x33, 0x82, 0x3e, 0x85, 0xf2, 0x9c, 0x46, 0x24, 0xc6, 0x2f, 0x88, 0x29, 0xd6,
	0xbb, 0xfa, 0xf6, 0xb6, 0xfc, 0x0b, 0x23, 0x72, 0xa0, 0x46, 0xe3, 0x88, 0xc6, 0x64, 0x32, 0x5d,
	0x0a, 0x92, 0xaa, 0xc0, 0x6b, 0x86, 0xfc, 0x32, 0x67, 0x4b, 0x72, 0x55, 0x13, 0x5c, 0x69, 0x47,
	0x5f, 0x40, 0xdd, 0xf0, 0x53, 0xc1, 0x69, 0x7c, 0xbe, 0xf1, 0x7a, 0xbd, 0x2d, 0xdf, 0x78, 0x1c,
	0x2b, 0x82, 0x8b, 0xa0, 0x92, 0x26, 0x64, 0x46, 0xe7, 0x94, 0x70, 0x54, 0xfc, 0xeb, 0xed, 0x9b,
	0xbc, 0xd5, 0xfc, 0xd3, 0x82, 0xdd, 0x80, 0xe3, 0x38, 0x4d, 0x18, 0x17, 0x63, 0x36, 0x7b, 0x4e,
	0x04, 0xda, 0x87, 0xc2, 0x95, 0xe1, 0xfa, 0x0a, 0x46, 0x5f, 0x42, 0x69, 0xc6, 0xe2, 0x39, 0x3d,
	0xff, 0x40, 0x7b, 0xf6, 0xb6, 0x7c, 0x43, 0x44, 0xdf, 0x40, 0x4d, 0xee, 0xa3, 0x70, 0x62, 0x84,
	0x7a, 0xee, 0x6f, 0x6c, 0x08, 0x8f, 0xe2, 0xa5, 0x4c, 0x53, 0x71, 0x3b, 0x8a, 0xea, 0xd6, 0xa1,
	0xaa, 0x45, 0x13, 0x89, 0x36, 0xff, 0xcd, 0x41, 0x4d, 0x87, 0x69, 0xba, 0xe5, 0x00, 0xaa, 0x21,
	0x49, 0x67, 0x9c, 0xaa, 0xab, 0x99, 0xa2, 0x75, 0x08, 0xdd, 0x80, 0x62, 0x44, 0x16, 0x24, 0x52,
	0xe1, 0xe6, 0x7d, 0x7d, 0x91, 0x8b, 0x4e, 0x25, 0x99, 0x57, 0xa0, 0xce, 0x6c, 0x1f, 0x2a, 0x34,
	0x5e, 0xcd, 0x8b, 0x5c, 0x33, 0x79, 0xf9, 0x42, 0x34, 0x36, 0xd3, 0xb2, 0x0f, 0x95, 0x69, 0x36,
	0x37, 0x66, 0xb9, 0x47, 0x6a, 0xd2, 0x3c, 0xcd, 0xe6, 0xda, 0xfc, 0x3d, 0x14, 0x53, 0x81, 0x05,
	0x69, 0xc8, 0x31, 0xd8, 0x69, 0x7f, 0x76, 0x45, 0xc3, 0xac, 0x47, 0x6e, 0x2e, 0x63, 0x29, 0x71,
	0x6f, 0xbc, 0xeb, 0x61, 0x75, 0xfa, 0x55, 0x75, 0xb3, 0xf6, 0xd7, 0x3c, 0x86, 0xea, 0x1a, 0x17,
	0x5d, 0x83, 0xfa, 0x38, 0x38, 0x0a, 0xbc, 0xc9, 0xc8, 0xf7, 0xdc, 0xfe, 0xa0, 0x6b, 0x6f, 0xa1,
	0x5d, 0xa8, 0x6a, 0xc8, 0x1d, 0x9e, 0x0d, 0xba, 0xb6, 0x85, 0xae, 0xc3, 0xae, 0x06, 0x4e, 0xfa,
	0xe3, 0xc0, 0x1b, 0xf4, 0x07, 0x8f, 0xec, 0x9c, 0xbb, 0x63, 0x26, 0x72, 0xf5, 0xf6, 0xaf, 0x2d,
	0x68, 0x98, 0xa5, 0x71, 0xcc, 0xf1, 0x4c, 0x06, 0x85, 0xa3, 0x91, 0xfe, 0x65, 0xa0, 0xc1, 0xfb,
	0xfb, 0x43, 0x0f, 0xe3, 0xbe, 0xc9, 0x4a, 0x3e, 0x86, 0xb3, 0xa1, 0xba, 0x34, 0x8b, 0x97, 0x57,
	0xcd, 0xbd, 0xcb, 0xab, 0x46, 0xff, 0x14, 0xd6, 0xf7, 0x8b, 0x03, 0xb5, 0x0e, 0x8b, 0x05, 0x67,
	0xd1, 0x28, 0xc2, 0x31, 0x41, 0x77, 0x01, 0x68, 0x48, 0x62, 0xa1, 0xda, 0xd5, 0xbc, 0xeb, 0x1a,
	0x72, 0xff, 0x10, 0x76, 0x7d, 0x96, 0x09, 0x1a, 0x9f, 0x8f, 0x38, 0x65, 0x5c, 0x2e, 0xfb, 0x2a,
	0x6c, 0x77, 0xbd, 0xe3, 0xa3, 0xb3, 0x93, 0xc0, 0xde, 0x42, 0x65, 0x28, 0xf4, 0xfa, 0x8f, 0x7a,
	0xb6, 0x75, 0xff, 0x37, 0x0b, 0xea, 0x3e, 0xf9, 0x29, 0x23, 0xa9, 0x38, 0x25, 0xe2, 0x19, 0x0b,
	0xd1, 0x4d, 0x40, 0xa7, 0x5e, 0xd0, 0x1b, 0x76, 0x27, 0x67, 0x83, 0xf1, 0xc8, 0xeb, 0xf4, 0x8f,
	0xfb, 0x9e, 0xac, 0xe3, 0x36, 0xe4, 0x1f, 0x79, 0x81, 0x6d, 0x29, 0xb1, 0x77, 0xd4, 0xb5, 0x73,
	0xf2, 0x34, 0x1a, 0x8e, 0x03, 0x3b, 0x2f, 0x8d, 0xa3, 0xb3, 0xc0, 0x2e, 0x20, 0x80, 0x52, 0xd7,
	0x3b, 0xf1, 0x02, 0xcf, 0x2e, 0xca, 0x4f, 0x76, 0x86, 0x83, 0x81, 0xd7, 0x09, 0xec, 0x92, 0xbc,
	0x0c, 0x47, 0x41, 0x7f, 0x38, 0x18, 0xdb, 0xdb, 0xa8, 0x02, 0xc5, 0xc0, 0x3f, 0xea, 0x78, 0x76,
	0x59, 0x1e, 0x47, 0x47, 0x41, 0xa7, 0x67, 0x57, 0xdc, 0xaf, 0xe0, 0x1e, 0x65, 0xba, 0x86, 0x09,
	0x67, 0xbf, 0x2c, 0x37, 0x9b, 0xc4, 0xad, 0xb8, 0x38, 0x25, 0x23, 0x39, 0x12, 0x23, 0xeb, 0x69,
	0x41, 0x42, 0xd3, 0x92, 0x9a, 0x90, 0x07, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xb5, 0x03, 0x41,
	0x71, 0x7f, 0x08, 0x00, 0x00,
}


text:
struct S;

impl Drop for S {
    fn drop(&mut self) {
    }
}

fn might_unwind() {
}

// CHECK-LABEL: @test
#[no_mangle]
pub fn test() {
    let _s = S;
    // Check that the personality slot alloca gets a lifetime start in each cleanup block, not just
    // in the first one.
    // CHECK-LABEL: cleanup:
    // CHECK: bitcast{{.*}}personalityslot
    // CHECK-NEXT: call void @llvm.lifetime.start
    // CHECK-LABEL: cleanup1:
    // CHECK: bitcast{{.*}}personalityslot
    // CHECK-NEXT: call void @llvm.lifetime.start
    might_unwind();
    let _t = S;
    might_unwind();
}

redpajama_set_name: RedPajamaGithub


text:
angular.module('UiElements', [])
.factory('UiFactory', UiFactory);

UiFactory.$inject = ['$rootScope', '$uibModal', '$timeout'];

function UiFactory($rootScope, $uibModal, $timeout) {
    $rootScope.alertMessage = []; // Alert message
    $rootScope.datePick = { // Date picker
        opened1: false,
        opened12: false
    };
    $rootScope.closeAlert = function(index) {
        $rootScope.alertMessage.splice(index, 1);
    };
    return {
        alert: function(alertType, message) {
            $rootScope.alertMessage.push({
                type: alertType,
                msg: message
            });
            $timeout(function() {
                $rootScope.alertMessage = [];
            }, 3000);
        },
        datePicker: {
            dpPopup1: function() {
                $rootScope.datePick.opened1 = true;
            },
            dpPopup2: function() {
                $rootScope.datePick.opened2 = true;
            }
        },
        modal: {
            open: function(size, template) {
                var modalInstance = $uibModal.open({
                    animation: true,
                    templateUrl: template,
                    controller: function($uibModalInstance) {
                        $rootScope.ok = function() {
                            $uibModalInstance.close();
                        };
                        $rootScope.dismissModal = function() {
                            $uibModalInstance.dismiss('cancel');
                        };
                    },
                    // backdrop: 'static',
                    size: size,
                });
            }
        }
    };
}


text:
package net.violet.mynabaztag.form;

import java.util.ArrayList;
import java.util.List;

import net.violet.mynabaztag.data.PlayerData;
import net.violet.platform.util.StringShop;

public class MySrvPlayerForm extends AbstractForm {

	private static final long serialVersionUID = 491597568795993297L;

	private int isMarkup; // il y a t'il eu une lecture du bouquin
	private long sizeVoice;
	private long appletId;
	private long voiceId;
	private long bookId; // id du ZtampImpl
	private long srvId;
	private List<PlayerData> mySetting = new ArrayList<PlayerData>();
	private Long isbn = 0L;
	private String dicoRoot = StringShop.EMPTY_STRING;
	private String bookSerial = StringShop.EMPTY_STRING;

	public String getBookSerial() {
		return this.bookSerial;
	}

	public void setBookSerial(String bookSerial) {
		this.bookSerial = bookSerial;
	}

	public List<PlayerData> getMySetting() {
		return this.mySetting;
	}

	public void setMySetting(List<PlayerData> mySetting) {
		this.mySetting = mySetting;
	}

	public long getSizeVoice() {
		return this.sizeVoice;
	}

	public void setSizeVoice(long sizeVoice) {
		this.sizeVoice = sizeVoice;
	}

	public long getAppletId() {
		return this.appletId;
	}

	public void setAppletId(long appletId) {
		this.appletId = appletId;
	}

	public int getIsMarkup() {
		return this.isMarkup;
	}

	public void setIsMarkup(int isMarkup) {
		this.isMarkup = isMarkup;
	}

	public long getSrvId() {
		return this.srvId;
	}

	public void setSrvId(long srvId) {
		this.srvId = srvId;
	}

	public long getVoiceId() {
		return this.voiceId;
	}

	public void setVoiceId(long voiceId) {
		this.voiceId = voiceId;
	}

	public long getBookId() {
		return this.bookId;
	}

	public void setBookId(long bookId) {
		this.bookId = bookId;
	}

	/**
	 * @return the isbn
	 */
	public Long getIsbn() {
		return this.isbn;
	}

	/**
	 * @param isbn the isbn to set
	 */
	public void setIsbn(Long isbn) {
		this.isbn = isbn;
	}

	/**
	 * @return the dicoRoot
	 */
	public String getDicoRoot() {
		return this.dicoRoot;
	}

	/**
	 * @param dicoRoot the dicoRoot to set
	 */
	public void setDicoRoot(String dicoRoot) {
		this.dicoRoot = dicoRoot;
	}

}


text:
<?php

namespace Vich\UploaderBundle\Storage;

use Vich\UploaderBundle\Mapping\PropertyMapping;

/**
 * @author Dustin Dobervich <ddobervich@gmail.com>
 */
interface StorageInterface
{
    /**
     * Uploads the file in the uploadable field of the specified object
     * according to the property configuration.
     *
     * @param object          $obj     The object
     * @param PropertyMapping $mapping The mapping representing the field to upload
     */
    public function upload($obj, PropertyMapping $mapping);

    /**
     * Removes the files associated with the given mapping.
     *
     * @param object          $obj     The object
     * @param PropertyMapping $mapping The mapping representing the field to remove
     */
    public function remove($obj, PropertyMapping $mapping);

    /**
     * Resolves the path for a file based on the specified object
     * and mapping name.
     *
     * @param object|array $obj       The object
     * @param string       $fieldName The field to use
     * @param string       $className The object's class. Mandatory if $obj can't be used to determine it
     * @param bool         $relative  Whether the path should be relative or absolute
     *
     * @return string The path
     */
    public function resolvePath($obj, $fieldName, $className = null, $relative = false);

    //TODO: inconsistency - use PropertyMapping instead of fieldName+className

    /**
     * Resolves the uri based on the specified object and mapping name.
     *
     * @param object|array $obj       The object
     * @param string       $fieldName The field to use
     * @param string       $className The object's class. Mandatory if $obj can't be used to determine it
     *
     * @return string|null The uri or null if file not stored
     */
    public function resolveUri($obj, $fieldName, $className = null);

    /**
     * Returns a read-only stream based on the specified object and mapping
     * name.
     *
     * @param object|array $obj       The object
     * @param string       $fieldName The field to use
     * @param string       $className The object's class. Mandatory if $obj can't be used to determine it
     *
     * @return resource|null The resolved resource or null if file not stored
     */
    public function resolveStream($obj, $fieldName, $className = null);
}


text:
package com.rainbow.red_alert.monitor.util;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

public final class HttpUtil {
    private HttpUtil() {
    }

    public static String urlEncode(String str) throws UnsupportedEncodingException {
        return URLEncoder.encode(str, StandardCharsets.UTF_8.toString());
    }
}


text:
require 'test_helper'

class ProductsControllerTest < ActionController::TestCase
  setup do
    @product = products(:one)
  end

  test "should get index" do
    get :index
    assert_response :success
    assert_not_nil assigns(:products)
  end

end


text:
module.exports = function () {
    "use strict";

    let beyond = require('../../../..');
    let Rest = beyond.helpers.Rest;
    let rest = new Rest(
        'logs',
        {
            'logs': {'calls': 'calls.log', 'errors': 'errors.log'},
            'hosts': {'example': {'development': 'http://localhost:9000'}}
        },
        'development');

    this.delayed = require('async')(function *(resolve, reject, params, context) {

        setTimeout(function () {
            resolve('hello world');
        }, 2000);

    });

    this.rest = require('async')(function *(resolve, reject, params, context) {
        let rq = new rest.Request();
        rq.host = 'example';
        rq.path = '/';
        resolve((yield rq.execute()));
    });

};


text:
jest.mock('../plugins');
import {
  loadPlugin,
  switchPlugin,
  uninstallPlugin,
} from '../../reducers/pluginManager';
import {requirePlugin} from '../plugins';
import {mocked} from 'ts-jest/utils';
import {TestUtils} from 'flipper-plugin';
import * as TestPlugin from '../../__tests__/test-utils/TestPlugin';
import {_SandyPluginDefinition as SandyPluginDefinition} from 'flipper-plugin';
import MockFlipper from '../../__tests__/test-utils/MockFlipper';
import Client from '../../Client';
import React from 'react';
import {BaseDevice} from 'flipper-frontend-core';
import {awaitPluginCommandQueueEmpty} from '../pluginManager';

const pluginDetails1 = TestUtils.createMockPluginDetails({
  id: 'plugin1',
  name: 'flipper-plugin1',
  version: '0.0.1',
});
const pluginDefinition1 = new SandyPluginDefinition(pluginDetails1, TestPlugin);

const pluginDetails1V2 = TestUtils.createMockPluginDetails({
  id: 'plugin1',
  name: 'flipper-plugin1',
  version: '0.0.2',
});
const pluginDefinition1V2 = new SandyPluginDefinition(
  pluginDetails1V2,
  TestPlugin,
);

const pluginDetails2 = TestUtils.createMockPluginDetails({
  id: 'plugin2',
  name: 'flipper-plugin2',
});
const pluginDefinition2 = new SandyPluginDefinition(pluginDetails2, TestPlugin);

const devicePluginDetails = TestUtils.createMockPluginDetails({
  id: 'device',
  name: 'flipper-device',
});
const devicePluginDefinition = new SandyPluginDefinition(devicePluginDetails, {
  supportsDevice() {
    return true;
  },
  devicePlugin() {
    return {};
  },
  Component() {
    return
Plugin3
;
  },
});

const mockedRequirePlugin = mocked(requirePlugin);

let mockFlipper: MockFlipper;
let mockClient: Client;
let mockDevice: BaseDevice;

beforeEach(async () => {
  mockedRequirePlugin.mockImplementation(
    async (details) =>
      (details === pluginDetails1
        ? pluginDefinition1
        : details === pluginDetails2
        ? pluginDefinition2
        : details === pluginDetails1V2
        ? pluginDefinition1V2
        : details === devicePluginDetails
        ? devicePluginDefinition
        : undefined)!,
  );
  mockFlipper = new MockFlipper();
  const initResult = await mockFlipper.initWithDeviceAndClient({
    clientOptions: {supportedPlugins: ['plugin1', 'plugin2']},
  });
  mockClient = initResult.client;
  mockDevice = initResult.device;
});

afterEach(async () => {
  mockedRequirePlugin.mockReset();
  await mockFlipper.destroy();
});

test('load plugin when no other version loaded', async () => {
  mockFlipper.dispatch(
    loadPlugin({plugin: pluginDetails1, enable: false, notifyIfFailed: false}),
  );

  await awaitPluginCommandQueueEmpty(mockFlipper.store);
  expect(mockFlipper.getState().plugins.clientPlugins.get('plugin1')).toBe(
    pluginDefinition1,
  );
  expect(mockFlipper.getState().plugins.loadedPlugins.get('plugin1')).toBe(
    pluginDetails1,
  );
  expect(mockClient.sandyPluginStates.has('plugin1')).toBeFalsy();
});

test('load plugin when other version loaded', async () => {
  mockFlipper.dispatch(
    loadPlugin({plugin: pluginDetails1, enable: false, notifyIfFailed: false}),
  );
  mockFlipper.dispatch(
    loadPlugin({
      plugin: pluginDetails1V2,
      enable: false,
      notifyIfFailed: false,
    }),
  );

  await awaitPluginCommandQueueEmpty(mockFlipper.store);
  expect(mockFlipper.getState().plugins.clientPlugins.get('plugin1')).toBe(
    pluginDefinition1V2,
  );
  expect(mockFlipper.getState().plugins.loadedPlugins.get('plugin1')).toBe(
    pluginDetails1V2,
  );
  expect(mockClient.sandyPluginStates.has('plugin1')).toBeFalsy();
});

test('load and enable Sandy plugin', async () => {
  mockFlipper.dispatch(
    loadPlugin({plugin: pluginDetails1, enable: true, notifyIfFailed: false}),
  );

  await awaitPluginCommandQueueEmpty(mockFlipper.store);
  expect(mockFlipper.getState().plugins.clientPlugins.get('plugin1')).toBe(
    pluginDefinition1,
  );
  expect(mockFlipper.getState().plugins.loadedPlugins.get('plugin1')).toBe(
    pluginDetails1,
  );
  expect(mockClient.sandyPluginStates.has('plugin1')).toBeTruthy();
});

test('uninstall plugin', async () => {
  mockFlipper.dispatch(
    loadPlugin({plugin: pluginDetails1, enable: true, notifyIfFailed: false}),
  );
  mockFlipper.dispatch(uninstallPlugin({plugin: pluginDefinition1}));

  await awaitPluginCommandQueueEmpty(mockFlipper.store);
  expect(
    mockFlipper.getState().plugins.clientPlugins.has('plugin1'),
  ).toBeFalsy();
  expect(
    mockFlipper.getState().plugins.loadedPlugins.has('plugin1'),
  ).toBeFalsy();
  expect(
    mockFlipper
      .getState()
      .plugins.uninstalledPluginNames.has('flipper-plugin1'),
  ).toBeTruthy();
  expect(mockClient.sandyPluginStates.has('plugin1')).toBeFalsy();
});

test('star plugin', async () => {
  mockFlipper.dispatch(
    loadPlugin({plugin: pluginDetails1, enable: false, notifyIfFailed: false}),
  );
  mockFlipper.dispatch(
    switchPlugin({
      plugin: pluginDefinition1,
      selectedApp: mockClient.query.app,
    }),
  );

  await awaitPluginCommandQueueEmpty(mockFlipper.store);
  expect(
    mockFlipper.getState().connections.enabledPlugins[mockClient.query.app],
  ).toContain('plugin1');
  expect(mockClient.sandyPluginStates.has('plugin1')).toBeTruthy();
});

test('disable plugin', async () => {
  mockFlipper.dispatch(
    loadPlugin({plugin: pluginDetails1, enable: false, notifyIfFailed: false}),
  );
  mockFlipper.dispatch(
    switchPlugin({
      plugin: pluginDefinition1,
      selectedApp: mockClient.query.app,
    }),
  );
  mockFlipper.dispatch(
    switchPlugin({
      plugin: pluginDefinition1,
      selectedApp: mockClient.query.app,
    }),
  );

  await awaitPluginCommandQueueEmpty(mockFlipper.store);
  expect(
    mockFlipper.getState().connections.enabledPlugins[mockClient.query.app],
  ).not.toContain('plugin1');
  expect(mockClient.sandyPluginStates.has('plugin1')).toBeFalsy();
});

test('star device plugin', async () => {
  mockFlipper.dispatch(
    loadPlugin({
      plugin: devicePluginDetails,
      enable: false,
      notifyIfFailed: false,
    }),
  );
  mockFlipper.dispatch(
    switchPlugin({
      plugin: devicePluginDefinition,
    }),
  );

  await awaitPluginCommandQueueEmpty(mockFlipper.store);
  expect(
    mockFlipper.getState().connections.enabledDevicePlugins.has('device'),
  ).toBeTruthy();
  expect(mockDevice.sandyPluginStates.has('device')).toBeTruthy();
});

test('disable device plugin', async () => {
  mockFlipper.dispatch(
    loadPlugin({
      plugin: devicePluginDetails,
      enable: false,
      notifyIfFailed: false,
    }),
  );
  mockFlipper.dispatch(
    switchPlugin({
      plugin: devicePluginDefinition,
    }),
  );
  mockFlipper.dispatch(
    switchPlugin({
      plugin: devicePluginDefinition,
    }),
  );

  await awaitPluginCommandQueueEmpty(mockFlipper.store);
  expect(
    mockFlipper.getState().connections.enabledDevicePlugins.has('device'),
  ).toBeFalsy();
  expect(mockDevice.sandyPluginStates.has('device')).toBeFalsy();
});


text:
title: Rooms of Doom
---
## Problem 327: Rooms of Doom

This is a stub. Help our community expand it.

This quick style guide will help ensure your pull request gets accepted.


text:
using JetBrains.ReSharper.Plugins.Unity.CSharp.Daemon.Stages.Highlightings;
using NUnit.Framework;

namespace JetBrains.ReSharper.Plugins.Tests.Unity.CSharp.Daemon.Stages.Analysis
{
    [TestUnity]
    public class RedundantAttributeOnTargetAnalyzerTests : CSharpHighlightingTestBase<IUnityAnalyzerHighlighting>
    {
        protected override string RelativeTestDataPath => @"CSharp\Daemon\Stages\Analysis\RedundantAttributeOnTarget";

        [Test] public void TestAddComponentMenu() { DoNamedTest2(); }
        [Test] public void TestExecuteInEditMode() { DoNamedTest2(); }
        [Test] public void TestHideInInspector() { DoNamedTest2(); }
        [Test] public void TestImageEffectAllowedInSceneView() { DoNamedTest2(); }
        [Test] public void TestImageEffectOpaque() { DoNamedTest2(); }
        [Test] public void TestImageEffectTransformsToLDR() { DoNamedTest2(); }
        [Test] public void TestSerializeField() { DoNamedTest2(); }
        [Test] public void TestCanEditMultipleObjects() { DoNamedTest2(); }
        [Test] public void TestCustomEditor() { DoNamedTest2(); }
        [Test] public void TestDrawGizmo() { DoNamedTest2(); }
        [Test] public void TestDidReloadScripts() { DoNamedTest2(); }
        [Test] public void TestOnOpenAssetAttribute() { DoNamedTest2(); }
        [Test] public void TestPostProcessBuildAttribute() { DoNamedTest2(); }
        [Test] public void TestPostProcessSceneAttribute() { DoNamedTest2(); }
    }
}


text:
package ch.ralscha.extdirectspring.bean;

import static org.assertj.core.api.Assertions.assertThat;

import org.junit.jupiter.api.Test;

public class DataTypeTest {

	@Test
	public void testFromString() {
		assertThat(DataType.BOOLEAN.getName()).isEqualTo("boolean");
		assertThat(DataType.DATE.getName()).isEqualTo("date");
		assertThat(DataType.FLOAT.getName()).isEqualTo("float");
		assertThat(DataType.INTEGER.getName()).isEqualTo("int");
		assertThat(DataType.STRING.getName()).isEqualTo("string");
	}
}