github.com/onosproject/onos-api/go@v0.10.32/onos/fabricsim/links.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: onos/fabricsim/links.proto

package fabricsim

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

// 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// LinkStatus represents the operational status of the link, derived from the status of its adjacent ports
type LinkStatus int32

const (
	LinkStatus_LINK_DOWN LinkStatus = 0
	LinkStatus_LINK_UP   LinkStatus = 1
)

var LinkStatus_name = map[int32]string{
	0: "LINK_DOWN",
	1: "LINK_UP",
}

var LinkStatus_value = map[string]int32{
	"LINK_DOWN": 0,
	"LINK_UP":   1,
}

func (x LinkStatus) String() string {
	return proto.EnumName(LinkStatus_name, int32(x))
}

func (LinkStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_fc16fca2ba28ce9e, []int{0}
}

// Link describes a simulated link, i.e a link between two device or host ports
type Link struct {
	// unique port id and port type
	ID LinkID `protobuf:"bytes,1,opt,name=id,proto3,casttype=LinkID" json:"id,omitempty"`
	// unique port ids of source and target ports
	SrcID PortID `protobuf:"bytes,2,opt,name=src_id,json=srcId,proto3,casttype=PortID" json:"src_id,omitempty"`
	TgtID PortID `protobuf:"bytes,3,opt,name=tgt_id,json=tgtId,proto3,casttype=PortID" json:"tgt_id,omitempty"`
	// status (operational state derived from the status of its adjacent ports)
	Status LinkStatus `protobuf:"varint,4,opt,name=status,proto3,enum=onos.fabricsim.LinkStatus" json:"status,omitempty"`
}

func (m *Link) Reset()         { *m = Link{} }
func (m *Link) String() string { return proto.CompactTextString(m) }
func (*Link) ProtoMessage()    {}
func (*Link) Descriptor() ([]byte, []int) {
	return fileDescriptor_fc16fca2ba28ce9e, []int{0}
}
func (m *Link) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Link) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Link.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Link) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Link.Merge(m, src)
}
func (m *Link) XXX_Size() int {
	return m.Size()
}
func (m *Link) XXX_DiscardUnknown() {
	xxx_messageInfo_Link.DiscardUnknown(m)
}

var xxx_messageInfo_Link proto.InternalMessageInfo

func (m *Link) GetID() LinkID {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *Link) GetSrcID() PortID {
	if m != nil {
		return m.SrcID
	}
	return ""
}

func (m *Link) GetTgtID() PortID {
	if m != nil {
		return m.TgtID
	}
	return ""
}

func (m *Link) GetStatus() LinkStatus {
	if m != nil {
		return m.Status
	}
	return LinkStatus_LINK_DOWN
}

type GetLinksRequest struct {
}

func (m *GetLinksRequest) Reset()         { *m = GetLinksRequest{} }
func (m *GetLinksRequest) String() string { return proto.CompactTextString(m) }
func (*GetLinksRequest) ProtoMessage()    {}
func (*GetLinksRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_fc16fca2ba28ce9e, []int{1}
}
func (m *GetLinksRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetLinksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetLinksRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetLinksRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetLinksRequest.Merge(m, src)
}
func (m *GetLinksRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetLinksRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetLinksRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetLinksRequest proto.InternalMessageInfo

type GetLinksResponse struct {
	Links []*Link `protobuf:"bytes,1,rep,name=links,proto3" json:"links,omitempty"`
}

func (m *GetLinksResponse) Reset()         { *m = GetLinksResponse{} }
func (m *GetLinksResponse) String() string { return proto.CompactTextString(m) }
func (*GetLinksResponse) ProtoMessage()    {}
func (*GetLinksResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_fc16fca2ba28ce9e, []int{2}
}
func (m *GetLinksResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetLinksResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetLinksResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetLinksResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetLinksResponse.Merge(m, src)
}
func (m *GetLinksResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetLinksResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetLinksResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetLinksResponse proto.InternalMessageInfo

func (m *GetLinksResponse) GetLinks() []*Link {
	if m != nil {
		return m.Links
	}
	return nil
}

type GetLinkRequest struct {
	ID LinkID `protobuf:"bytes,1,opt,name=id,proto3,casttype=LinkID" json:"id,omitempty"`
}

func (m *GetLinkRequest) Reset()         { *m = GetLinkRequest{} }
func (m *GetLinkRequest) String() string { return proto.CompactTextString(m) }
func (*GetLinkRequest) ProtoMessage()    {}
func (*GetLinkRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_fc16fca2ba28ce9e, []int{3}
}
func (m *GetLinkRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetLinkRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetLinkRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetLinkRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetLinkRequest.Merge(m, src)
}
func (m *GetLinkRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetLinkRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetLinkRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetLinkRequest proto.InternalMessageInfo

func (m *GetLinkRequest) GetID() LinkID {
	if m != nil {
		return m.ID
	}
	return ""
}

type GetLinkResponse struct {
	Link *Link `protobuf:"bytes,1,opt,name=link,proto3" json:"link,omitempty"`
}

func (m *GetLinkResponse) Reset()         { *m = GetLinkResponse{} }
func (m *GetLinkResponse) String() string { return proto.CompactTextString(m) }
func (*GetLinkResponse) ProtoMessage()    {}
func (*GetLinkResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_fc16fca2ba28ce9e, []int{4}
}
func (m *GetLinkResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetLinkResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetLinkResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetLinkResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetLinkResponse.Merge(m, src)
}
func (m *GetLinkResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetLinkResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetLinkResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetLinkResponse proto.InternalMessageInfo

func (m *GetLinkResponse) GetLink() *Link {
	if m != nil {
		return m.Link
	}
	return nil
}

type AddLinkRequest struct {
	Link *Link `protobuf:"bytes,1,opt,name=link,proto3" json:"link,omitempty"`
}

func (m *AddLinkRequest) Reset()         { *m = AddLinkRequest{} }
func (m *AddLinkRequest) String() string { return proto.CompactTextString(m) }
func (*AddLinkRequest) ProtoMessage()    {}
func (*AddLinkRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_fc16fca2ba28ce9e, []int{5}
}
func (m *AddLinkRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddLinkRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddLinkRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AddLinkRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddLinkRequest.Merge(m, src)
}
func (m *AddLinkRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddLinkRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddLinkRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddLinkRequest proto.InternalMessageInfo

func (m *AddLinkRequest) GetLink() *Link {
	if m != nil {
		return m.Link
	}
	return nil
}

type AddLinkResponse struct {
}

func (m *AddLinkResponse) Reset()         { *m = AddLinkResponse{} }
func (m *AddLinkResponse) String() string { return proto.CompactTextString(m) }
func (*AddLinkResponse) ProtoMessage()    {}
func (*AddLinkResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_fc16fca2ba28ce9e, []int{6}
}
func (m *AddLinkResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddLinkResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddLinkResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AddLinkResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddLinkResponse.Merge(m, src)
}
func (m *AddLinkResponse) XXX_Size() int {
	return m.Size()
}
func (m *AddLinkResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AddLinkResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AddLinkResponse proto.InternalMessageInfo

type RemoveLinkRequest struct {
	ID LinkID `protobuf:"bytes,1,opt,name=id,proto3,casttype=LinkID" json:"id,omitempty"`
}

func (m *RemoveLinkRequest) Reset()         { *m = RemoveLinkRequest{} }
func (m *RemoveLinkRequest) String() string { return proto.CompactTextString(m) }
func (*RemoveLinkRequest) ProtoMessage()    {}
func (*RemoveLinkRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_fc16fca2ba28ce9e, []int{7}
}
func (m *RemoveLinkRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveLinkRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveLinkRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RemoveLinkRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveLinkRequest.Merge(m, src)
}
func (m *RemoveLinkRequest) XXX_Size() int {
	return m.Size()
}
func (m *RemoveLinkRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveLinkRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveLinkRequest proto.InternalMessageInfo

func (m *RemoveLinkRequest) GetID() LinkID {
	if m != nil {
		return m.ID
	}
	return ""
}

type RemoveLinkResponse struct {
}

func (m *RemoveLinkResponse) Reset()         { *m = RemoveLinkResponse{} }
func (m *RemoveLinkResponse) String() string { return proto.CompactTextString(m) }
func (*RemoveLinkResponse) ProtoMessage()    {}
func (*RemoveLinkResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_fc16fca2ba28ce9e, []int{8}
}
func (m *RemoveLinkResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveLinkResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveLinkResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RemoveLinkResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveLinkResponse.Merge(m, src)
}
func (m *RemoveLinkResponse) XXX_Size() int {
	return m.Size()
}
func (m *RemoveLinkResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveLinkResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveLinkResponse proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("onos.fabricsim.LinkStatus", LinkStatus_name, LinkStatus_value)
	proto.RegisterType((*Link)(nil), "onos.fabricsim.Link")
	proto.RegisterType((*GetLinksRequest)(nil), "onos.fabricsim.GetLinksRequest")
	proto.RegisterType((*GetLinksResponse)(nil), "onos.fabricsim.GetLinksResponse")
	proto.RegisterType((*GetLinkRequest)(nil), "onos.fabricsim.GetLinkRequest")
	proto.RegisterType((*GetLinkResponse)(nil), "onos.fabricsim.GetLinkResponse")
	proto.RegisterType((*AddLinkRequest)(nil), "onos.fabricsim.AddLinkRequest")
	proto.RegisterType((*AddLinkResponse)(nil), "onos.fabricsim.AddLinkResponse")
	proto.RegisterType((*RemoveLinkRequest)(nil), "onos.fabricsim.RemoveLinkRequest")
	proto.RegisterType((*RemoveLinkResponse)(nil), "onos.fabricsim.RemoveLinkResponse")
}

func init() { proto.RegisterFile("onos/fabricsim/links.proto", fileDescriptor_fc16fca2ba28ce9e) }

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// LinkServiceClient is the client API for LinkService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type LinkServiceClient interface {
	// GetLinks gets a list of all simulated links
	GetLinks(ctx context.Context, in *GetLinksRequest, opts ...grpc.CallOption) (*GetLinksResponse, error)
	// GetLink gets a specific link entry
	GetLink(ctx context.Context, in *GetLinkRequest, opts ...grpc.CallOption) (*GetLinkResponse, error)
	// AddLink adds a new simulated link
	AddLink(ctx context.Context, in *AddLinkRequest, opts ...grpc.CallOption) (*AddLinkResponse, error)
	// RemoveLink removes a simulated link
	RemoveLink(ctx context.Context, in *RemoveLinkRequest, opts ...grpc.CallOption) (*RemoveLinkResponse, error)
}

type linkServiceClient struct {
	cc *grpc.ClientConn
}

func NewLinkServiceClient(cc *grpc.ClientConn) LinkServiceClient {
	return &linkServiceClient{cc}
}

func (c *linkServiceClient) GetLinks(ctx context.Context, in *GetLinksRequest, opts ...grpc.CallOption) (*GetLinksResponse, error) {
	out := new(GetLinksResponse)
	err := c.cc.Invoke(ctx, "/onos.fabricsim.LinkService/GetLinks", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *linkServiceClient) GetLink(ctx context.Context, in *GetLinkRequest, opts ...grpc.CallOption) (*GetLinkResponse, error) {
	out := new(GetLinkResponse)
	err := c.cc.Invoke(ctx, "/onos.fabricsim.LinkService/GetLink", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *linkServiceClient) AddLink(ctx context.Context, in *AddLinkRequest, opts ...grpc.CallOption) (*AddLinkResponse, error) {
	out := new(AddLinkResponse)
	err := c.cc.Invoke(ctx, "/onos.fabricsim.LinkService/AddLink", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *linkServiceClient) RemoveLink(ctx context.Context, in *RemoveLinkRequest, opts ...grpc.CallOption) (*RemoveLinkResponse, error) {
	out := new(RemoveLinkResponse)
	err := c.cc.Invoke(ctx, "/onos.fabricsim.LinkService/RemoveLink", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// LinkServiceServer is the server API for LinkService service.
type LinkServiceServer interface {
	// GetLinks gets a list of all simulated links
	GetLinks(context.Context, *GetLinksRequest) (*GetLinksResponse, error)
	// GetLink gets a specific link entry
	GetLink(context.Context, *GetLinkRequest) (*GetLinkResponse, error)
	// AddLink adds a new simulated link
	AddLink(context.Context, *AddLinkRequest) (*AddLinkResponse, error)
	// RemoveLink removes a simulated link
	RemoveLink(context.Context, *RemoveLinkRequest) (*RemoveLinkResponse, error)
}

// UnimplementedLinkServiceServer can be embedded to have forward compatible implementations.
type UnimplementedLinkServiceServer struct {
}

func (*UnimplementedLinkServiceServer) GetLinks(ctx context.Context, req *GetLinksRequest) (*GetLinksResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetLinks not implemented")
}
func (*UnimplementedLinkServiceServer) GetLink(ctx context.Context, req *GetLinkRequest) (*GetLinkResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetLink not implemented")
}
func (*UnimplementedLinkServiceServer) AddLink(ctx context.Context, req *AddLinkRequest) (*AddLinkResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddLink not implemented")
}
func (*UnimplementedLinkServiceServer) RemoveLink(ctx context.Context, req *RemoveLinkRequest) (*RemoveLinkResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveLink not implemented")
}

func RegisterLinkServiceServer(s *grpc.Server, srv LinkServiceServer) {
	s.RegisterService(&_LinkService_serviceDesc, srv)
}

func _LinkService_GetLinks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLinksRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LinkServiceServer).GetLinks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.fabricsim.LinkService/GetLinks",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LinkServiceServer).GetLinks(ctx, req.(*GetLinksRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LinkService_GetLink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLinkRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LinkServiceServer).GetLink(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.fabricsim.LinkService/GetLink",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LinkServiceServer).GetLink(ctx, req.(*GetLinkRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LinkService_AddLink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddLinkRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LinkServiceServer).AddLink(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.fabricsim.LinkService/AddLink",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LinkServiceServer).AddLink(ctx, req.(*AddLinkRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LinkService_RemoveLink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveLinkRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LinkServiceServer).RemoveLink(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.fabricsim.LinkService/RemoveLink",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LinkServiceServer).RemoveLink(ctx, req.(*RemoveLinkRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _LinkService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "onos.fabricsim.LinkService",
	HandlerType: (*LinkServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetLinks",
			Handler:    _LinkService_GetLinks_Handler,
		},
		{
			MethodName: "GetLink",
			Handler:    _LinkService_GetLink_Handler,
		},
		{
			MethodName: "AddLink",
			Handler:    _LinkService_AddLink_Handler,
		},
		{
			MethodName: "RemoveLink",
			Handler:    _LinkService_RemoveLink_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "onos/fabricsim/links.proto",
}

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

func (m *Link) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Link) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != 0 {
		i = encodeVarintLinks(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x20
	}
	if len(m.TgtID) > 0 {
		i -= len(m.TgtID)
		copy(dAtA[i:], m.TgtID)
		i = encodeVarintLinks(dAtA, i, uint64(len(m.TgtID)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.SrcID) > 0 {
		i -= len(m.SrcID)
		copy(dAtA[i:], m.SrcID)
		i = encodeVarintLinks(dAtA, i, uint64(len(m.SrcID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintLinks(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *GetLinksRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetLinksRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

func (m *GetLinksResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetLinksResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Links) > 0 {
		for iNdEx := len(m.Links) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Links[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLinks(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *GetLinkRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetLinkRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintLinks(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *GetLinkResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetLinkResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Link != nil {
		{
			size, err := m.Link.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLinks(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *AddLinkRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddLinkRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Link != nil {
		{
			size, err := m.Link.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLinks(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *AddLinkResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddLinkResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

func (m *RemoveLinkRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveLinkRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintLinks(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *RemoveLinkResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveLinkResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func encodeVarintLinks(dAtA []byte, offset int, v uint64) int {
	offset -= sovLinks(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Link) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovLinks(uint64(l))
	}
	l = len(m.SrcID)
	if l > 0 {
		n += 1 + l + sovLinks(uint64(l))
	}
	l = len(m.TgtID)
	if l > 0 {
		n += 1 + l + sovLinks(uint64(l))
	}
	if m.Status != 0 {
		n += 1 + sovLinks(uint64(m.Status))
	}
	return n
}

func (m *GetLinksRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *GetLinksResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Links) > 0 {
		for _, e := range m.Links {
			l = e.Size()
			n += 1 + l + sovLinks(uint64(l))
		}
	}
	return n
}

func (m *GetLinkRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovLinks(uint64(l))
	}
	return n
}

func (m *GetLinkResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Link != nil {
		l = m.Link.Size()
		n += 1 + l + sovLinks(uint64(l))
	}
	return n
}

func (m *AddLinkRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Link != nil {
		l = m.Link.Size()
		n += 1 + l + sovLinks(uint64(l))
	}
	return n
}

func (m *AddLinkResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RemoveLinkRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovLinks(uint64(l))
	}
	return n
}

func (m *RemoveLinkResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func sovLinks(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozLinks(x uint64) (n int) {
	return sovLinks(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Link) 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 ErrIntOverflowLinks
			}
			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: Link: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Link: 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 ErrIntOverflowLinks
				}
				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 ErrInvalidLengthLinks
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLinks
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = LinkID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SrcID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLinks
				}
				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 ErrInvalidLengthLinks
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLinks
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SrcID = PortID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TgtID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLinks
				}
				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 ErrInvalidLengthLinks
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLinks
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TgtID = PortID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLinks
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= LinkStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipLinks(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLinks
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetLinksRequest) 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 ErrIntOverflowLinks
			}
			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: GetLinksRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetLinksRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipLinks(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLinks
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetLinksResponse) 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 ErrIntOverflowLinks
			}
			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: GetLinksResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetLinksResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Links", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLinks
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLinks
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLinks
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Links = append(m.Links, &Link{})
			if err := m.Links[len(m.Links)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLinks(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLinks
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetLinkRequest) 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 ErrIntOverflowLinks
			}
			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: GetLinkRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetLinkRequest: 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 ErrIntOverflowLinks
				}
				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 ErrInvalidLengthLinks
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLinks
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = LinkID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLinks(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLinks
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetLinkResponse) 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 ErrIntOverflowLinks
			}
			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: GetLinkResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetLinkResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Link", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLinks
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLinks
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLinks
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Link == nil {
				m.Link = &Link{}
			}
			if err := m.Link.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLinks(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLinks
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddLinkRequest) 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 ErrIntOverflowLinks
			}
			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: AddLinkRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddLinkRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Link", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLinks
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLinks
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLinks
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Link == nil {
				m.Link = &Link{}
			}
			if err := m.Link.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLinks(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLinks
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddLinkResponse) 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 ErrIntOverflowLinks
			}
			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: AddLinkResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddLinkResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipLinks(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLinks
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveLinkRequest) 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 ErrIntOverflowLinks
			}
			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: RemoveLinkRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveLinkRequest: 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 ErrIntOverflowLinks
				}
				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 ErrInvalidLengthLinks
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLinks
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = LinkID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLinks(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLinks
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveLinkResponse) 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 ErrIntOverflowLinks
			}
			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: RemoveLinkResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveLinkResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipLinks(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLinks
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipLinks(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowLinks
			}
			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, ErrIntOverflowLinks
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowLinks
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthLinks
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupLinks
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthLinks
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthLinks        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowLinks          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupLinks = fmt.Errorf("proto: unexpected end of group")
)