service.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: service.proto

/*
	Package gxregistry is a generated protocol buffer package.

	It is generated from these files:
		service.proto

	It has these top-level messages:
		ServiceAttr
		Node
		Service
		EventResult
*/
package gxregistry

import (
	"encoding/json"
	"fmt"
	"io"
	"math"
	"net/url"
	"reflect"
	"strconv"
	"strings"
)

import (
	_ "github.com/gogo/protobuf/gogoproto"
	"github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	jerrors "github.com/juju/errors"
)

import (
	"github.com/AlexStocks/goext/strings"
)

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ = proto.Marshal
	_ = fmt.Errorf
	_ = 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package

// ////////////////////////////////////////
// service role
// ////////////////////////////////////////
type ServiceRoleType int32

const (
	SRT_UNKOWN   ServiceRoleType = 0
	SRT_Provider ServiceRoleType = 1
	SRT_Consumer ServiceRoleType = 2
)

var ServiceRoleType_name = map[int32]string{
	0: "SRT_UNKOWN",
	1: "SRT_Provider",
	2: "SRT_Consumer",
}
var ServiceRoleType_value = map[string]int32{
	"SRT_UNKOWN":   0,
	"SRT_Provider": 1,
	"SRT_Consumer": 2,
}

func String2ServiceRoleType(role string) ServiceRoleType {
	r, ok := ServiceRoleType_value[role]
	if !ok {
		return SRT_UNKOWN
	}

	return ServiceRoleType(r)
}

func (ServiceRoleType) EnumDescriptor() ([]byte, []int) { return fileDescriptorService, []int{0} }

// ////////////////////////////////////////
// service url event type
// ////////////////////////////////////////
type ServiceEventType int32

const (
	SET_UNKNOWN   ServiceEventType = 0
	ServiceAdd    ServiceEventType = 1
	ServiceDel    ServiceEventType = 2
	ServiceUpdate ServiceEventType = 3
)

var ServiceEventType_name = map[int32]string{
	0: "SET_UNKNOWN",
	1: "ServiceAdd",
	2: "ServiceDel",
	3: "ServiceUpdate",
}
var ServiceEventType_value = map[string]int32{
	"SET_UNKNOWN":   0,
	"ServiceAdd":    1,
	"ServiceDel":    2,
	"ServiceUpdate": 3,
}

func (ServiceEventType) EnumDescriptor() ([]byte, []int) { return fileDescriptorService, []int{1} }

type ServiceAttr struct {
	Group    string          `protobuf:"bytes,1,opt,name=Group,proto3" json:"Group,omitempty"`
	Service  string          `protobuf:"bytes,2,opt,name=Service,proto3" json:"Service,omitempty"`
	Protocol string          `protobuf:"bytes,3,opt,name=Protocol,proto3" json:"Protocol,omitempty"`
	Version  string          `protobuf:"bytes,4,opt,name=Version,proto3" json:"Version,omitempty"`
	Role     ServiceRoleType `protobuf:"varint,5,opt,name=Role,proto3,enum=gxregistry.ServiceRoleType" json:"Role,omitempty"`
}

func (m *ServiceAttr) Reset()                    { *m = ServiceAttr{} }
func (*ServiceAttr) ProtoMessage()               {}
func (*ServiceAttr) Descriptor() ([]byte, []int) { return fileDescriptorService, []int{0} }

// fine filtering
func (m *ServiceAttr) Filter(service ServiceAttr) bool {
	switch {
	case "" != m.Protocol && service.Protocol != m.Protocol:
		return false

	case "" != m.Service && service.Service != m.Service:
		return false

	case "" != m.Group && service.Group != m.Group:
		return false

	case "" != m.Version && service.Version != m.Version:
		return false

	case SRT_UNKOWN != m.Role && service.Role != m.Role:
		return false

	default:
		return true
	}
}

func (m *ServiceAttr) MeshFilter(service ServiceAttr) bool {
	switch {
	case "" != m.Service && service.Service != m.Service:
		return false

	case SRT_UNKOWN != m.Role && service.Role != m.Role:
		return false

	default:
		return true
	}
}

func (m *ServiceAttr) Copy() *ServiceAttr {
	return &ServiceAttr{
		Group:    m.Group,
		Service:  m.Service,
		Protocol: m.Protocol,
		Version:  m.Version,
		Role:     m.Role,
	}
}

type Node struct {
	ID       string            `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
	Address  string            `protobuf:"bytes,2,opt,name=Address,proto3" json:"Address,omitempty"`
	Port     int32             `protobuf:"varint,3,opt,name=Port,proto3" json:"Port,omitempty"`
	Metadata map[string]string `protobuf:"bytes,4,rep,name=Metadata" json:"Metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *Node) Reset()                    { *m = Node{} }
func (*Node) ProtoMessage()               {}
func (*Node) Descriptor() ([]byte, []int) { return fileDescriptorService, []int{1} }

func (m *Node) Copy() *Node {
	n := Node{
		ID:      m.ID,
		Address: m.Address,
		Port:    m.Port,
	}

	if len(m.Metadata) != 0 {
		n.Metadata = make(map[string]string, len(m.Metadata))
		for k, v := range m.Metadata {
			n.Metadata[k] = v
		}
	}

	return &n
}

type NodeMeta func(*Node)

func WithNodeMeta(key, value string) NodeMeta {
	return func(n *Node) {
		if n.Metadata == nil {
			n.Metadata = make(map[string]string)
		}
		n.Metadata[key] = value
	}
}

type Service struct {
	Attr     *ServiceAttr      `protobuf:"bytes,1,opt,name=Attr" json:"Attr,omitempty"`
	Nodes    []*Node           `protobuf:"bytes,2,rep,name=Nodes" json:"Nodes,omitempty"`
	Metadata map[string]string `protobuf:"bytes,3,rep,name=Metadata" json:"Metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *Service) Reset()                    { *m = Service{} }
func (*Service) ProtoMessage()               {}
func (*Service) Descriptor() ([]byte, []int) { return fileDescriptorService, []int{2} }
func (s *Service) Copy() *Service {
	c := Service{
		Attr: s.Attr.Copy(),
	}

	if len(s.Nodes) != 0 {
		c.Nodes = make([]*Node, 0, len(s.Nodes))
		for i := range s.Nodes {
			c.Nodes = append(c.Nodes, s.Nodes[i].Copy())
		}
	}
	if len(s.Metadata) != 0 {
		c.Metadata = make(map[string]string, len(s.Metadata))
		for k, v := range s.Metadata {
			c.Metadata[k] = v
		}
	}

	return &c
}

type ServiceMeta func(*Service)

func WithServiceMeta(key, value string) ServiceMeta {
	return func(s *Service) {
		if s.Metadata == nil {
			s.Metadata = make(map[string]string)
		}
		s.Metadata[key] = value
	}
}

// Result is returned by a call to Next on
// the watcher. Actions can be create, update, delete
type EventResult struct {
	Action  ServiceEventType `protobuf:"varint,1,opt,name=Action,proto3,enum=gxregistry.ServiceEventType" json:"Action,omitempty"`
	Service *Service         `protobuf:"bytes,2,opt,name=Service" json:"Service,omitempty"`
}

func (m *EventResult) Reset()                    { *m = EventResult{} }
func (*EventResult) ProtoMessage()               {}
func (*EventResult) Descriptor() ([]byte, []int) { return fileDescriptorService, []int{3} }
func init() {
	proto.RegisterType((*ServiceAttr)(nil), "gxregistry.ServiceAttr")
	proto.RegisterType((*Node)(nil), "gxregistry.Node")
	proto.RegisterType((*Service)(nil), "gxregistry.Service")
	proto.RegisterType((*EventResult)(nil), "gxregistry.EventResult")
	proto.RegisterEnum("gxregistry.ServiceRoleType", ServiceRoleType_name, ServiceRoleType_value)
	proto.RegisterEnum("gxregistry.ServiceEventType", ServiceEventType_name, ServiceEventType_value)
}
func (x ServiceRoleType) String() string {
	s, ok := ServiceRoleType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x ServiceEventType) String() string {
	s, ok := ServiceEventType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *ServiceAttr) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*ServiceAttr)
	if !ok {
		that2, ok := that.(ServiceAttr)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *ServiceAttr")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *ServiceAttr but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *ServiceAttr but is not nil && this == nil")
	}
	if this.Group != that1.Group {
		return fmt.Errorf("Group this(%v) Not Equal that(%v)", this.Group, that1.Group)
	}
	if this.Service != that1.Service {
		return fmt.Errorf("Service this(%v) Not Equal that(%v)", this.Service, that1.Service)
	}
	if this.Protocol != that1.Protocol {
		return fmt.Errorf("Protocol this(%v) Not Equal that(%v)", this.Protocol, that1.Protocol)
	}
	if this.Version != that1.Version {
		return fmt.Errorf("Version this(%v) Not Equal that(%v)", this.Version, that1.Version)
	}
	if this.Role != that1.Role {
		return fmt.Errorf("Role this(%v) Not Equal that(%v)", this.Role, that1.Role)
	}
	return nil
}
func (this *ServiceAttr) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*ServiceAttr)
	if !ok {
		that2, ok := that.(ServiceAttr)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Group != that1.Group {
		return false
	}
	if this.Service != that1.Service {
		return false
	}
	if this.Protocol != that1.Protocol {
		return false
	}
	if this.Version != that1.Version {
		return false
	}
	if this.Role != that1.Role {
		return false
	}
	return true
}
func (this *Node) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Node)
	if !ok {
		that2, ok := that.(Node)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Node")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Node but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Node but is not nil && this == nil")
	}
	if this.ID != that1.ID {
		return fmt.Errorf("ID this(%v) Not Equal that(%v)", this.ID, that1.ID)
	}
	if this.Address != that1.Address {
		return fmt.Errorf("Address this(%v) Not Equal that(%v)", this.Address, that1.Address)
	}
	if this.Port != that1.Port {
		return fmt.Errorf("Port this(%v) Not Equal that(%v)", this.Port, that1.Port)
	}
	if len(this.Metadata) != len(that1.Metadata) {
		return fmt.Errorf("Metadata this(%v) Not Equal that(%v)", len(this.Metadata), len(that1.Metadata))
	}
	for i := range this.Metadata {
		if this.Metadata[i] != that1.Metadata[i] {
			return fmt.Errorf("Metadata this[%v](%v) Not Equal that[%v](%v)", i, this.Metadata[i], i, that1.Metadata[i])
		}
	}
	return nil
}
func (this *Node) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Node)
	if !ok {
		that2, ok := that.(Node)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if this.Address != that1.Address {
		return false
	}
	if this.Port != that1.Port {
		return false
	}
	if len(this.Metadata) != len(that1.Metadata) {
		return false
	}
	for i := range this.Metadata {
		if this.Metadata[i] != that1.Metadata[i] {
			return false
		}
	}
	return true
}
func (this *Service) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Service)
	if !ok {
		that2, ok := that.(Service)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Service")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Service but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Service but is not nil && this == nil")
	}
	if !this.Attr.Equal(that1.Attr) {
		return fmt.Errorf("Attr this(%v) Not Equal that(%v)", this.Attr, that1.Attr)
	}
	if len(this.Nodes) != len(that1.Nodes) {
		return fmt.Errorf("Nodes this(%v) Not Equal that(%v)", len(this.Nodes), len(that1.Nodes))
	}
	for i := range this.Nodes {
		if !this.Nodes[i].Equal(that1.Nodes[i]) {
			return fmt.Errorf("Nodes this[%v](%v) Not Equal that[%v](%v)", i, this.Nodes[i], i, that1.Nodes[i])
		}
	}
	if len(this.Metadata) != len(that1.Metadata) {
		return fmt.Errorf("Metadata this(%v) Not Equal that(%v)", len(this.Metadata), len(that1.Metadata))
	}
	for i := range this.Metadata {
		if this.Metadata[i] != that1.Metadata[i] {
			return fmt.Errorf("Metadata this[%v](%v) Not Equal that[%v](%v)", i, this.Metadata[i], i, that1.Metadata[i])
		}
	}
	return nil
}
func (this *Service) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Service)
	if !ok {
		that2, ok := that.(Service)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.Attr.Equal(that1.Attr) {
		return false
	}
	if len(this.Nodes) != len(that1.Nodes) {
		return false
	}
	for i := range this.Nodes {
		if !this.Nodes[i].Equal(that1.Nodes[i]) {
			return false
		}
	}
	if len(this.Metadata) != len(that1.Metadata) {
		return false
	}
	for i := range this.Metadata {
		if this.Metadata[i] != that1.Metadata[i] {
			return false
		}
	}
	return true
}
func (this *EventResult) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*EventResult)
	if !ok {
		that2, ok := that.(EventResult)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *EventResult")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *EventResult but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *EventResult but is not nil && this == nil")
	}
	if this.Action != that1.Action {
		return fmt.Errorf("Action this(%v) Not Equal that(%v)", this.Action, that1.Action)
	}
	if !this.Service.Equal(that1.Service) {
		return fmt.Errorf("Service this(%v) Not Equal that(%v)", this.Service, that1.Service)
	}
	return nil
}
func (this *EventResult) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*EventResult)
	if !ok {
		that2, ok := that.(EventResult)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Action != that1.Action {
		return false
	}
	if !this.Service.Equal(that1.Service) {
		return false
	}
	return true
}
func (this *ServiceAttr) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&gxregistry.ServiceAttr{")
	s = append(s, "Group: "+fmt.Sprintf("%#v", this.Group)+",\n")
	s = append(s, "Service: "+fmt.Sprintf("%#v", this.Service)+",\n")
	s = append(s, "Protocol: "+fmt.Sprintf("%#v", this.Protocol)+",\n")
	s = append(s, "Version: "+fmt.Sprintf("%#v", this.Version)+",\n")
	s = append(s, "Role: "+fmt.Sprintf("%#v", this.Role)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Node) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&gxregistry.Node{")
	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	s = append(s, "Address: "+fmt.Sprintf("%#v", this.Address)+",\n")
	s = append(s, "Port: "+fmt.Sprintf("%#v", this.Port)+",\n")
	keysForMetadata := make([]string, 0, len(this.Metadata))
	for k, _ := range this.Metadata {
		keysForMetadata = append(keysForMetadata, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMetadata)
	mapStringForMetadata := "map[string]string{"
	for _, k := range keysForMetadata {
		mapStringForMetadata += fmt.Sprintf("%#v: %#v,", k, this.Metadata[k])
	}
	mapStringForMetadata += "}"
	if this.Metadata != nil {
		s = append(s, "Metadata: "+mapStringForMetadata+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Service) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&gxregistry.Service{")
	if this.Attr != nil {
		s = append(s, "Attr: "+fmt.Sprintf("%#v", this.Attr)+",\n")
	}
	if this.Nodes != nil {
		s = append(s, "Nodes: "+fmt.Sprintf("%#v", this.Nodes)+",\n")
	}
	keysForMetadata := make([]string, 0, len(this.Metadata))
	for k, _ := range this.Metadata {
		keysForMetadata = append(keysForMetadata, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMetadata)
	mapStringForMetadata := "map[string]string{"
	for _, k := range keysForMetadata {
		mapStringForMetadata += fmt.Sprintf("%#v: %#v,", k, this.Metadata[k])
	}
	mapStringForMetadata += "}"
	if this.Metadata != nil {
		s = append(s, "Metadata: "+mapStringForMetadata+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EventResult) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&gxregistry.EventResult{")
	s = append(s, "Action: "+fmt.Sprintf("%#v", this.Action)+",\n")
	if this.Service != nil {
		s = append(s, "Service: "+fmt.Sprintf("%#v", this.Service)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringService(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *ServiceAttr) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ServiceAttr) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Group) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintService(dAtA, i, uint64(len(m.Group)))
		i += copy(dAtA[i:], m.Group)
	}
	if len(m.Service) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintService(dAtA, i, uint64(len(m.Service)))
		i += copy(dAtA[i:], m.Service)
	}
	if len(m.Protocol) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintService(dAtA, i, uint64(len(m.Protocol)))
		i += copy(dAtA[i:], m.Protocol)
	}
	if len(m.Version) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintService(dAtA, i, uint64(len(m.Version)))
		i += copy(dAtA[i:], m.Version)
	}
	if m.Role != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintService(dAtA, i, uint64(m.Role))
	}
	return i, nil
}

func (m *Node) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Node) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ID) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintService(dAtA, i, uint64(len(m.ID)))
		i += copy(dAtA[i:], m.ID)
	}
	if len(m.Address) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintService(dAtA, i, uint64(len(m.Address)))
		i += copy(dAtA[i:], m.Address)
	}
	if m.Port != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintService(dAtA, i, uint64(m.Port))
	}
	if len(m.Metadata) > 0 {
		for k, _ := range m.Metadata {
			dAtA[i] = 0x22
			i++
			v := m.Metadata[k]
			mapSize := 1 + len(k) + sovService(uint64(len(k))) + 1 + len(v) + sovService(uint64(len(v)))
			i = encodeVarintService(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintService(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintService(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	return i, nil
}

func (m *Service) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Service) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Attr != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintService(dAtA, i, uint64(m.Attr.Size()))
		n1, err := m.Attr.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if len(m.Nodes) > 0 {
		for _, msg := range m.Nodes {
			dAtA[i] = 0x12
			i++
			i = encodeVarintService(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Metadata) > 0 {
		for k, _ := range m.Metadata {
			dAtA[i] = 0x1a
			i++
			v := m.Metadata[k]
			mapSize := 1 + len(k) + sovService(uint64(len(k))) + 1 + len(v) + sovService(uint64(len(v)))
			i = encodeVarintService(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintService(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintService(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	return i, nil
}

func (m *EventResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EventResult) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Action != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintService(dAtA, i, uint64(m.Action))
	}
	if m.Service != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintService(dAtA, i, uint64(m.Service.Size()))
		n2, err := m.Service.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	return i, nil
}

func encodeFixed64Service(dAtA []byte, offset int, v uint64) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	dAtA[offset+4] = uint8(v >> 32)
	dAtA[offset+5] = uint8(v >> 40)
	dAtA[offset+6] = uint8(v >> 48)
	dAtA[offset+7] = uint8(v >> 56)
	return offset + 8
}
func encodeFixed32Service(dAtA []byte, offset int, v uint32) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	return offset + 4
}
func encodeVarintService(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *ServiceAttr) Size() (n int) {
	var l int
	_ = l
	l = len(m.Group)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.Service)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.Protocol)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if m.Role != 0 {
		n += 1 + sovService(uint64(m.Role))
	}
	return n
}

func (m *Node) Size() (n int) {
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if m.Port != 0 {
		n += 1 + sovService(uint64(m.Port))
	}
	if len(m.Metadata) > 0 {
		for k, v := range m.Metadata {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovService(uint64(len(k))) + 1 + len(v) + sovService(uint64(len(v)))
			n += mapEntrySize + 1 + sovService(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *Service) Size() (n int) {
	var l int
	_ = l
	if m.Attr != nil {
		l = m.Attr.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if len(m.Nodes) > 0 {
		for _, e := range m.Nodes {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	if len(m.Metadata) > 0 {
		for k, v := range m.Metadata {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovService(uint64(len(k))) + 1 + len(v) + sovService(uint64(len(v)))
			n += mapEntrySize + 1 + sovService(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *EventResult) Size() (n int) {
	var l int
	_ = l
	if m.Action != 0 {
		n += 1 + sovService(uint64(m.Action))
	}
	if m.Service != nil {
		l = m.Service.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func sovService(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozService(x uint64) (n int) {
	return sovService(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *ServiceAttr) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ServiceAttr{`,
		`Group:` + fmt.Sprintf("%v", this.Group) + `,`,
		`Service:` + fmt.Sprintf("%v", this.Service) + `,`,
		`Protocol:` + fmt.Sprintf("%v", this.Protocol) + `,`,
		`Version:` + fmt.Sprintf("%v", this.Version) + `,`,
		`Role:` + fmt.Sprintf("%v", this.Role) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Node) String() string {
	if this == nil {
		return "nil"
	}
	keysForMetadata := make([]string, 0, len(this.Metadata))
	for k, _ := range this.Metadata {
		keysForMetadata = append(keysForMetadata, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMetadata)
	mapStringForMetadata := "map[string]string{"
	for _, k := range keysForMetadata {
		mapStringForMetadata += fmt.Sprintf("%v: %v,", k, this.Metadata[k])
	}
	mapStringForMetadata += "}"
	s := strings.Join([]string{`&Node{`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`Address:` + fmt.Sprintf("%v", this.Address) + `,`,
		`Port:` + fmt.Sprintf("%v", this.Port) + `,`,
		`Metadata:` + mapStringForMetadata + `,`,
		`}`,
	}, "")
	return s
}
func (this *Service) String() string {
	if this == nil {
		return "nil"
	}
	keysForMetadata := make([]string, 0, len(this.Metadata))
	for k, _ := range this.Metadata {
		keysForMetadata = append(keysForMetadata, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMetadata)
	mapStringForMetadata := "map[string]string{"
	for _, k := range keysForMetadata {
		mapStringForMetadata += fmt.Sprintf("%v: %v,", k, this.Metadata[k])
	}
	mapStringForMetadata += "}"
	s := strings.Join([]string{`&Service{`,
		`Attr:` + strings.Replace(fmt.Sprintf("%v", this.Attr), "ServiceAttr", "ServiceAttr", 1) + `,`,
		`Nodes:` + strings.Replace(fmt.Sprintf("%v", this.Nodes), "Node", "Node", 1) + `,`,
		`Metadata:` + mapStringForMetadata + `,`,
		`}`,
	}, "")
	return s
}
func (this *EventResult) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EventResult{`,
		`Action:` + fmt.Sprintf("%v", this.Action) + `,`,
		`Service:` + strings.Replace(fmt.Sprintf("%v", this.Service), "Service", "Service", 1) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringService(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *ServiceAttr) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ServiceAttr: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceAttr: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Group = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Service = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Protocol = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
			}
			m.Role = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Role |= (ServiceRoleType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Node) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Node: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Node: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metadata == nil {
				m.Metadata = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowService
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowService
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthService
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowService
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthService
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipService(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthService
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Metadata[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Service) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Service: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Service: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attr", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Attr == nil {
				m.Attr = &ServiceAttr{}
			}
			if err := m.Attr.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Nodes = append(m.Nodes, &Node{})
			if err := m.Nodes[len(m.Nodes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metadata == nil {
				m.Metadata = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowService
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowService
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthService
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowService
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthService
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipService(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthService
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Metadata[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventResult) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
			}
			m.Action = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Action |= (ServiceEventType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Service == nil {
				m.Service = &Service{}
			}
			if err := m.Service.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipService(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowService
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowService
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowService
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthService
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowService
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipService(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthService = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowService   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("service.proto", fileDescriptorService) }

var fileDescriptorService = []byte{
	// 414 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x52, 0xcd, 0xce, 0xd2, 0x40,
	0x14, 0xed, 0xf4, 0xc7, 0xef, 0xf3, 0x12, 0x08, 0x99, 0x98, 0xd8, 0xd4, 0x64, 0x82, 0x2c, 0x0c,
	0x1b, 0x4b, 0x82, 0x2e, 0x14, 0xe3, 0x02, 0x83, 0x31, 0x2c, 0x24, 0xa4, 0x1a, 0xf7, 0x85, 0x8e,
	0xb5, 0xb1, 0x30, 0x64, 0x3a, 0x25, 0x76, 0xe7, 0x23, 0xf8, 0x04, 0xae, 0x7d, 0x09, 0xf7, 0x2c,
	0x59, 0xba, 0xa4, 0x75, 0xc3, 0x92, 0x47, 0x30, 0x33, 0x6d, 0x11, 0x0c, 0x5b, 0x77, 0xf7, 0xcc,
	0x39, 0xf7, 0xde, 0x73, 0x6e, 0x0b, 0xcd, 0x84, 0xf2, 0x4d, 0xb4, 0xa0, 0xee, 0x9a, 0x33, 0xc1,
	0x30, 0x84, 0x5f, 0x38, 0x0d, 0xa3, 0x44, 0xf0, 0xcc, 0x79, 0x1c, 0x46, 0xe2, 0x53, 0x3a, 0x77,
	0x17, 0x6c, 0xd9, 0x0f, 0x59, 0xc8, 0xfa, 0x4a, 0x32, 0x4f, 0x3f, 0x2a, 0xa4, 0x80, 0xaa, 0xca,
	0x56, 0x07, 0x38, 0x8b, 0xab, 0x31, 0xdd, 0xef, 0x08, 0x1a, 0xef, 0xca, 0xc1, 0x23, 0x21, 0x38,
	0xbe, 0x07, 0xd6, 0x1b, 0xce, 0xd2, 0xb5, 0x8d, 0x3a, 0xa8, 0x77, 0xd7, 0x2b, 0x01, 0xc6, 0x60,
	0x4e, 0xfd, 0x25, 0xb5, 0x75, 0xf5, 0xa8, 0x6a, 0xec, 0xc0, 0xed, 0x4c, 0x8e, 0x58, 0xb0, 0xd8,
	0x36, 0xd4, 0xfb, 0x09, 0x63, 0x1b, 0x6e, 0x3e, 0x50, 0x9e, 0x44, 0x6c, 0x65, 0x9b, 0x8a, 0xaa,
	0x21, 0xee, 0x83, 0xe9, 0xb1, 0x98, 0xda, 0x56, 0x07, 0xf5, 0x5a, 0x83, 0x07, 0xee, 0xdf, 0x14,
	0x6e, 0x65, 0x43, 0xd2, 0xef, 0xb3, 0x35, 0xf5, 0x94, 0xb0, 0xfb, 0x13, 0x81, 0x39, 0x65, 0x01,
	0xc5, 0x2d, 0xd0, 0x27, 0xe3, 0xca, 0x96, 0x3e, 0x19, 0xcb, 0x1d, 0xa3, 0x20, 0xe0, 0x34, 0x49,
	0x2a, 0x5b, 0x35, 0x94, 0x6e, 0x67, 0x8c, 0x0b, 0xe5, 0xca, 0xf2, 0x54, 0x8d, 0x87, 0x70, 0xfb,
	0x96, 0x0a, 0x3f, 0xf0, 0x85, 0x6f, 0x9b, 0x1d, 0xa3, 0xd7, 0x18, 0x90, 0xf3, 0xdd, 0x72, 0x83,
	0x5b, 0x0b, 0x5e, 0xaf, 0x04, 0xcf, 0xbc, 0x93, 0xde, 0x79, 0x01, 0xcd, 0x0b, 0x0a, 0xb7, 0xc1,
	0xf8, 0x4c, 0xb3, 0xca, 0x8b, 0x2c, 0xe5, 0xd9, 0x36, 0x7e, 0x9c, 0xd6, 0x17, 0x2a, 0xc1, 0x50,
	0x7f, 0x86, 0xba, 0x07, 0x04, 0x37, 0x55, 0x32, 0xfc, 0xfc, 0xe2, 0xd6, 0xaa, 0xbf, 0x31, 0xb8,
	0x7f, 0xe5, 0x06, 0x92, 0xf6, 0x2e, 0xbe, 0xcb, 0x23, 0xb0, 0xa4, 0x47, 0x99, 0x55, 0x9a, 0x6f,
	0xff, 0x6b, 0xde, 0x2b, 0x69, 0xfc, 0xf2, 0x2c, 0xa7, 0xa1, 0xa4, 0x0f, 0xaf, 0xcc, 0xff, 0x2f,
	0x51, 0x5f, 0x3d, 0xdd, 0xe6, 0x44, 0xdb, 0xe5, 0x44, 0xfb, 0x95, 0x13, 0x6d, 0x9f, 0x13, 0x74,
	0xcc, 0x09, 0xfa, 0x5a, 0x10, 0xf4, 0xa3, 0x20, 0x68, 0x5b, 0x10, 0xb4, 0x2b, 0x08, 0xda, 0x17,
	0x04, 0x1d, 0x0a, 0xa2, 0x1d, 0x0b, 0x82, 0xbe, 0xfd, 0x26, 0xda, 0xfc, 0x8e, 0xfa, 0x11, 0x9f,
	0xfc, 0x09, 0x00, 0x00, 0xff, 0xff, 0xb2, 0xfe, 0xcf, 0xd3, 0xe0, 0x02, 0x00, 0x00,
}

//////////////////////////////////////////

func (a *ServiceAttr) MarshalPath() ([]byte, error) {
	params := url.Values{}
	if len(a.Group) != 0 {
		params.Add("group", a.Group)
	}
	if len(a.Service) != 0 {
		params.Add("service", a.Service)
	}
	if len(a.Protocol) != 0 {
		params.Add("protocol", a.Protocol)
	}
	if len(a.Version) != 0 {
		params.Add("version", a.Version)
	}
	if a.Role != SRT_UNKOWN {
		params.Add("role", a.Role.String())
	}

	if len(params) == 0 {
		return gxstrings.Slice(""), nil
	}

	// encode result: group=bjtelecom&protocol=pb&service=shopping&type=add+service&version=1.0.1
	// query escape: group%3Dbjtelecom%26protocol%3Dpb%26service%3Dshopping%26type%3Dadd%2Bservice%26version%3D1.0.1
	return []byte(url.QueryEscape(params.Encode())), nil
}

func (a *ServiceAttr) UnmarshalPath(data []byte) error {
	rawString, err := url.QueryUnescape(gxstrings.String(data))
	if err != nil {
		return jerrors.Annotatef(err, "url.QueryUnescape(data:%s)", gxstrings.String(data))
	}

	query, err := url.ParseQuery(rawString)
	if err != nil {
		return jerrors.Annotatef(err, "url.ParseQuery(string:%s)", rawString)
	}

	a.Group = query.Get("group")
	a.Service = query.Get("service")
	a.Protocol = query.Get("protocol")
	a.Version = query.Get("version")
	a.Role = String2ServiceRoleType(query.Get("role"))

	return nil
}

func EncodeService(s *Service) (string, error) {
	b, err := json.Marshal(s)
	if err != nil {
		return "", jerrors.Annotatef(err, "json.Marshal(Service:%+v)", s)
	}

	return string(b), nil
}

func DecodeService(ds []byte) (*Service, error) {
	var s Service
	err := json.Unmarshal(ds, &s)
	if err != nil {
		return nil, jerrors.Annotatef(err, "json.Unmarshal(data:%s)", gxstrings.String(ds))
	}
	return &s, nil
}

func registryPath(paths ...string) string {
	var service strings.Builder
	for _, path := range paths {
		if path != "" {
			service.WriteString(path)
			if !strings.HasSuffix(path, "/") {
				service.WriteString("/")
			}
		}
	}

	return service.String()
}

// /dubbo/group%3Dbjtelecom%26protocol%3Dpb%26service%3Dshopping%26type%3Dadd%2Bservice%26version%3D1.0.1/node1
func (s *Service) Path(root string) string {
	saPath, _ := s.Attr.MarshalPath()
	return registryPath([]string{root, gxstrings.String(saPath)}...)
}

func (s *Service) NodePath(root string, node Node) string {
	return s.Path(root) + node.ID
}