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

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

package fabricsim

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	misc "github.com/onosproject/onos-api/go/onos/misc"
	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

// HostType represents type of a host, i.e. bare metal, virtual, etc.
type HostType int32

const (
	HostType_BARE_METAL HostType = 0
	HostType_VIRTUAL    HostType = 1
)

var HostType_name = map[int32]string{
	0: "BARE_METAL",
	1: "VIRTUAL",
}

var HostType_value = map[string]int32{
	"BARE_METAL": 0,
	"VIRTUAL":    1,
}

func (x HostType) String() string {
	return proto.EnumName(HostType_name, int32(x))
}

func (HostType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_032be33f3739b3f8, []int{0}
}

// Host describes a simulated host (bare metal, VM or container)
type Host struct {
	// unique host id and host type
	ID   HostID   `protobuf:"bytes,1,opt,name=id,proto3,casttype=HostID" json:"id,omitempty"`
	Type HostType `protobuf:"varint,4,opt,name=type,proto3,enum=onos.fabricsim.HostType" json:"type,omitempty"`
	// network interfaces
	Interfaces []*NetworkInterface `protobuf:"bytes,2,rep,name=interfaces,proto3" json:"interfaces,omitempty"`
	Pos        *misc.GridPosition  `protobuf:"bytes,3,opt,name=pos,proto3" json:"pos,omitempty"`
	// virtual hosts being hosted by this (bare metal) host
	Hosts []*Host `protobuf:"bytes,5,rep,name=hosts,proto3" json:"hosts,omitempty"`
}

func (m *Host) Reset()         { *m = Host{} }
func (m *Host) String() string { return proto.CompactTextString(m) }
func (*Host) ProtoMessage()    {}
func (*Host) Descriptor() ([]byte, []int) {
	return fileDescriptor_032be33f3739b3f8, []int{0}
}
func (m *Host) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Host) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Host.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 *Host) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Host.Merge(m, src)
}
func (m *Host) XXX_Size() int {
	return m.Size()
}
func (m *Host) XXX_DiscardUnknown() {
	xxx_messageInfo_Host.DiscardUnknown(m)
}

var xxx_messageInfo_Host proto.InternalMessageInfo

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

func (m *Host) GetType() HostType {
	if m != nil {
		return m.Type
	}
	return HostType_BARE_METAL
}

func (m *Host) GetInterfaces() []*NetworkInterface {
	if m != nil {
		return m.Interfaces
	}
	return nil
}

func (m *Host) GetPos() *misc.GridPosition {
	if m != nil {
		return m.Pos
	}
	return nil
}

func (m *Host) GetHosts() []*Host {
	if m != nil {
		return m.Hosts
	}
	return nil
}

// NetworkInterface describes simulated host's attachment to the network
type NetworkInterface struct {
	// unique port id
	ID PortID `protobuf:"bytes,1,opt,name=id,proto3,casttype=PortID" json:"id,omitempty"`
	// mac address and VLAN
	MacAddress string `protobuf:"bytes,2,opt,name=mac_address,json=macAddress,proto3" json:"mac_address,omitempty"`
	VLAN       uint32 `protobuf:"varint,6,opt,name=vlan,proto3" json:"vlan,omitempty"`
	// ipv4 address
	IpAddress string `protobuf:"bytes,3,opt,name=ip_address,json=ipAddress,proto3" json:"ip_address,omitempty"`
	// ipv6 address
	Ipv6Address string `protobuf:"bytes,4,opt,name=ipv6_address,json=ipv6Address,proto3" json:"ipv6_address,omitempty"`
	// behavior
	Behavior *NetworkInterfaceBehavior `protobuf:"bytes,5,opt,name=behavior,proto3" json:"behavior,omitempty"`
}

func (m *NetworkInterface) Reset()         { *m = NetworkInterface{} }
func (m *NetworkInterface) String() string { return proto.CompactTextString(m) }
func (*NetworkInterface) ProtoMessage()    {}
func (*NetworkInterface) Descriptor() ([]byte, []int) {
	return fileDescriptor_032be33f3739b3f8, []int{1}
}
func (m *NetworkInterface) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NetworkInterface) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NetworkInterface.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 *NetworkInterface) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetworkInterface.Merge(m, src)
}
func (m *NetworkInterface) XXX_Size() int {
	return m.Size()
}
func (m *NetworkInterface) XXX_DiscardUnknown() {
	xxx_messageInfo_NetworkInterface.DiscardUnknown(m)
}

var xxx_messageInfo_NetworkInterface proto.InternalMessageInfo

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

func (m *NetworkInterface) GetMacAddress() string {
	if m != nil {
		return m.MacAddress
	}
	return ""
}

func (m *NetworkInterface) GetVLAN() uint32 {
	if m != nil {
		return m.VLAN
	}
	return 0
}

func (m *NetworkInterface) GetIpAddress() string {
	if m != nil {
		return m.IpAddress
	}
	return ""
}

func (m *NetworkInterface) GetIpv6Address() string {
	if m != nil {
		return m.Ipv6Address
	}
	return ""
}

func (m *NetworkInterface) GetBehavior() *NetworkInterfaceBehavior {
	if m != nil {
		return m.Behavior
	}
	return nil
}

// NetworkInterfaceBehavior describes dynamic aspects of a simulated host interface
// and how it manifests its presence on the network.
type NetworkInterfaceBehavior struct {
}

func (m *NetworkInterfaceBehavior) Reset()         { *m = NetworkInterfaceBehavior{} }
func (m *NetworkInterfaceBehavior) String() string { return proto.CompactTextString(m) }
func (*NetworkInterfaceBehavior) ProtoMessage()    {}
func (*NetworkInterfaceBehavior) Descriptor() ([]byte, []int) {
	return fileDescriptor_032be33f3739b3f8, []int{2}
}
func (m *NetworkInterfaceBehavior) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NetworkInterfaceBehavior) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NetworkInterfaceBehavior.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 *NetworkInterfaceBehavior) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetworkInterfaceBehavior.Merge(m, src)
}
func (m *NetworkInterfaceBehavior) XXX_Size() int {
	return m.Size()
}
func (m *NetworkInterfaceBehavior) XXX_DiscardUnknown() {
	xxx_messageInfo_NetworkInterfaceBehavior.DiscardUnknown(m)
}

var xxx_messageInfo_NetworkInterfaceBehavior proto.InternalMessageInfo

type GetHostsRequest struct {
}

func (m *GetHostsRequest) Reset()         { *m = GetHostsRequest{} }
func (m *GetHostsRequest) String() string { return proto.CompactTextString(m) }
func (*GetHostsRequest) ProtoMessage()    {}
func (*GetHostsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_032be33f3739b3f8, []int{3}
}
func (m *GetHostsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetHostsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetHostsRequest.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 *GetHostsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetHostsRequest.Merge(m, src)
}
func (m *GetHostsRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetHostsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetHostsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetHostsRequest proto.InternalMessageInfo

type GetHostsResponse struct {
	Hosts []*Host `protobuf:"bytes,1,rep,name=hosts,proto3" json:"hosts,omitempty"`
}

func (m *GetHostsResponse) Reset()         { *m = GetHostsResponse{} }
func (m *GetHostsResponse) String() string { return proto.CompactTextString(m) }
func (*GetHostsResponse) ProtoMessage()    {}
func (*GetHostsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_032be33f3739b3f8, []int{4}
}
func (m *GetHostsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetHostsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetHostsResponse.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 *GetHostsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetHostsResponse.Merge(m, src)
}
func (m *GetHostsResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetHostsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetHostsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetHostsResponse proto.InternalMessageInfo

func (m *GetHostsResponse) GetHosts() []*Host {
	if m != nil {
		return m.Hosts
	}
	return nil
}

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

func (m *GetHostRequest) Reset()         { *m = GetHostRequest{} }
func (m *GetHostRequest) String() string { return proto.CompactTextString(m) }
func (*GetHostRequest) ProtoMessage()    {}
func (*GetHostRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_032be33f3739b3f8, []int{5}
}
func (m *GetHostRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetHostRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetHostRequest.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 *GetHostRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetHostRequest.Merge(m, src)
}
func (m *GetHostRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetHostRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetHostRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetHostRequest proto.InternalMessageInfo

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

type GetHostResponse struct {
	Host *Host `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"`
}

func (m *GetHostResponse) Reset()         { *m = GetHostResponse{} }
func (m *GetHostResponse) String() string { return proto.CompactTextString(m) }
func (*GetHostResponse) ProtoMessage()    {}
func (*GetHostResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_032be33f3739b3f8, []int{6}
}
func (m *GetHostResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetHostResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetHostResponse.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 *GetHostResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetHostResponse.Merge(m, src)
}
func (m *GetHostResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetHostResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetHostResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetHostResponse proto.InternalMessageInfo

func (m *GetHostResponse) GetHost() *Host {
	if m != nil {
		return m.Host
	}
	return nil
}

type AddHostRequest struct {
	Host     *Host  `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"`
	HostedBy HostID `protobuf:"bytes,2,opt,name=hosted_by,json=hostedBy,proto3,casttype=HostID" json:"hosted_by,omitempty"`
}

func (m *AddHostRequest) Reset()         { *m = AddHostRequest{} }
func (m *AddHostRequest) String() string { return proto.CompactTextString(m) }
func (*AddHostRequest) ProtoMessage()    {}
func (*AddHostRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_032be33f3739b3f8, []int{7}
}
func (m *AddHostRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddHostRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddHostRequest.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 *AddHostRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddHostRequest.Merge(m, src)
}
func (m *AddHostRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddHostRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddHostRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddHostRequest proto.InternalMessageInfo

func (m *AddHostRequest) GetHost() *Host {
	if m != nil {
		return m.Host
	}
	return nil
}

func (m *AddHostRequest) GetHostedBy() HostID {
	if m != nil {
		return m.HostedBy
	}
	return ""
}

type AddHostResponse struct {
}

func (m *AddHostResponse) Reset()         { *m = AddHostResponse{} }
func (m *AddHostResponse) String() string { return proto.CompactTextString(m) }
func (*AddHostResponse) ProtoMessage()    {}
func (*AddHostResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_032be33f3739b3f8, []int{8}
}
func (m *AddHostResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddHostResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddHostResponse.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 *AddHostResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddHostResponse.Merge(m, src)
}
func (m *AddHostResponse) XXX_Size() int {
	return m.Size()
}
func (m *AddHostResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AddHostResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AddHostResponse proto.InternalMessageInfo

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

func (m *RemoveHostRequest) Reset()         { *m = RemoveHostRequest{} }
func (m *RemoveHostRequest) String() string { return proto.CompactTextString(m) }
func (*RemoveHostRequest) ProtoMessage()    {}
func (*RemoveHostRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_032be33f3739b3f8, []int{9}
}
func (m *RemoveHostRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveHostRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveHostRequest.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 *RemoveHostRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveHostRequest.Merge(m, src)
}
func (m *RemoveHostRequest) XXX_Size() int {
	return m.Size()
}
func (m *RemoveHostRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveHostRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveHostRequest proto.InternalMessageInfo

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

type RemoveHostResponse struct {
}

func (m *RemoveHostResponse) Reset()         { *m = RemoveHostResponse{} }
func (m *RemoveHostResponse) String() string { return proto.CompactTextString(m) }
func (*RemoveHostResponse) ProtoMessage()    {}
func (*RemoveHostResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_032be33f3739b3f8, []int{10}
}
func (m *RemoveHostResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveHostResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveHostResponse.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 *RemoveHostResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveHostResponse.Merge(m, src)
}
func (m *RemoveHostResponse) XXX_Size() int {
	return m.Size()
}
func (m *RemoveHostResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveHostResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveHostResponse proto.InternalMessageInfo

type EmitARPsRequest struct {
	ID          HostID   `protobuf:"bytes,1,opt,name=id,proto3,casttype=HostID" json:"id,omitempty"`
	MacAddress  string   `protobuf:"bytes,2,opt,name=mac_address,json=macAddress,proto3" json:"mac_address,omitempty"`
	IpAddresses []string `protobuf:"bytes,3,rep,name=ip_addresses,json=ipAddresses,proto3" json:"ip_addresses,omitempty"`
}

func (m *EmitARPsRequest) Reset()         { *m = EmitARPsRequest{} }
func (m *EmitARPsRequest) String() string { return proto.CompactTextString(m) }
func (*EmitARPsRequest) ProtoMessage()    {}
func (*EmitARPsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_032be33f3739b3f8, []int{11}
}
func (m *EmitARPsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EmitARPsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EmitARPsRequest.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 *EmitARPsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EmitARPsRequest.Merge(m, src)
}
func (m *EmitARPsRequest) XXX_Size() int {
	return m.Size()
}
func (m *EmitARPsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_EmitARPsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_EmitARPsRequest proto.InternalMessageInfo

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

func (m *EmitARPsRequest) GetMacAddress() string {
	if m != nil {
		return m.MacAddress
	}
	return ""
}

func (m *EmitARPsRequest) GetIpAddresses() []string {
	if m != nil {
		return m.IpAddresses
	}
	return nil
}

type EmitARPsResponse struct {
}

func (m *EmitARPsResponse) Reset()         { *m = EmitARPsResponse{} }
func (m *EmitARPsResponse) String() string { return proto.CompactTextString(m) }
func (*EmitARPsResponse) ProtoMessage()    {}
func (*EmitARPsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_032be33f3739b3f8, []int{12}
}
func (m *EmitARPsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EmitARPsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EmitARPsResponse.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 *EmitARPsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EmitARPsResponse.Merge(m, src)
}
func (m *EmitARPsResponse) XXX_Size() int {
	return m.Size()
}
func (m *EmitARPsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_EmitARPsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_EmitARPsResponse proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("onos.fabricsim.HostType", HostType_name, HostType_value)
	proto.RegisterType((*Host)(nil), "onos.fabricsim.Host")
	proto.RegisterType((*NetworkInterface)(nil), "onos.fabricsim.NetworkInterface")
	proto.RegisterType((*NetworkInterfaceBehavior)(nil), "onos.fabricsim.NetworkInterfaceBehavior")
	proto.RegisterType((*GetHostsRequest)(nil), "onos.fabricsim.GetHostsRequest")
	proto.RegisterType((*GetHostsResponse)(nil), "onos.fabricsim.GetHostsResponse")
	proto.RegisterType((*GetHostRequest)(nil), "onos.fabricsim.GetHostRequest")
	proto.RegisterType((*GetHostResponse)(nil), "onos.fabricsim.GetHostResponse")
	proto.RegisterType((*AddHostRequest)(nil), "onos.fabricsim.AddHostRequest")
	proto.RegisterType((*AddHostResponse)(nil), "onos.fabricsim.AddHostResponse")
	proto.RegisterType((*RemoveHostRequest)(nil), "onos.fabricsim.RemoveHostRequest")
	proto.RegisterType((*RemoveHostResponse)(nil), "onos.fabricsim.RemoveHostResponse")
	proto.RegisterType((*EmitARPsRequest)(nil), "onos.fabricsim.EmitARPsRequest")
	proto.RegisterType((*EmitARPsResponse)(nil), "onos.fabricsim.EmitARPsResponse")
}

func init() { proto.RegisterFile("onos/fabricsim/hosts.proto", fileDescriptor_032be33f3739b3f8) }

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

// HostServiceClient is the client API for HostService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type HostServiceClient interface {
	// GetHosts gets a list of all simulated hosts
	GetHosts(ctx context.Context, in *GetHostsRequest, opts ...grpc.CallOption) (*GetHostsResponse, error)
	// GetHost gets a specific host entry
	GetHost(ctx context.Context, in *GetHostRequest, opts ...grpc.CallOption) (*GetHostResponse, error)
	// AddHost adds a new simulated host
	AddHost(ctx context.Context, in *AddHostRequest, opts ...grpc.CallOption) (*AddHostResponse, error)
	// RemoveHost removes a simulated host
	RemoveHost(ctx context.Context, in *RemoveHostRequest, opts ...grpc.CallOption) (*RemoveHostResponse, error)
	// EmitARPs triggers the specified host NIC to send ARP requests for a set of IP addresses
	EmitARPs(ctx context.Context, in *EmitARPsRequest, opts ...grpc.CallOption) (*EmitARPsResponse, error)
}

type hostServiceClient struct {
	cc *grpc.ClientConn
}

func NewHostServiceClient(cc *grpc.ClientConn) HostServiceClient {
	return &hostServiceClient{cc}
}

func (c *hostServiceClient) GetHosts(ctx context.Context, in *GetHostsRequest, opts ...grpc.CallOption) (*GetHostsResponse, error) {
	out := new(GetHostsResponse)
	err := c.cc.Invoke(ctx, "/onos.fabricsim.HostService/GetHosts", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *hostServiceClient) GetHost(ctx context.Context, in *GetHostRequest, opts ...grpc.CallOption) (*GetHostResponse, error) {
	out := new(GetHostResponse)
	err := c.cc.Invoke(ctx, "/onos.fabricsim.HostService/GetHost", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *hostServiceClient) AddHost(ctx context.Context, in *AddHostRequest, opts ...grpc.CallOption) (*AddHostResponse, error) {
	out := new(AddHostResponse)
	err := c.cc.Invoke(ctx, "/onos.fabricsim.HostService/AddHost", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *hostServiceClient) RemoveHost(ctx context.Context, in *RemoveHostRequest, opts ...grpc.CallOption) (*RemoveHostResponse, error) {
	out := new(RemoveHostResponse)
	err := c.cc.Invoke(ctx, "/onos.fabricsim.HostService/RemoveHost", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *hostServiceClient) EmitARPs(ctx context.Context, in *EmitARPsRequest, opts ...grpc.CallOption) (*EmitARPsResponse, error) {
	out := new(EmitARPsResponse)
	err := c.cc.Invoke(ctx, "/onos.fabricsim.HostService/EmitARPs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// HostServiceServer is the server API for HostService service.
type HostServiceServer interface {
	// GetHosts gets a list of all simulated hosts
	GetHosts(context.Context, *GetHostsRequest) (*GetHostsResponse, error)
	// GetHost gets a specific host entry
	GetHost(context.Context, *GetHostRequest) (*GetHostResponse, error)
	// AddHost adds a new simulated host
	AddHost(context.Context, *AddHostRequest) (*AddHostResponse, error)
	// RemoveHost removes a simulated host
	RemoveHost(context.Context, *RemoveHostRequest) (*RemoveHostResponse, error)
	// EmitARPs triggers the specified host NIC to send ARP requests for a set of IP addresses
	EmitARPs(context.Context, *EmitARPsRequest) (*EmitARPsResponse, error)
}

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

func (*UnimplementedHostServiceServer) GetHosts(ctx context.Context, req *GetHostsRequest) (*GetHostsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetHosts not implemented")
}
func (*UnimplementedHostServiceServer) GetHost(ctx context.Context, req *GetHostRequest) (*GetHostResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetHost not implemented")
}
func (*UnimplementedHostServiceServer) AddHost(ctx context.Context, req *AddHostRequest) (*AddHostResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddHost not implemented")
}
func (*UnimplementedHostServiceServer) RemoveHost(ctx context.Context, req *RemoveHostRequest) (*RemoveHostResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveHost not implemented")
}
func (*UnimplementedHostServiceServer) EmitARPs(ctx context.Context, req *EmitARPsRequest) (*EmitARPsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EmitARPs not implemented")
}

func RegisterHostServiceServer(s *grpc.Server, srv HostServiceServer) {
	s.RegisterService(&_HostService_serviceDesc, srv)
}

func _HostService_GetHosts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetHostsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HostServiceServer).GetHosts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.fabricsim.HostService/GetHosts",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HostServiceServer).GetHosts(ctx, req.(*GetHostsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HostService_GetHost_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetHostRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HostServiceServer).GetHost(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.fabricsim.HostService/GetHost",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HostServiceServer).GetHost(ctx, req.(*GetHostRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HostService_AddHost_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddHostRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HostServiceServer).AddHost(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.fabricsim.HostService/AddHost",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HostServiceServer).AddHost(ctx, req.(*AddHostRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HostService_RemoveHost_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveHostRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HostServiceServer).RemoveHost(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.fabricsim.HostService/RemoveHost",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HostServiceServer).RemoveHost(ctx, req.(*RemoveHostRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HostService_EmitARPs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EmitARPsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HostServiceServer).EmitARPs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.fabricsim.HostService/EmitARPs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HostServiceServer).EmitARPs(ctx, req.(*EmitARPsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _HostService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "onos.fabricsim.HostService",
	HandlerType: (*HostServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetHosts",
			Handler:    _HostService_GetHosts_Handler,
		},
		{
			MethodName: "GetHost",
			Handler:    _HostService_GetHost_Handler,
		},
		{
			MethodName: "AddHost",
			Handler:    _HostService_AddHost_Handler,
		},
		{
			MethodName: "RemoveHost",
			Handler:    _HostService_RemoveHost_Handler,
		},
		{
			MethodName: "EmitARPs",
			Handler:    _HostService_EmitARPs_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "onos/fabricsim/hosts.proto",
}

func (m *Host) 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 *Host) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Host) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Hosts) > 0 {
		for iNdEx := len(m.Hosts) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Hosts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHosts(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.Type != 0 {
		i = encodeVarintHosts(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x20
	}
	if m.Pos != nil {
		{
			size, err := m.Pos.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHosts(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Interfaces) > 0 {
		for iNdEx := len(m.Interfaces) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Interfaces[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHosts(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintHosts(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *NetworkInterface) 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 *NetworkInterface) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NetworkInterface) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.VLAN != 0 {
		i = encodeVarintHosts(dAtA, i, uint64(m.VLAN))
		i--
		dAtA[i] = 0x30
	}
	if m.Behavior != nil {
		{
			size, err := m.Behavior.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHosts(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Ipv6Address) > 0 {
		i -= len(m.Ipv6Address)
		copy(dAtA[i:], m.Ipv6Address)
		i = encodeVarintHosts(dAtA, i, uint64(len(m.Ipv6Address)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.IpAddress) > 0 {
		i -= len(m.IpAddress)
		copy(dAtA[i:], m.IpAddress)
		i = encodeVarintHosts(dAtA, i, uint64(len(m.IpAddress)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.MacAddress) > 0 {
		i -= len(m.MacAddress)
		copy(dAtA[i:], m.MacAddress)
		i = encodeVarintHosts(dAtA, i, uint64(len(m.MacAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintHosts(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *NetworkInterfaceBehavior) 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 *NetworkInterfaceBehavior) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *GetHostsRequest) 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 *GetHostsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *GetHostsResponse) 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 *GetHostsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *GetHostRequest) 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 *GetHostRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetHostRequest) 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 = encodeVarintHosts(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetHostResponse) 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 *GetHostResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *AddHostRequest) 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 *AddHostRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddHostRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.HostedBy) > 0 {
		i -= len(m.HostedBy)
		copy(dAtA[i:], m.HostedBy)
		i = encodeVarintHosts(dAtA, i, uint64(len(m.HostedBy)))
		i--
		dAtA[i] = 0x12
	}
	if m.Host != nil {
		{
			size, err := m.Host.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHosts(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AddHostResponse) 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 *AddHostResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *RemoveHostRequest) 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 *RemoveHostRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveHostRequest) 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 = encodeVarintHosts(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RemoveHostResponse) 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 *RemoveHostResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EmitARPsRequest) 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 *EmitARPsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EmitARPsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.IpAddresses) > 0 {
		for iNdEx := len(m.IpAddresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.IpAddresses[iNdEx])
			copy(dAtA[i:], m.IpAddresses[iNdEx])
			i = encodeVarintHosts(dAtA, i, uint64(len(m.IpAddresses[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.MacAddress) > 0 {
		i -= len(m.MacAddress)
		copy(dAtA[i:], m.MacAddress)
		i = encodeVarintHosts(dAtA, i, uint64(len(m.MacAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintHosts(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EmitARPsResponse) 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 *EmitARPsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func encodeVarintHosts(dAtA []byte, offset int, v uint64) int {
	offset -= sovHosts(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Host) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovHosts(uint64(l))
	}
	if len(m.Interfaces) > 0 {
		for _, e := range m.Interfaces {
			l = e.Size()
			n += 1 + l + sovHosts(uint64(l))
		}
	}
	if m.Pos != nil {
		l = m.Pos.Size()
		n += 1 + l + sovHosts(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovHosts(uint64(m.Type))
	}
	if len(m.Hosts) > 0 {
		for _, e := range m.Hosts {
			l = e.Size()
			n += 1 + l + sovHosts(uint64(l))
		}
	}
	return n
}

func (m *NetworkInterface) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovHosts(uint64(l))
	}
	l = len(m.MacAddress)
	if l > 0 {
		n += 1 + l + sovHosts(uint64(l))
	}
	l = len(m.IpAddress)
	if l > 0 {
		n += 1 + l + sovHosts(uint64(l))
	}
	l = len(m.Ipv6Address)
	if l > 0 {
		n += 1 + l + sovHosts(uint64(l))
	}
	if m.Behavior != nil {
		l = m.Behavior.Size()
		n += 1 + l + sovHosts(uint64(l))
	}
	if m.VLAN != 0 {
		n += 1 + sovHosts(uint64(m.VLAN))
	}
	return n
}

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

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

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

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

func (m *GetHostResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Host != nil {
		l = m.Host.Size()
		n += 1 + l + sovHosts(uint64(l))
	}
	return n
}

func (m *AddHostRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Host != nil {
		l = m.Host.Size()
		n += 1 + l + sovHosts(uint64(l))
	}
	l = len(m.HostedBy)
	if l > 0 {
		n += 1 + l + sovHosts(uint64(l))
	}
	return n
}

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

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

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

func (m *EmitARPsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovHosts(uint64(l))
	}
	l = len(m.MacAddress)
	if l > 0 {
		n += 1 + l + sovHosts(uint64(l))
	}
	if len(m.IpAddresses) > 0 {
		for _, s := range m.IpAddresses {
			l = len(s)
			n += 1 + l + sovHosts(uint64(l))
		}
	}
	return n
}

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

func sovHosts(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozHosts(x uint64) (n int) {
	return sovHosts(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Host) 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 ErrIntOverflowHosts
			}
			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: Host: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Host: 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 ErrIntOverflowHosts
				}
				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 ErrInvalidLengthHosts
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHosts
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = HostID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Interfaces", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHosts
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHosts
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHosts
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Interfaces = append(m.Interfaces, &NetworkInterface{})
			if err := m.Interfaces[len(m.Interfaces)-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 Pos", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHosts
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHosts
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHosts
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pos == nil {
				m.Pos = &misc.GridPosition{}
			}
			if err := m.Pos.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHosts
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= HostType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hosts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHosts
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHosts
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHosts
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hosts = append(m.Hosts, &Host{})
			if err := m.Hosts[len(m.Hosts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHosts(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHosts
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NetworkInterface) 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 ErrIntOverflowHosts
			}
			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: NetworkInterface: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NetworkInterface: 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 ErrIntOverflowHosts
				}
				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 ErrInvalidLengthHosts
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHosts
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = PortID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MacAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHosts
				}
				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 ErrInvalidLengthHosts
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHosts
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MacAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IpAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHosts
				}
				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 ErrInvalidLengthHosts
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHosts
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IpAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipv6Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHosts
				}
				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 ErrInvalidLengthHosts
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHosts
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ipv6Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Behavior", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHosts
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHosts
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHosts
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Behavior == nil {
				m.Behavior = &NetworkInterfaceBehavior{}
			}
			if err := m.Behavior.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VLAN", wireType)
			}
			m.VLAN = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHosts
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VLAN |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHosts(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHosts
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EmitARPsRequest) 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 ErrIntOverflowHosts
			}
			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: EmitARPsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EmitARPsRequest: 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 ErrIntOverflowHosts
				}
				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 ErrInvalidLengthHosts
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHosts
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = HostID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MacAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHosts
				}
				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 ErrInvalidLengthHosts
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHosts
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MacAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IpAddresses", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHosts
				}
				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 ErrInvalidLengthHosts
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHosts
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IpAddresses = append(m.IpAddresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHosts(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthHosts
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipHosts(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, ErrIntOverflowHosts
			}
			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, ErrIntOverflowHosts
				}
				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, ErrIntOverflowHosts
				}
				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, ErrInvalidLengthHosts
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupHosts
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthHosts
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthHosts        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowHosts          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupHosts = fmt.Errorf("proto: unexpected end of group")
)