github.com/zhuohuang-hust/src-cbuild@v0.0.0-20230105071821-c7aab3e7c840/mergeCode/libnetwork/networkdb/networkdb.pb.go (about)

     1  // Code generated by protoc-gen-gogo.
     2  // source: networkdb.proto
     3  // DO NOT EDIT!
     4  
     5  /*
     6  	Package networkdb is a generated protocol buffer package.
     7  
     8  	It is generated from these files:
     9  		networkdb.proto
    10  
    11  	It has these top-level messages:
    12  		GossipMessage
    13  		NodeEvent
    14  		NetworkEvent
    15  		NetworkEntry
    16  		NetworkPushPull
    17  		TableEvent
    18  		BulkSyncMessage
    19  		CompoundMessage
    20  */
    21  package networkdb
    22  
    23  import proto "github.com/gogo/protobuf/proto"
    24  import fmt "fmt"
    25  import math "math"
    26  import _ "github.com/gogo/protobuf/gogoproto"
    27  
    28  import github_com_hashicorp_serf_serf "github.com/hashicorp/serf/serf"
    29  
    30  import strings "strings"
    31  import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
    32  import sort "sort"
    33  import strconv "strconv"
    34  import reflect "reflect"
    35  
    36  import io "io"
    37  
    38  // Reference imports to suppress errors if they are not otherwise used.
    39  var _ = proto.Marshal
    40  var _ = fmt.Errorf
    41  var _ = math.Inf
    42  
    43  // This is a compile-time assertion to ensure that this generated file
    44  // is compatible with the proto package it is being compiled against.
    45  const _ = proto.GoGoProtoPackageIsVersion1
    46  
    47  // MessageType enum defines all the core message types that networkdb
    48  // uses to communicate to peers.
    49  type MessageType int32
    50  
    51  const (
    52  	MessageTypeInvalid MessageType = 0
    53  	// NetworEvent message type is used to communicate network
    54  	// attachments on the node.
    55  	MessageTypeNetworkEvent MessageType = 1
    56  	// TableEvent message type is used to communicate any table
    57  	// CRUD event that happened on the node.
    58  	MessageTypeTableEvent MessageType = 2
    59  	// PushPull message type is used to syncup all network
    60  	// attachments on a peer node either during startup of this
    61  	// node or with a random peer node periodically thereafter.
    62  	MessageTypePushPull MessageType = 3
    63  	// BulkSync message is used to bulksync the whole networkdb
    64  	// state with a peer node during startup of this node or with
    65  	// a random peer node periodically thereafter.
    66  	MessageTypeBulkSync MessageType = 4
    67  	// Compound message type is used to form a compound message
    68  	// which is a pack of many message of above types, packed into
    69  	// a single compound message.
    70  	MessageTypeCompound MessageType = 5
    71  	// NodeEvent message type is used to communicare node
    72  	// join/leave events in the cluster
    73  	MessageTypeNodeEvent MessageType = 6
    74  )
    75  
    76  var MessageType_name = map[int32]string{
    77  	0: "INVALID",
    78  	1: "NETWORK_EVENT",
    79  	2: "TABLE_EVENT",
    80  	3: "PUSH_PULL",
    81  	4: "BULK_SYNC",
    82  	5: "COMPOUND",
    83  	6: "NODE_EVENT",
    84  }
    85  var MessageType_value = map[string]int32{
    86  	"INVALID":       0,
    87  	"NETWORK_EVENT": 1,
    88  	"TABLE_EVENT":   2,
    89  	"PUSH_PULL":     3,
    90  	"BULK_SYNC":     4,
    91  	"COMPOUND":      5,
    92  	"NODE_EVENT":    6,
    93  }
    94  
    95  func (x MessageType) String() string {
    96  	return proto.EnumName(MessageType_name, int32(x))
    97  }
    98  func (MessageType) EnumDescriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{0} }
    99  
   100  type NodeEvent_Type int32
   101  
   102  const (
   103  	NodeEventTypeInvalid NodeEvent_Type = 0
   104  	// Join event is generated when this node joins the cluster.
   105  	NodeEventTypeJoin NodeEvent_Type = 1
   106  	// Leave event is generated when this node leaves the cluster.
   107  	NodeEventTypeLeave NodeEvent_Type = 2
   108  )
   109  
   110  var NodeEvent_Type_name = map[int32]string{
   111  	0: "INVALID",
   112  	1: "JOIN",
   113  	2: "LEAVE",
   114  }
   115  var NodeEvent_Type_value = map[string]int32{
   116  	"INVALID": 0,
   117  	"JOIN":    1,
   118  	"LEAVE":   2,
   119  }
   120  
   121  func (x NodeEvent_Type) String() string {
   122  	return proto.EnumName(NodeEvent_Type_name, int32(x))
   123  }
   124  func (NodeEvent_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{1, 0} }
   125  
   126  type NetworkEvent_Type int32
   127  
   128  const (
   129  	NetworkEventTypeInvalid NetworkEvent_Type = 0
   130  	// Join event is generated when this node joins a network.
   131  	NetworkEventTypeJoin NetworkEvent_Type = 1
   132  	// Leave event is generated when this node leaves a network.
   133  	NetworkEventTypeLeave NetworkEvent_Type = 2
   134  )
   135  
   136  var NetworkEvent_Type_name = map[int32]string{
   137  	0: "INVALID",
   138  	1: "JOIN",
   139  	2: "LEAVE",
   140  }
   141  var NetworkEvent_Type_value = map[string]int32{
   142  	"INVALID": 0,
   143  	"JOIN":    1,
   144  	"LEAVE":   2,
   145  }
   146  
   147  func (x NetworkEvent_Type) String() string {
   148  	return proto.EnumName(NetworkEvent_Type_name, int32(x))
   149  }
   150  func (NetworkEvent_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{2, 0} }
   151  
   152  type TableEvent_Type int32
   153  
   154  const (
   155  	TableEventTypeInvalid TableEvent_Type = 0
   156  	// Create signifies that this table entry was just
   157  	// created.
   158  	TableEventTypeCreate TableEvent_Type = 1
   159  	// Update signifies that this table entry was just
   160  	// updated.
   161  	TableEventTypeUpdate TableEvent_Type = 2
   162  	// Delete signifies that this table entry was just
   163  	// updated.
   164  	TableEventTypeDelete TableEvent_Type = 3
   165  )
   166  
   167  var TableEvent_Type_name = map[int32]string{
   168  	0: "INVALID",
   169  	1: "CREATE",
   170  	2: "UPDATE",
   171  	3: "DELETE",
   172  }
   173  var TableEvent_Type_value = map[string]int32{
   174  	"INVALID": 0,
   175  	"CREATE":  1,
   176  	"UPDATE":  2,
   177  	"DELETE":  3,
   178  }
   179  
   180  func (x TableEvent_Type) String() string {
   181  	return proto.EnumName(TableEvent_Type_name, int32(x))
   182  }
   183  func (TableEvent_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{5, 0} }
   184  
   185  // GossipMessage is a basic message header used by all messages types.
   186  type GossipMessage struct {
   187  	Type MessageType `protobuf:"varint,1,opt,name=type,proto3,enum=networkdb.MessageType" json:"type,omitempty"`
   188  	Data []byte      `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
   189  }
   190  
   191  func (m *GossipMessage) Reset()                    { *m = GossipMessage{} }
   192  func (*GossipMessage) ProtoMessage()               {}
   193  func (*GossipMessage) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{0} }
   194  
   195  // NodeEvent message payload definition.
   196  type NodeEvent struct {
   197  	Type NodeEvent_Type `protobuf:"varint,1,opt,name=type,proto3,enum=networkdb.NodeEvent_Type" json:"type,omitempty"`
   198  	// Lamport time using a network lamport clock indicating the
   199  	// time this event was generated on the node where it was
   200  	// generated.
   201  	LTime github_com_hashicorp_serf_serf.LamportTime `protobuf:"varint,2,opt,name=l_time,json=lTime,proto3,customtype=github.com/hashicorp/serf/serf.LamportTime" json:"l_time"`
   202  	// Source node name.
   203  	NodeName string `protobuf:"bytes,3,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
   204  }
   205  
   206  func (m *NodeEvent) Reset()                    { *m = NodeEvent{} }
   207  func (*NodeEvent) ProtoMessage()               {}
   208  func (*NodeEvent) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{1} }
   209  
   210  // NetworkEvent message payload definition.
   211  type NetworkEvent struct {
   212  	Type NetworkEvent_Type `protobuf:"varint,1,opt,name=type,proto3,enum=networkdb.NetworkEvent_Type" json:"type,omitempty"`
   213  	// Lamport time using a network lamport clock indicating the
   214  	// time this event was generated on the node where it was
   215  	// generated.
   216  	LTime github_com_hashicorp_serf_serf.LamportTime `protobuf:"varint,2,opt,name=l_time,json=lTime,proto3,customtype=github.com/hashicorp/serf/serf.LamportTime" json:"l_time"`
   217  	// Source node name.
   218  	NodeName string `protobuf:"bytes,3,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
   219  	// ID of the network for which the event is generated.
   220  	NetworkID string `protobuf:"bytes,4,opt,name=network_id,json=networkId,proto3" json:"network_id,omitempty"`
   221  }
   222  
   223  func (m *NetworkEvent) Reset()                    { *m = NetworkEvent{} }
   224  func (*NetworkEvent) ProtoMessage()               {}
   225  func (*NetworkEvent) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{2} }
   226  
   227  // NetworkEntry for push pull of networks.
   228  type NetworkEntry struct {
   229  	// ID of the network
   230  	NetworkID string `protobuf:"bytes,1,opt,name=network_id,json=networkId,proto3" json:"network_id,omitempty"`
   231  	// Latest lamport time of the network attachment when this
   232  	// network event was recorded.
   233  	LTime github_com_hashicorp_serf_serf.LamportTime `protobuf:"varint,2,opt,name=l_time,json=lTime,proto3,customtype=github.com/hashicorp/serf/serf.LamportTime" json:"l_time"`
   234  	// Source node name where this network attachment happened.
   235  	NodeName string `protobuf:"bytes,3,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
   236  	// Indicates if a leave from this network is in progress.
   237  	Leaving bool `protobuf:"varint,4,opt,name=leaving,proto3" json:"leaving,omitempty"`
   238  }
   239  
   240  func (m *NetworkEntry) Reset()                    { *m = NetworkEntry{} }
   241  func (*NetworkEntry) ProtoMessage()               {}
   242  func (*NetworkEntry) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{3} }
   243  
   244  // NetworkPushpull message payload definition.
   245  type NetworkPushPull struct {
   246  	// Lamport time when this push pull was initiated.
   247  	LTime    github_com_hashicorp_serf_serf.LamportTime `protobuf:"varint,1,opt,name=l_time,json=lTime,proto3,customtype=github.com/hashicorp/serf/serf.LamportTime" json:"l_time"`
   248  	Networks []*NetworkEntry                            `protobuf:"bytes,2,rep,name=networks" json:"networks,omitempty"`
   249  	// Name of the node sending this push pull payload.
   250  	NodeName string `protobuf:"bytes,3,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
   251  }
   252  
   253  func (m *NetworkPushPull) Reset()                    { *m = NetworkPushPull{} }
   254  func (*NetworkPushPull) ProtoMessage()               {}
   255  func (*NetworkPushPull) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{4} }
   256  
   257  func (m *NetworkPushPull) GetNetworks() []*NetworkEntry {
   258  	if m != nil {
   259  		return m.Networks
   260  	}
   261  	return nil
   262  }
   263  
   264  // TableEvent message payload definition.
   265  type TableEvent struct {
   266  	Type TableEvent_Type `protobuf:"varint,1,opt,name=type,proto3,enum=networkdb.TableEvent_Type" json:"type,omitempty"`
   267  	// Lamport time when this event was generated.
   268  	LTime github_com_hashicorp_serf_serf.LamportTime `protobuf:"varint,2,opt,name=l_time,json=lTime,proto3,customtype=github.com/hashicorp/serf/serf.LamportTime" json:"l_time"`
   269  	// Node name where this event originated.
   270  	NodeName string `protobuf:"bytes,3,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
   271  	// ID of the network to which this table entry belongs.
   272  	NetworkID string `protobuf:"bytes,4,opt,name=network_id,json=networkId,proto3" json:"network_id,omitempty"`
   273  	// Name of the table to which this table entry belongs.
   274  	TableName string `protobuf:"bytes,5,opt,name=table_name,json=tableName,proto3" json:"table_name,omitempty"`
   275  	// Entry key.
   276  	Key string `protobuf:"bytes,6,opt,name=key,proto3" json:"key,omitempty"`
   277  	// Entry value.
   278  	Value []byte `protobuf:"bytes,7,opt,name=value,proto3" json:"value,omitempty"`
   279  }
   280  
   281  func (m *TableEvent) Reset()                    { *m = TableEvent{} }
   282  func (*TableEvent) ProtoMessage()               {}
   283  func (*TableEvent) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{5} }
   284  
   285  // BulkSync message payload definition.
   286  type BulkSyncMessage struct {
   287  	// Lamport time when this bulk sync was initiated.
   288  	LTime github_com_hashicorp_serf_serf.LamportTime `protobuf:"varint,1,opt,name=l_time,json=lTime,proto3,customtype=github.com/hashicorp/serf/serf.LamportTime" json:"l_time"`
   289  	// Indicates if this bulksync is a response to a bulk sync
   290  	// request from a peer node.
   291  	Unsolicited bool `protobuf:"varint,2,opt,name=unsolicited,proto3" json:"unsolicited,omitempty"`
   292  	// Name of the node which is producing this bulk sync message.
   293  	NodeName string `protobuf:"bytes,3,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
   294  	// List of network names whose table entries are getting
   295  	// bulksynced as part of the bulksync.
   296  	Networks []string `protobuf:"bytes,4,rep,name=networks" json:"networks,omitempty"`
   297  	// Bulksync payload
   298  	Payload []byte `protobuf:"bytes,5,opt,name=payload,proto3" json:"payload,omitempty"`
   299  }
   300  
   301  func (m *BulkSyncMessage) Reset()                    { *m = BulkSyncMessage{} }
   302  func (*BulkSyncMessage) ProtoMessage()               {}
   303  func (*BulkSyncMessage) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{6} }
   304  
   305  // Compound message payload definition.
   306  type CompoundMessage struct {
   307  	// A list of simple messages.
   308  	Messages []*CompoundMessage_SimpleMessage `protobuf:"bytes,1,rep,name=messages" json:"messages,omitempty"`
   309  }
   310  
   311  func (m *CompoundMessage) Reset()                    { *m = CompoundMessage{} }
   312  func (*CompoundMessage) ProtoMessage()               {}
   313  func (*CompoundMessage) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{7} }
   314  
   315  func (m *CompoundMessage) GetMessages() []*CompoundMessage_SimpleMessage {
   316  	if m != nil {
   317  		return m.Messages
   318  	}
   319  	return nil
   320  }
   321  
   322  type CompoundMessage_SimpleMessage struct {
   323  	// Bytestring payload of a message constructed using
   324  	// other message type definitions.
   325  	Payload []byte `protobuf:"bytes,1,opt,name=Payload,json=payload,proto3" json:"Payload,omitempty"`
   326  }
   327  
   328  func (m *CompoundMessage_SimpleMessage) Reset()      { *m = CompoundMessage_SimpleMessage{} }
   329  func (*CompoundMessage_SimpleMessage) ProtoMessage() {}
   330  func (*CompoundMessage_SimpleMessage) Descriptor() ([]byte, []int) {
   331  	return fileDescriptorNetworkdb, []int{7, 0}
   332  }
   333  
   334  func init() {
   335  	proto.RegisterType((*GossipMessage)(nil), "networkdb.GossipMessage")
   336  	proto.RegisterType((*NodeEvent)(nil), "networkdb.NodeEvent")
   337  	proto.RegisterType((*NetworkEvent)(nil), "networkdb.NetworkEvent")
   338  	proto.RegisterType((*NetworkEntry)(nil), "networkdb.NetworkEntry")
   339  	proto.RegisterType((*NetworkPushPull)(nil), "networkdb.NetworkPushPull")
   340  	proto.RegisterType((*TableEvent)(nil), "networkdb.TableEvent")
   341  	proto.RegisterType((*BulkSyncMessage)(nil), "networkdb.BulkSyncMessage")
   342  	proto.RegisterType((*CompoundMessage)(nil), "networkdb.CompoundMessage")
   343  	proto.RegisterType((*CompoundMessage_SimpleMessage)(nil), "networkdb.CompoundMessage.SimpleMessage")
   344  	proto.RegisterEnum("networkdb.MessageType", MessageType_name, MessageType_value)
   345  	proto.RegisterEnum("networkdb.NodeEvent_Type", NodeEvent_Type_name, NodeEvent_Type_value)
   346  	proto.RegisterEnum("networkdb.NetworkEvent_Type", NetworkEvent_Type_name, NetworkEvent_Type_value)
   347  	proto.RegisterEnum("networkdb.TableEvent_Type", TableEvent_Type_name, TableEvent_Type_value)
   348  }
   349  func (this *GossipMessage) GoString() string {
   350  	if this == nil {
   351  		return "nil"
   352  	}
   353  	s := make([]string, 0, 6)
   354  	s = append(s, "&networkdb.GossipMessage{")
   355  	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
   356  	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
   357  	s = append(s, "}")
   358  	return strings.Join(s, "")
   359  }
   360  func (this *NodeEvent) GoString() string {
   361  	if this == nil {
   362  		return "nil"
   363  	}
   364  	s := make([]string, 0, 7)
   365  	s = append(s, "&networkdb.NodeEvent{")
   366  	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
   367  	s = append(s, "LTime: "+fmt.Sprintf("%#v", this.LTime)+",\n")
   368  	s = append(s, "NodeName: "+fmt.Sprintf("%#v", this.NodeName)+",\n")
   369  	s = append(s, "}")
   370  	return strings.Join(s, "")
   371  }
   372  func (this *NetworkEvent) GoString() string {
   373  	if this == nil {
   374  		return "nil"
   375  	}
   376  	s := make([]string, 0, 8)
   377  	s = append(s, "&networkdb.NetworkEvent{")
   378  	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
   379  	s = append(s, "LTime: "+fmt.Sprintf("%#v", this.LTime)+",\n")
   380  	s = append(s, "NodeName: "+fmt.Sprintf("%#v", this.NodeName)+",\n")
   381  	s = append(s, "NetworkID: "+fmt.Sprintf("%#v", this.NetworkID)+",\n")
   382  	s = append(s, "}")
   383  	return strings.Join(s, "")
   384  }
   385  func (this *NetworkEntry) GoString() string {
   386  	if this == nil {
   387  		return "nil"
   388  	}
   389  	s := make([]string, 0, 8)
   390  	s = append(s, "&networkdb.NetworkEntry{")
   391  	s = append(s, "NetworkID: "+fmt.Sprintf("%#v", this.NetworkID)+",\n")
   392  	s = append(s, "LTime: "+fmt.Sprintf("%#v", this.LTime)+",\n")
   393  	s = append(s, "NodeName: "+fmt.Sprintf("%#v", this.NodeName)+",\n")
   394  	s = append(s, "Leaving: "+fmt.Sprintf("%#v", this.Leaving)+",\n")
   395  	s = append(s, "}")
   396  	return strings.Join(s, "")
   397  }
   398  func (this *NetworkPushPull) GoString() string {
   399  	if this == nil {
   400  		return "nil"
   401  	}
   402  	s := make([]string, 0, 7)
   403  	s = append(s, "&networkdb.NetworkPushPull{")
   404  	s = append(s, "LTime: "+fmt.Sprintf("%#v", this.LTime)+",\n")
   405  	if this.Networks != nil {
   406  		s = append(s, "Networks: "+fmt.Sprintf("%#v", this.Networks)+",\n")
   407  	}
   408  	s = append(s, "NodeName: "+fmt.Sprintf("%#v", this.NodeName)+",\n")
   409  	s = append(s, "}")
   410  	return strings.Join(s, "")
   411  }
   412  func (this *TableEvent) GoString() string {
   413  	if this == nil {
   414  		return "nil"
   415  	}
   416  	s := make([]string, 0, 11)
   417  	s = append(s, "&networkdb.TableEvent{")
   418  	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
   419  	s = append(s, "LTime: "+fmt.Sprintf("%#v", this.LTime)+",\n")
   420  	s = append(s, "NodeName: "+fmt.Sprintf("%#v", this.NodeName)+",\n")
   421  	s = append(s, "NetworkID: "+fmt.Sprintf("%#v", this.NetworkID)+",\n")
   422  	s = append(s, "TableName: "+fmt.Sprintf("%#v", this.TableName)+",\n")
   423  	s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
   424  	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
   425  	s = append(s, "}")
   426  	return strings.Join(s, "")
   427  }
   428  func (this *BulkSyncMessage) GoString() string {
   429  	if this == nil {
   430  		return "nil"
   431  	}
   432  	s := make([]string, 0, 9)
   433  	s = append(s, "&networkdb.BulkSyncMessage{")
   434  	s = append(s, "LTime: "+fmt.Sprintf("%#v", this.LTime)+",\n")
   435  	s = append(s, "Unsolicited: "+fmt.Sprintf("%#v", this.Unsolicited)+",\n")
   436  	s = append(s, "NodeName: "+fmt.Sprintf("%#v", this.NodeName)+",\n")
   437  	s = append(s, "Networks: "+fmt.Sprintf("%#v", this.Networks)+",\n")
   438  	s = append(s, "Payload: "+fmt.Sprintf("%#v", this.Payload)+",\n")
   439  	s = append(s, "}")
   440  	return strings.Join(s, "")
   441  }
   442  func (this *CompoundMessage) GoString() string {
   443  	if this == nil {
   444  		return "nil"
   445  	}
   446  	s := make([]string, 0, 5)
   447  	s = append(s, "&networkdb.CompoundMessage{")
   448  	if this.Messages != nil {
   449  		s = append(s, "Messages: "+fmt.Sprintf("%#v", this.Messages)+",\n")
   450  	}
   451  	s = append(s, "}")
   452  	return strings.Join(s, "")
   453  }
   454  func (this *CompoundMessage_SimpleMessage) GoString() string {
   455  	if this == nil {
   456  		return "nil"
   457  	}
   458  	s := make([]string, 0, 5)
   459  	s = append(s, "&networkdb.CompoundMessage_SimpleMessage{")
   460  	s = append(s, "Payload: "+fmt.Sprintf("%#v", this.Payload)+",\n")
   461  	s = append(s, "}")
   462  	return strings.Join(s, "")
   463  }
   464  func valueToGoStringNetworkdb(v interface{}, typ string) string {
   465  	rv := reflect.ValueOf(v)
   466  	if rv.IsNil() {
   467  		return "nil"
   468  	}
   469  	pv := reflect.Indirect(rv).Interface()
   470  	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
   471  }
   472  func extensionToGoStringNetworkdb(e map[int32]github_com_gogo_protobuf_proto.Extension) string {
   473  	if e == nil {
   474  		return "nil"
   475  	}
   476  	s := "map[int32]proto.Extension{"
   477  	keys := make([]int, 0, len(e))
   478  	for k := range e {
   479  		keys = append(keys, int(k))
   480  	}
   481  	sort.Ints(keys)
   482  	ss := []string{}
   483  	for _, k := range keys {
   484  		ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString())
   485  	}
   486  	s += strings.Join(ss, ",") + "}"
   487  	return s
   488  }
   489  func (m *GossipMessage) Marshal() (data []byte, err error) {
   490  	size := m.Size()
   491  	data = make([]byte, size)
   492  	n, err := m.MarshalTo(data)
   493  	if err != nil {
   494  		return nil, err
   495  	}
   496  	return data[:n], nil
   497  }
   498  
   499  func (m *GossipMessage) MarshalTo(data []byte) (int, error) {
   500  	var i int
   501  	_ = i
   502  	var l int
   503  	_ = l
   504  	if m.Type != 0 {
   505  		data[i] = 0x8
   506  		i++
   507  		i = encodeVarintNetworkdb(data, i, uint64(m.Type))
   508  	}
   509  	if len(m.Data) > 0 {
   510  		data[i] = 0x12
   511  		i++
   512  		i = encodeVarintNetworkdb(data, i, uint64(len(m.Data)))
   513  		i += copy(data[i:], m.Data)
   514  	}
   515  	return i, nil
   516  }
   517  
   518  func (m *NodeEvent) Marshal() (data []byte, err error) {
   519  	size := m.Size()
   520  	data = make([]byte, size)
   521  	n, err := m.MarshalTo(data)
   522  	if err != nil {
   523  		return nil, err
   524  	}
   525  	return data[:n], nil
   526  }
   527  
   528  func (m *NodeEvent) MarshalTo(data []byte) (int, error) {
   529  	var i int
   530  	_ = i
   531  	var l int
   532  	_ = l
   533  	if m.Type != 0 {
   534  		data[i] = 0x8
   535  		i++
   536  		i = encodeVarintNetworkdb(data, i, uint64(m.Type))
   537  	}
   538  	if m.LTime != 0 {
   539  		data[i] = 0x10
   540  		i++
   541  		i = encodeVarintNetworkdb(data, i, uint64(m.LTime))
   542  	}
   543  	if len(m.NodeName) > 0 {
   544  		data[i] = 0x1a
   545  		i++
   546  		i = encodeVarintNetworkdb(data, i, uint64(len(m.NodeName)))
   547  		i += copy(data[i:], m.NodeName)
   548  	}
   549  	return i, nil
   550  }
   551  
   552  func (m *NetworkEvent) Marshal() (data []byte, err error) {
   553  	size := m.Size()
   554  	data = make([]byte, size)
   555  	n, err := m.MarshalTo(data)
   556  	if err != nil {
   557  		return nil, err
   558  	}
   559  	return data[:n], nil
   560  }
   561  
   562  func (m *NetworkEvent) MarshalTo(data []byte) (int, error) {
   563  	var i int
   564  	_ = i
   565  	var l int
   566  	_ = l
   567  	if m.Type != 0 {
   568  		data[i] = 0x8
   569  		i++
   570  		i = encodeVarintNetworkdb(data, i, uint64(m.Type))
   571  	}
   572  	if m.LTime != 0 {
   573  		data[i] = 0x10
   574  		i++
   575  		i = encodeVarintNetworkdb(data, i, uint64(m.LTime))
   576  	}
   577  	if len(m.NodeName) > 0 {
   578  		data[i] = 0x1a
   579  		i++
   580  		i = encodeVarintNetworkdb(data, i, uint64(len(m.NodeName)))
   581  		i += copy(data[i:], m.NodeName)
   582  	}
   583  	if len(m.NetworkID) > 0 {
   584  		data[i] = 0x22
   585  		i++
   586  		i = encodeVarintNetworkdb(data, i, uint64(len(m.NetworkID)))
   587  		i += copy(data[i:], m.NetworkID)
   588  	}
   589  	return i, nil
   590  }
   591  
   592  func (m *NetworkEntry) Marshal() (data []byte, err error) {
   593  	size := m.Size()
   594  	data = make([]byte, size)
   595  	n, err := m.MarshalTo(data)
   596  	if err != nil {
   597  		return nil, err
   598  	}
   599  	return data[:n], nil
   600  }
   601  
   602  func (m *NetworkEntry) MarshalTo(data []byte) (int, error) {
   603  	var i int
   604  	_ = i
   605  	var l int
   606  	_ = l
   607  	if len(m.NetworkID) > 0 {
   608  		data[i] = 0xa
   609  		i++
   610  		i = encodeVarintNetworkdb(data, i, uint64(len(m.NetworkID)))
   611  		i += copy(data[i:], m.NetworkID)
   612  	}
   613  	if m.LTime != 0 {
   614  		data[i] = 0x10
   615  		i++
   616  		i = encodeVarintNetworkdb(data, i, uint64(m.LTime))
   617  	}
   618  	if len(m.NodeName) > 0 {
   619  		data[i] = 0x1a
   620  		i++
   621  		i = encodeVarintNetworkdb(data, i, uint64(len(m.NodeName)))
   622  		i += copy(data[i:], m.NodeName)
   623  	}
   624  	if m.Leaving {
   625  		data[i] = 0x20
   626  		i++
   627  		if m.Leaving {
   628  			data[i] = 1
   629  		} else {
   630  			data[i] = 0
   631  		}
   632  		i++
   633  	}
   634  	return i, nil
   635  }
   636  
   637  func (m *NetworkPushPull) Marshal() (data []byte, err error) {
   638  	size := m.Size()
   639  	data = make([]byte, size)
   640  	n, err := m.MarshalTo(data)
   641  	if err != nil {
   642  		return nil, err
   643  	}
   644  	return data[:n], nil
   645  }
   646  
   647  func (m *NetworkPushPull) MarshalTo(data []byte) (int, error) {
   648  	var i int
   649  	_ = i
   650  	var l int
   651  	_ = l
   652  	if m.LTime != 0 {
   653  		data[i] = 0x8
   654  		i++
   655  		i = encodeVarintNetworkdb(data, i, uint64(m.LTime))
   656  	}
   657  	if len(m.Networks) > 0 {
   658  		for _, msg := range m.Networks {
   659  			data[i] = 0x12
   660  			i++
   661  			i = encodeVarintNetworkdb(data, i, uint64(msg.Size()))
   662  			n, err := msg.MarshalTo(data[i:])
   663  			if err != nil {
   664  				return 0, err
   665  			}
   666  			i += n
   667  		}
   668  	}
   669  	if len(m.NodeName) > 0 {
   670  		data[i] = 0x1a
   671  		i++
   672  		i = encodeVarintNetworkdb(data, i, uint64(len(m.NodeName)))
   673  		i += copy(data[i:], m.NodeName)
   674  	}
   675  	return i, nil
   676  }
   677  
   678  func (m *TableEvent) Marshal() (data []byte, err error) {
   679  	size := m.Size()
   680  	data = make([]byte, size)
   681  	n, err := m.MarshalTo(data)
   682  	if err != nil {
   683  		return nil, err
   684  	}
   685  	return data[:n], nil
   686  }
   687  
   688  func (m *TableEvent) MarshalTo(data []byte) (int, error) {
   689  	var i int
   690  	_ = i
   691  	var l int
   692  	_ = l
   693  	if m.Type != 0 {
   694  		data[i] = 0x8
   695  		i++
   696  		i = encodeVarintNetworkdb(data, i, uint64(m.Type))
   697  	}
   698  	if m.LTime != 0 {
   699  		data[i] = 0x10
   700  		i++
   701  		i = encodeVarintNetworkdb(data, i, uint64(m.LTime))
   702  	}
   703  	if len(m.NodeName) > 0 {
   704  		data[i] = 0x1a
   705  		i++
   706  		i = encodeVarintNetworkdb(data, i, uint64(len(m.NodeName)))
   707  		i += copy(data[i:], m.NodeName)
   708  	}
   709  	if len(m.NetworkID) > 0 {
   710  		data[i] = 0x22
   711  		i++
   712  		i = encodeVarintNetworkdb(data, i, uint64(len(m.NetworkID)))
   713  		i += copy(data[i:], m.NetworkID)
   714  	}
   715  	if len(m.TableName) > 0 {
   716  		data[i] = 0x2a
   717  		i++
   718  		i = encodeVarintNetworkdb(data, i, uint64(len(m.TableName)))
   719  		i += copy(data[i:], m.TableName)
   720  	}
   721  	if len(m.Key) > 0 {
   722  		data[i] = 0x32
   723  		i++
   724  		i = encodeVarintNetworkdb(data, i, uint64(len(m.Key)))
   725  		i += copy(data[i:], m.Key)
   726  	}
   727  	if len(m.Value) > 0 {
   728  		data[i] = 0x3a
   729  		i++
   730  		i = encodeVarintNetworkdb(data, i, uint64(len(m.Value)))
   731  		i += copy(data[i:], m.Value)
   732  	}
   733  	return i, nil
   734  }
   735  
   736  func (m *BulkSyncMessage) Marshal() (data []byte, err error) {
   737  	size := m.Size()
   738  	data = make([]byte, size)
   739  	n, err := m.MarshalTo(data)
   740  	if err != nil {
   741  		return nil, err
   742  	}
   743  	return data[:n], nil
   744  }
   745  
   746  func (m *BulkSyncMessage) MarshalTo(data []byte) (int, error) {
   747  	var i int
   748  	_ = i
   749  	var l int
   750  	_ = l
   751  	if m.LTime != 0 {
   752  		data[i] = 0x8
   753  		i++
   754  		i = encodeVarintNetworkdb(data, i, uint64(m.LTime))
   755  	}
   756  	if m.Unsolicited {
   757  		data[i] = 0x10
   758  		i++
   759  		if m.Unsolicited {
   760  			data[i] = 1
   761  		} else {
   762  			data[i] = 0
   763  		}
   764  		i++
   765  	}
   766  	if len(m.NodeName) > 0 {
   767  		data[i] = 0x1a
   768  		i++
   769  		i = encodeVarintNetworkdb(data, i, uint64(len(m.NodeName)))
   770  		i += copy(data[i:], m.NodeName)
   771  	}
   772  	if len(m.Networks) > 0 {
   773  		for _, s := range m.Networks {
   774  			data[i] = 0x22
   775  			i++
   776  			l = len(s)
   777  			for l >= 1<<7 {
   778  				data[i] = uint8(uint64(l)&0x7f | 0x80)
   779  				l >>= 7
   780  				i++
   781  			}
   782  			data[i] = uint8(l)
   783  			i++
   784  			i += copy(data[i:], s)
   785  		}
   786  	}
   787  	if len(m.Payload) > 0 {
   788  		data[i] = 0x2a
   789  		i++
   790  		i = encodeVarintNetworkdb(data, i, uint64(len(m.Payload)))
   791  		i += copy(data[i:], m.Payload)
   792  	}
   793  	return i, nil
   794  }
   795  
   796  func (m *CompoundMessage) Marshal() (data []byte, err error) {
   797  	size := m.Size()
   798  	data = make([]byte, size)
   799  	n, err := m.MarshalTo(data)
   800  	if err != nil {
   801  		return nil, err
   802  	}
   803  	return data[:n], nil
   804  }
   805  
   806  func (m *CompoundMessage) MarshalTo(data []byte) (int, error) {
   807  	var i int
   808  	_ = i
   809  	var l int
   810  	_ = l
   811  	if len(m.Messages) > 0 {
   812  		for _, msg := range m.Messages {
   813  			data[i] = 0xa
   814  			i++
   815  			i = encodeVarintNetworkdb(data, i, uint64(msg.Size()))
   816  			n, err := msg.MarshalTo(data[i:])
   817  			if err != nil {
   818  				return 0, err
   819  			}
   820  			i += n
   821  		}
   822  	}
   823  	return i, nil
   824  }
   825  
   826  func (m *CompoundMessage_SimpleMessage) Marshal() (data []byte, err error) {
   827  	size := m.Size()
   828  	data = make([]byte, size)
   829  	n, err := m.MarshalTo(data)
   830  	if err != nil {
   831  		return nil, err
   832  	}
   833  	return data[:n], nil
   834  }
   835  
   836  func (m *CompoundMessage_SimpleMessage) MarshalTo(data []byte) (int, error) {
   837  	var i int
   838  	_ = i
   839  	var l int
   840  	_ = l
   841  	if len(m.Payload) > 0 {
   842  		data[i] = 0xa
   843  		i++
   844  		i = encodeVarintNetworkdb(data, i, uint64(len(m.Payload)))
   845  		i += copy(data[i:], m.Payload)
   846  	}
   847  	return i, nil
   848  }
   849  
   850  func encodeFixed64Networkdb(data []byte, offset int, v uint64) int {
   851  	data[offset] = uint8(v)
   852  	data[offset+1] = uint8(v >> 8)
   853  	data[offset+2] = uint8(v >> 16)
   854  	data[offset+3] = uint8(v >> 24)
   855  	data[offset+4] = uint8(v >> 32)
   856  	data[offset+5] = uint8(v >> 40)
   857  	data[offset+6] = uint8(v >> 48)
   858  	data[offset+7] = uint8(v >> 56)
   859  	return offset + 8
   860  }
   861  func encodeFixed32Networkdb(data []byte, offset int, v uint32) int {
   862  	data[offset] = uint8(v)
   863  	data[offset+1] = uint8(v >> 8)
   864  	data[offset+2] = uint8(v >> 16)
   865  	data[offset+3] = uint8(v >> 24)
   866  	return offset + 4
   867  }
   868  func encodeVarintNetworkdb(data []byte, offset int, v uint64) int {
   869  	for v >= 1<<7 {
   870  		data[offset] = uint8(v&0x7f | 0x80)
   871  		v >>= 7
   872  		offset++
   873  	}
   874  	data[offset] = uint8(v)
   875  	return offset + 1
   876  }
   877  func (m *GossipMessage) Size() (n int) {
   878  	var l int
   879  	_ = l
   880  	if m.Type != 0 {
   881  		n += 1 + sovNetworkdb(uint64(m.Type))
   882  	}
   883  	l = len(m.Data)
   884  	if l > 0 {
   885  		n += 1 + l + sovNetworkdb(uint64(l))
   886  	}
   887  	return n
   888  }
   889  
   890  func (m *NodeEvent) Size() (n int) {
   891  	var l int
   892  	_ = l
   893  	if m.Type != 0 {
   894  		n += 1 + sovNetworkdb(uint64(m.Type))
   895  	}
   896  	if m.LTime != 0 {
   897  		n += 1 + sovNetworkdb(uint64(m.LTime))
   898  	}
   899  	l = len(m.NodeName)
   900  	if l > 0 {
   901  		n += 1 + l + sovNetworkdb(uint64(l))
   902  	}
   903  	return n
   904  }
   905  
   906  func (m *NetworkEvent) Size() (n int) {
   907  	var l int
   908  	_ = l
   909  	if m.Type != 0 {
   910  		n += 1 + sovNetworkdb(uint64(m.Type))
   911  	}
   912  	if m.LTime != 0 {
   913  		n += 1 + sovNetworkdb(uint64(m.LTime))
   914  	}
   915  	l = len(m.NodeName)
   916  	if l > 0 {
   917  		n += 1 + l + sovNetworkdb(uint64(l))
   918  	}
   919  	l = len(m.NetworkID)
   920  	if l > 0 {
   921  		n += 1 + l + sovNetworkdb(uint64(l))
   922  	}
   923  	return n
   924  }
   925  
   926  func (m *NetworkEntry) Size() (n int) {
   927  	var l int
   928  	_ = l
   929  	l = len(m.NetworkID)
   930  	if l > 0 {
   931  		n += 1 + l + sovNetworkdb(uint64(l))
   932  	}
   933  	if m.LTime != 0 {
   934  		n += 1 + sovNetworkdb(uint64(m.LTime))
   935  	}
   936  	l = len(m.NodeName)
   937  	if l > 0 {
   938  		n += 1 + l + sovNetworkdb(uint64(l))
   939  	}
   940  	if m.Leaving {
   941  		n += 2
   942  	}
   943  	return n
   944  }
   945  
   946  func (m *NetworkPushPull) Size() (n int) {
   947  	var l int
   948  	_ = l
   949  	if m.LTime != 0 {
   950  		n += 1 + sovNetworkdb(uint64(m.LTime))
   951  	}
   952  	if len(m.Networks) > 0 {
   953  		for _, e := range m.Networks {
   954  			l = e.Size()
   955  			n += 1 + l + sovNetworkdb(uint64(l))
   956  		}
   957  	}
   958  	l = len(m.NodeName)
   959  	if l > 0 {
   960  		n += 1 + l + sovNetworkdb(uint64(l))
   961  	}
   962  	return n
   963  }
   964  
   965  func (m *TableEvent) Size() (n int) {
   966  	var l int
   967  	_ = l
   968  	if m.Type != 0 {
   969  		n += 1 + sovNetworkdb(uint64(m.Type))
   970  	}
   971  	if m.LTime != 0 {
   972  		n += 1 + sovNetworkdb(uint64(m.LTime))
   973  	}
   974  	l = len(m.NodeName)
   975  	if l > 0 {
   976  		n += 1 + l + sovNetworkdb(uint64(l))
   977  	}
   978  	l = len(m.NetworkID)
   979  	if l > 0 {
   980  		n += 1 + l + sovNetworkdb(uint64(l))
   981  	}
   982  	l = len(m.TableName)
   983  	if l > 0 {
   984  		n += 1 + l + sovNetworkdb(uint64(l))
   985  	}
   986  	l = len(m.Key)
   987  	if l > 0 {
   988  		n += 1 + l + sovNetworkdb(uint64(l))
   989  	}
   990  	l = len(m.Value)
   991  	if l > 0 {
   992  		n += 1 + l + sovNetworkdb(uint64(l))
   993  	}
   994  	return n
   995  }
   996  
   997  func (m *BulkSyncMessage) Size() (n int) {
   998  	var l int
   999  	_ = l
  1000  	if m.LTime != 0 {
  1001  		n += 1 + sovNetworkdb(uint64(m.LTime))
  1002  	}
  1003  	if m.Unsolicited {
  1004  		n += 2
  1005  	}
  1006  	l = len(m.NodeName)
  1007  	if l > 0 {
  1008  		n += 1 + l + sovNetworkdb(uint64(l))
  1009  	}
  1010  	if len(m.Networks) > 0 {
  1011  		for _, s := range m.Networks {
  1012  			l = len(s)
  1013  			n += 1 + l + sovNetworkdb(uint64(l))
  1014  		}
  1015  	}
  1016  	l = len(m.Payload)
  1017  	if l > 0 {
  1018  		n += 1 + l + sovNetworkdb(uint64(l))
  1019  	}
  1020  	return n
  1021  }
  1022  
  1023  func (m *CompoundMessage) Size() (n int) {
  1024  	var l int
  1025  	_ = l
  1026  	if len(m.Messages) > 0 {
  1027  		for _, e := range m.Messages {
  1028  			l = e.Size()
  1029  			n += 1 + l + sovNetworkdb(uint64(l))
  1030  		}
  1031  	}
  1032  	return n
  1033  }
  1034  
  1035  func (m *CompoundMessage_SimpleMessage) Size() (n int) {
  1036  	var l int
  1037  	_ = l
  1038  	l = len(m.Payload)
  1039  	if l > 0 {
  1040  		n += 1 + l + sovNetworkdb(uint64(l))
  1041  	}
  1042  	return n
  1043  }
  1044  
  1045  func sovNetworkdb(x uint64) (n int) {
  1046  	for {
  1047  		n++
  1048  		x >>= 7
  1049  		if x == 0 {
  1050  			break
  1051  		}
  1052  	}
  1053  	return n
  1054  }
  1055  func sozNetworkdb(x uint64) (n int) {
  1056  	return sovNetworkdb(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  1057  }
  1058  func (this *GossipMessage) String() string {
  1059  	if this == nil {
  1060  		return "nil"
  1061  	}
  1062  	s := strings.Join([]string{`&GossipMessage{`,
  1063  		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
  1064  		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
  1065  		`}`,
  1066  	}, "")
  1067  	return s
  1068  }
  1069  func (this *NodeEvent) String() string {
  1070  	if this == nil {
  1071  		return "nil"
  1072  	}
  1073  	s := strings.Join([]string{`&NodeEvent{`,
  1074  		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
  1075  		`LTime:` + fmt.Sprintf("%v", this.LTime) + `,`,
  1076  		`NodeName:` + fmt.Sprintf("%v", this.NodeName) + `,`,
  1077  		`}`,
  1078  	}, "")
  1079  	return s
  1080  }
  1081  func (this *NetworkEvent) String() string {
  1082  	if this == nil {
  1083  		return "nil"
  1084  	}
  1085  	s := strings.Join([]string{`&NetworkEvent{`,
  1086  		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
  1087  		`LTime:` + fmt.Sprintf("%v", this.LTime) + `,`,
  1088  		`NodeName:` + fmt.Sprintf("%v", this.NodeName) + `,`,
  1089  		`NetworkID:` + fmt.Sprintf("%v", this.NetworkID) + `,`,
  1090  		`}`,
  1091  	}, "")
  1092  	return s
  1093  }
  1094  func (this *NetworkEntry) String() string {
  1095  	if this == nil {
  1096  		return "nil"
  1097  	}
  1098  	s := strings.Join([]string{`&NetworkEntry{`,
  1099  		`NetworkID:` + fmt.Sprintf("%v", this.NetworkID) + `,`,
  1100  		`LTime:` + fmt.Sprintf("%v", this.LTime) + `,`,
  1101  		`NodeName:` + fmt.Sprintf("%v", this.NodeName) + `,`,
  1102  		`Leaving:` + fmt.Sprintf("%v", this.Leaving) + `,`,
  1103  		`}`,
  1104  	}, "")
  1105  	return s
  1106  }
  1107  func (this *NetworkPushPull) String() string {
  1108  	if this == nil {
  1109  		return "nil"
  1110  	}
  1111  	s := strings.Join([]string{`&NetworkPushPull{`,
  1112  		`LTime:` + fmt.Sprintf("%v", this.LTime) + `,`,
  1113  		`Networks:` + strings.Replace(fmt.Sprintf("%v", this.Networks), "NetworkEntry", "NetworkEntry", 1) + `,`,
  1114  		`NodeName:` + fmt.Sprintf("%v", this.NodeName) + `,`,
  1115  		`}`,
  1116  	}, "")
  1117  	return s
  1118  }
  1119  func (this *TableEvent) String() string {
  1120  	if this == nil {
  1121  		return "nil"
  1122  	}
  1123  	s := strings.Join([]string{`&TableEvent{`,
  1124  		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
  1125  		`LTime:` + fmt.Sprintf("%v", this.LTime) + `,`,
  1126  		`NodeName:` + fmt.Sprintf("%v", this.NodeName) + `,`,
  1127  		`NetworkID:` + fmt.Sprintf("%v", this.NetworkID) + `,`,
  1128  		`TableName:` + fmt.Sprintf("%v", this.TableName) + `,`,
  1129  		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
  1130  		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
  1131  		`}`,
  1132  	}, "")
  1133  	return s
  1134  }
  1135  func (this *BulkSyncMessage) String() string {
  1136  	if this == nil {
  1137  		return "nil"
  1138  	}
  1139  	s := strings.Join([]string{`&BulkSyncMessage{`,
  1140  		`LTime:` + fmt.Sprintf("%v", this.LTime) + `,`,
  1141  		`Unsolicited:` + fmt.Sprintf("%v", this.Unsolicited) + `,`,
  1142  		`NodeName:` + fmt.Sprintf("%v", this.NodeName) + `,`,
  1143  		`Networks:` + fmt.Sprintf("%v", this.Networks) + `,`,
  1144  		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
  1145  		`}`,
  1146  	}, "")
  1147  	return s
  1148  }
  1149  func (this *CompoundMessage) String() string {
  1150  	if this == nil {
  1151  		return "nil"
  1152  	}
  1153  	s := strings.Join([]string{`&CompoundMessage{`,
  1154  		`Messages:` + strings.Replace(fmt.Sprintf("%v", this.Messages), "CompoundMessage_SimpleMessage", "CompoundMessage_SimpleMessage", 1) + `,`,
  1155  		`}`,
  1156  	}, "")
  1157  	return s
  1158  }
  1159  func (this *CompoundMessage_SimpleMessage) String() string {
  1160  	if this == nil {
  1161  		return "nil"
  1162  	}
  1163  	s := strings.Join([]string{`&CompoundMessage_SimpleMessage{`,
  1164  		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
  1165  		`}`,
  1166  	}, "")
  1167  	return s
  1168  }
  1169  func valueToStringNetworkdb(v interface{}) string {
  1170  	rv := reflect.ValueOf(v)
  1171  	if rv.IsNil() {
  1172  		return "nil"
  1173  	}
  1174  	pv := reflect.Indirect(rv).Interface()
  1175  	return fmt.Sprintf("*%v", pv)
  1176  }
  1177  func (m *GossipMessage) Unmarshal(data []byte) error {
  1178  	l := len(data)
  1179  	iNdEx := 0
  1180  	for iNdEx < l {
  1181  		preIndex := iNdEx
  1182  		var wire uint64
  1183  		for shift := uint(0); ; shift += 7 {
  1184  			if shift >= 64 {
  1185  				return ErrIntOverflowNetworkdb
  1186  			}
  1187  			if iNdEx >= l {
  1188  				return io.ErrUnexpectedEOF
  1189  			}
  1190  			b := data[iNdEx]
  1191  			iNdEx++
  1192  			wire |= (uint64(b) & 0x7F) << shift
  1193  			if b < 0x80 {
  1194  				break
  1195  			}
  1196  		}
  1197  		fieldNum := int32(wire >> 3)
  1198  		wireType := int(wire & 0x7)
  1199  		if wireType == 4 {
  1200  			return fmt.Errorf("proto: GossipMessage: wiretype end group for non-group")
  1201  		}
  1202  		if fieldNum <= 0 {
  1203  			return fmt.Errorf("proto: GossipMessage: illegal tag %d (wire type %d)", fieldNum, wire)
  1204  		}
  1205  		switch fieldNum {
  1206  		case 1:
  1207  			if wireType != 0 {
  1208  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
  1209  			}
  1210  			m.Type = 0
  1211  			for shift := uint(0); ; shift += 7 {
  1212  				if shift >= 64 {
  1213  					return ErrIntOverflowNetworkdb
  1214  				}
  1215  				if iNdEx >= l {
  1216  					return io.ErrUnexpectedEOF
  1217  				}
  1218  				b := data[iNdEx]
  1219  				iNdEx++
  1220  				m.Type |= (MessageType(b) & 0x7F) << shift
  1221  				if b < 0x80 {
  1222  					break
  1223  				}
  1224  			}
  1225  		case 2:
  1226  			if wireType != 2 {
  1227  				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
  1228  			}
  1229  			var byteLen int
  1230  			for shift := uint(0); ; shift += 7 {
  1231  				if shift >= 64 {
  1232  					return ErrIntOverflowNetworkdb
  1233  				}
  1234  				if iNdEx >= l {
  1235  					return io.ErrUnexpectedEOF
  1236  				}
  1237  				b := data[iNdEx]
  1238  				iNdEx++
  1239  				byteLen |= (int(b) & 0x7F) << shift
  1240  				if b < 0x80 {
  1241  					break
  1242  				}
  1243  			}
  1244  			if byteLen < 0 {
  1245  				return ErrInvalidLengthNetworkdb
  1246  			}
  1247  			postIndex := iNdEx + byteLen
  1248  			if postIndex > l {
  1249  				return io.ErrUnexpectedEOF
  1250  			}
  1251  			m.Data = append(m.Data[:0], data[iNdEx:postIndex]...)
  1252  			if m.Data == nil {
  1253  				m.Data = []byte{}
  1254  			}
  1255  			iNdEx = postIndex
  1256  		default:
  1257  			iNdEx = preIndex
  1258  			skippy, err := skipNetworkdb(data[iNdEx:])
  1259  			if err != nil {
  1260  				return err
  1261  			}
  1262  			if skippy < 0 {
  1263  				return ErrInvalidLengthNetworkdb
  1264  			}
  1265  			if (iNdEx + skippy) > l {
  1266  				return io.ErrUnexpectedEOF
  1267  			}
  1268  			iNdEx += skippy
  1269  		}
  1270  	}
  1271  
  1272  	if iNdEx > l {
  1273  		return io.ErrUnexpectedEOF
  1274  	}
  1275  	return nil
  1276  }
  1277  func (m *NodeEvent) Unmarshal(data []byte) error {
  1278  	l := len(data)
  1279  	iNdEx := 0
  1280  	for iNdEx < l {
  1281  		preIndex := iNdEx
  1282  		var wire uint64
  1283  		for shift := uint(0); ; shift += 7 {
  1284  			if shift >= 64 {
  1285  				return ErrIntOverflowNetworkdb
  1286  			}
  1287  			if iNdEx >= l {
  1288  				return io.ErrUnexpectedEOF
  1289  			}
  1290  			b := data[iNdEx]
  1291  			iNdEx++
  1292  			wire |= (uint64(b) & 0x7F) << shift
  1293  			if b < 0x80 {
  1294  				break
  1295  			}
  1296  		}
  1297  		fieldNum := int32(wire >> 3)
  1298  		wireType := int(wire & 0x7)
  1299  		if wireType == 4 {
  1300  			return fmt.Errorf("proto: NodeEvent: wiretype end group for non-group")
  1301  		}
  1302  		if fieldNum <= 0 {
  1303  			return fmt.Errorf("proto: NodeEvent: illegal tag %d (wire type %d)", fieldNum, wire)
  1304  		}
  1305  		switch fieldNum {
  1306  		case 1:
  1307  			if wireType != 0 {
  1308  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
  1309  			}
  1310  			m.Type = 0
  1311  			for shift := uint(0); ; shift += 7 {
  1312  				if shift >= 64 {
  1313  					return ErrIntOverflowNetworkdb
  1314  				}
  1315  				if iNdEx >= l {
  1316  					return io.ErrUnexpectedEOF
  1317  				}
  1318  				b := data[iNdEx]
  1319  				iNdEx++
  1320  				m.Type |= (NodeEvent_Type(b) & 0x7F) << shift
  1321  				if b < 0x80 {
  1322  					break
  1323  				}
  1324  			}
  1325  		case 2:
  1326  			if wireType != 0 {
  1327  				return fmt.Errorf("proto: wrong wireType = %d for field LTime", wireType)
  1328  			}
  1329  			m.LTime = 0
  1330  			for shift := uint(0); ; shift += 7 {
  1331  				if shift >= 64 {
  1332  					return ErrIntOverflowNetworkdb
  1333  				}
  1334  				if iNdEx >= l {
  1335  					return io.ErrUnexpectedEOF
  1336  				}
  1337  				b := data[iNdEx]
  1338  				iNdEx++
  1339  				m.LTime |= (github_com_hashicorp_serf_serf.LamportTime(b) & 0x7F) << shift
  1340  				if b < 0x80 {
  1341  					break
  1342  				}
  1343  			}
  1344  		case 3:
  1345  			if wireType != 2 {
  1346  				return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
  1347  			}
  1348  			var stringLen uint64
  1349  			for shift := uint(0); ; shift += 7 {
  1350  				if shift >= 64 {
  1351  					return ErrIntOverflowNetworkdb
  1352  				}
  1353  				if iNdEx >= l {
  1354  					return io.ErrUnexpectedEOF
  1355  				}
  1356  				b := data[iNdEx]
  1357  				iNdEx++
  1358  				stringLen |= (uint64(b) & 0x7F) << shift
  1359  				if b < 0x80 {
  1360  					break
  1361  				}
  1362  			}
  1363  			intStringLen := int(stringLen)
  1364  			if intStringLen < 0 {
  1365  				return ErrInvalidLengthNetworkdb
  1366  			}
  1367  			postIndex := iNdEx + intStringLen
  1368  			if postIndex > l {
  1369  				return io.ErrUnexpectedEOF
  1370  			}
  1371  			m.NodeName = string(data[iNdEx:postIndex])
  1372  			iNdEx = postIndex
  1373  		default:
  1374  			iNdEx = preIndex
  1375  			skippy, err := skipNetworkdb(data[iNdEx:])
  1376  			if err != nil {
  1377  				return err
  1378  			}
  1379  			if skippy < 0 {
  1380  				return ErrInvalidLengthNetworkdb
  1381  			}
  1382  			if (iNdEx + skippy) > l {
  1383  				return io.ErrUnexpectedEOF
  1384  			}
  1385  			iNdEx += skippy
  1386  		}
  1387  	}
  1388  
  1389  	if iNdEx > l {
  1390  		return io.ErrUnexpectedEOF
  1391  	}
  1392  	return nil
  1393  }
  1394  func (m *NetworkEvent) Unmarshal(data []byte) error {
  1395  	l := len(data)
  1396  	iNdEx := 0
  1397  	for iNdEx < l {
  1398  		preIndex := iNdEx
  1399  		var wire uint64
  1400  		for shift := uint(0); ; shift += 7 {
  1401  			if shift >= 64 {
  1402  				return ErrIntOverflowNetworkdb
  1403  			}
  1404  			if iNdEx >= l {
  1405  				return io.ErrUnexpectedEOF
  1406  			}
  1407  			b := data[iNdEx]
  1408  			iNdEx++
  1409  			wire |= (uint64(b) & 0x7F) << shift
  1410  			if b < 0x80 {
  1411  				break
  1412  			}
  1413  		}
  1414  		fieldNum := int32(wire >> 3)
  1415  		wireType := int(wire & 0x7)
  1416  		if wireType == 4 {
  1417  			return fmt.Errorf("proto: NetworkEvent: wiretype end group for non-group")
  1418  		}
  1419  		if fieldNum <= 0 {
  1420  			return fmt.Errorf("proto: NetworkEvent: illegal tag %d (wire type %d)", fieldNum, wire)
  1421  		}
  1422  		switch fieldNum {
  1423  		case 1:
  1424  			if wireType != 0 {
  1425  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
  1426  			}
  1427  			m.Type = 0
  1428  			for shift := uint(0); ; shift += 7 {
  1429  				if shift >= 64 {
  1430  					return ErrIntOverflowNetworkdb
  1431  				}
  1432  				if iNdEx >= l {
  1433  					return io.ErrUnexpectedEOF
  1434  				}
  1435  				b := data[iNdEx]
  1436  				iNdEx++
  1437  				m.Type |= (NetworkEvent_Type(b) & 0x7F) << shift
  1438  				if b < 0x80 {
  1439  					break
  1440  				}
  1441  			}
  1442  		case 2:
  1443  			if wireType != 0 {
  1444  				return fmt.Errorf("proto: wrong wireType = %d for field LTime", wireType)
  1445  			}
  1446  			m.LTime = 0
  1447  			for shift := uint(0); ; shift += 7 {
  1448  				if shift >= 64 {
  1449  					return ErrIntOverflowNetworkdb
  1450  				}
  1451  				if iNdEx >= l {
  1452  					return io.ErrUnexpectedEOF
  1453  				}
  1454  				b := data[iNdEx]
  1455  				iNdEx++
  1456  				m.LTime |= (github_com_hashicorp_serf_serf.LamportTime(b) & 0x7F) << shift
  1457  				if b < 0x80 {
  1458  					break
  1459  				}
  1460  			}
  1461  		case 3:
  1462  			if wireType != 2 {
  1463  				return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
  1464  			}
  1465  			var stringLen uint64
  1466  			for shift := uint(0); ; shift += 7 {
  1467  				if shift >= 64 {
  1468  					return ErrIntOverflowNetworkdb
  1469  				}
  1470  				if iNdEx >= l {
  1471  					return io.ErrUnexpectedEOF
  1472  				}
  1473  				b := data[iNdEx]
  1474  				iNdEx++
  1475  				stringLen |= (uint64(b) & 0x7F) << shift
  1476  				if b < 0x80 {
  1477  					break
  1478  				}
  1479  			}
  1480  			intStringLen := int(stringLen)
  1481  			if intStringLen < 0 {
  1482  				return ErrInvalidLengthNetworkdb
  1483  			}
  1484  			postIndex := iNdEx + intStringLen
  1485  			if postIndex > l {
  1486  				return io.ErrUnexpectedEOF
  1487  			}
  1488  			m.NodeName = string(data[iNdEx:postIndex])
  1489  			iNdEx = postIndex
  1490  		case 4:
  1491  			if wireType != 2 {
  1492  				return fmt.Errorf("proto: wrong wireType = %d for field NetworkID", wireType)
  1493  			}
  1494  			var stringLen uint64
  1495  			for shift := uint(0); ; shift += 7 {
  1496  				if shift >= 64 {
  1497  					return ErrIntOverflowNetworkdb
  1498  				}
  1499  				if iNdEx >= l {
  1500  					return io.ErrUnexpectedEOF
  1501  				}
  1502  				b := data[iNdEx]
  1503  				iNdEx++
  1504  				stringLen |= (uint64(b) & 0x7F) << shift
  1505  				if b < 0x80 {
  1506  					break
  1507  				}
  1508  			}
  1509  			intStringLen := int(stringLen)
  1510  			if intStringLen < 0 {
  1511  				return ErrInvalidLengthNetworkdb
  1512  			}
  1513  			postIndex := iNdEx + intStringLen
  1514  			if postIndex > l {
  1515  				return io.ErrUnexpectedEOF
  1516  			}
  1517  			m.NetworkID = string(data[iNdEx:postIndex])
  1518  			iNdEx = postIndex
  1519  		default:
  1520  			iNdEx = preIndex
  1521  			skippy, err := skipNetworkdb(data[iNdEx:])
  1522  			if err != nil {
  1523  				return err
  1524  			}
  1525  			if skippy < 0 {
  1526  				return ErrInvalidLengthNetworkdb
  1527  			}
  1528  			if (iNdEx + skippy) > l {
  1529  				return io.ErrUnexpectedEOF
  1530  			}
  1531  			iNdEx += skippy
  1532  		}
  1533  	}
  1534  
  1535  	if iNdEx > l {
  1536  		return io.ErrUnexpectedEOF
  1537  	}
  1538  	return nil
  1539  }
  1540  func (m *NetworkEntry) Unmarshal(data []byte) error {
  1541  	l := len(data)
  1542  	iNdEx := 0
  1543  	for iNdEx < l {
  1544  		preIndex := iNdEx
  1545  		var wire uint64
  1546  		for shift := uint(0); ; shift += 7 {
  1547  			if shift >= 64 {
  1548  				return ErrIntOverflowNetworkdb
  1549  			}
  1550  			if iNdEx >= l {
  1551  				return io.ErrUnexpectedEOF
  1552  			}
  1553  			b := data[iNdEx]
  1554  			iNdEx++
  1555  			wire |= (uint64(b) & 0x7F) << shift
  1556  			if b < 0x80 {
  1557  				break
  1558  			}
  1559  		}
  1560  		fieldNum := int32(wire >> 3)
  1561  		wireType := int(wire & 0x7)
  1562  		if wireType == 4 {
  1563  			return fmt.Errorf("proto: NetworkEntry: wiretype end group for non-group")
  1564  		}
  1565  		if fieldNum <= 0 {
  1566  			return fmt.Errorf("proto: NetworkEntry: illegal tag %d (wire type %d)", fieldNum, wire)
  1567  		}
  1568  		switch fieldNum {
  1569  		case 1:
  1570  			if wireType != 2 {
  1571  				return fmt.Errorf("proto: wrong wireType = %d for field NetworkID", wireType)
  1572  			}
  1573  			var stringLen uint64
  1574  			for shift := uint(0); ; shift += 7 {
  1575  				if shift >= 64 {
  1576  					return ErrIntOverflowNetworkdb
  1577  				}
  1578  				if iNdEx >= l {
  1579  					return io.ErrUnexpectedEOF
  1580  				}
  1581  				b := data[iNdEx]
  1582  				iNdEx++
  1583  				stringLen |= (uint64(b) & 0x7F) << shift
  1584  				if b < 0x80 {
  1585  					break
  1586  				}
  1587  			}
  1588  			intStringLen := int(stringLen)
  1589  			if intStringLen < 0 {
  1590  				return ErrInvalidLengthNetworkdb
  1591  			}
  1592  			postIndex := iNdEx + intStringLen
  1593  			if postIndex > l {
  1594  				return io.ErrUnexpectedEOF
  1595  			}
  1596  			m.NetworkID = string(data[iNdEx:postIndex])
  1597  			iNdEx = postIndex
  1598  		case 2:
  1599  			if wireType != 0 {
  1600  				return fmt.Errorf("proto: wrong wireType = %d for field LTime", wireType)
  1601  			}
  1602  			m.LTime = 0
  1603  			for shift := uint(0); ; shift += 7 {
  1604  				if shift >= 64 {
  1605  					return ErrIntOverflowNetworkdb
  1606  				}
  1607  				if iNdEx >= l {
  1608  					return io.ErrUnexpectedEOF
  1609  				}
  1610  				b := data[iNdEx]
  1611  				iNdEx++
  1612  				m.LTime |= (github_com_hashicorp_serf_serf.LamportTime(b) & 0x7F) << shift
  1613  				if b < 0x80 {
  1614  					break
  1615  				}
  1616  			}
  1617  		case 3:
  1618  			if wireType != 2 {
  1619  				return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
  1620  			}
  1621  			var stringLen uint64
  1622  			for shift := uint(0); ; shift += 7 {
  1623  				if shift >= 64 {
  1624  					return ErrIntOverflowNetworkdb
  1625  				}
  1626  				if iNdEx >= l {
  1627  					return io.ErrUnexpectedEOF
  1628  				}
  1629  				b := data[iNdEx]
  1630  				iNdEx++
  1631  				stringLen |= (uint64(b) & 0x7F) << shift
  1632  				if b < 0x80 {
  1633  					break
  1634  				}
  1635  			}
  1636  			intStringLen := int(stringLen)
  1637  			if intStringLen < 0 {
  1638  				return ErrInvalidLengthNetworkdb
  1639  			}
  1640  			postIndex := iNdEx + intStringLen
  1641  			if postIndex > l {
  1642  				return io.ErrUnexpectedEOF
  1643  			}
  1644  			m.NodeName = string(data[iNdEx:postIndex])
  1645  			iNdEx = postIndex
  1646  		case 4:
  1647  			if wireType != 0 {
  1648  				return fmt.Errorf("proto: wrong wireType = %d for field Leaving", wireType)
  1649  			}
  1650  			var v int
  1651  			for shift := uint(0); ; shift += 7 {
  1652  				if shift >= 64 {
  1653  					return ErrIntOverflowNetworkdb
  1654  				}
  1655  				if iNdEx >= l {
  1656  					return io.ErrUnexpectedEOF
  1657  				}
  1658  				b := data[iNdEx]
  1659  				iNdEx++
  1660  				v |= (int(b) & 0x7F) << shift
  1661  				if b < 0x80 {
  1662  					break
  1663  				}
  1664  			}
  1665  			m.Leaving = bool(v != 0)
  1666  		default:
  1667  			iNdEx = preIndex
  1668  			skippy, err := skipNetworkdb(data[iNdEx:])
  1669  			if err != nil {
  1670  				return err
  1671  			}
  1672  			if skippy < 0 {
  1673  				return ErrInvalidLengthNetworkdb
  1674  			}
  1675  			if (iNdEx + skippy) > l {
  1676  				return io.ErrUnexpectedEOF
  1677  			}
  1678  			iNdEx += skippy
  1679  		}
  1680  	}
  1681  
  1682  	if iNdEx > l {
  1683  		return io.ErrUnexpectedEOF
  1684  	}
  1685  	return nil
  1686  }
  1687  func (m *NetworkPushPull) Unmarshal(data []byte) error {
  1688  	l := len(data)
  1689  	iNdEx := 0
  1690  	for iNdEx < l {
  1691  		preIndex := iNdEx
  1692  		var wire uint64
  1693  		for shift := uint(0); ; shift += 7 {
  1694  			if shift >= 64 {
  1695  				return ErrIntOverflowNetworkdb
  1696  			}
  1697  			if iNdEx >= l {
  1698  				return io.ErrUnexpectedEOF
  1699  			}
  1700  			b := data[iNdEx]
  1701  			iNdEx++
  1702  			wire |= (uint64(b) & 0x7F) << shift
  1703  			if b < 0x80 {
  1704  				break
  1705  			}
  1706  		}
  1707  		fieldNum := int32(wire >> 3)
  1708  		wireType := int(wire & 0x7)
  1709  		if wireType == 4 {
  1710  			return fmt.Errorf("proto: NetworkPushPull: wiretype end group for non-group")
  1711  		}
  1712  		if fieldNum <= 0 {
  1713  			return fmt.Errorf("proto: NetworkPushPull: illegal tag %d (wire type %d)", fieldNum, wire)
  1714  		}
  1715  		switch fieldNum {
  1716  		case 1:
  1717  			if wireType != 0 {
  1718  				return fmt.Errorf("proto: wrong wireType = %d for field LTime", wireType)
  1719  			}
  1720  			m.LTime = 0
  1721  			for shift := uint(0); ; shift += 7 {
  1722  				if shift >= 64 {
  1723  					return ErrIntOverflowNetworkdb
  1724  				}
  1725  				if iNdEx >= l {
  1726  					return io.ErrUnexpectedEOF
  1727  				}
  1728  				b := data[iNdEx]
  1729  				iNdEx++
  1730  				m.LTime |= (github_com_hashicorp_serf_serf.LamportTime(b) & 0x7F) << shift
  1731  				if b < 0x80 {
  1732  					break
  1733  				}
  1734  			}
  1735  		case 2:
  1736  			if wireType != 2 {
  1737  				return fmt.Errorf("proto: wrong wireType = %d for field Networks", wireType)
  1738  			}
  1739  			var msglen int
  1740  			for shift := uint(0); ; shift += 7 {
  1741  				if shift >= 64 {
  1742  					return ErrIntOverflowNetworkdb
  1743  				}
  1744  				if iNdEx >= l {
  1745  					return io.ErrUnexpectedEOF
  1746  				}
  1747  				b := data[iNdEx]
  1748  				iNdEx++
  1749  				msglen |= (int(b) & 0x7F) << shift
  1750  				if b < 0x80 {
  1751  					break
  1752  				}
  1753  			}
  1754  			if msglen < 0 {
  1755  				return ErrInvalidLengthNetworkdb
  1756  			}
  1757  			postIndex := iNdEx + msglen
  1758  			if postIndex > l {
  1759  				return io.ErrUnexpectedEOF
  1760  			}
  1761  			m.Networks = append(m.Networks, &NetworkEntry{})
  1762  			if err := m.Networks[len(m.Networks)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
  1763  				return err
  1764  			}
  1765  			iNdEx = postIndex
  1766  		case 3:
  1767  			if wireType != 2 {
  1768  				return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
  1769  			}
  1770  			var stringLen uint64
  1771  			for shift := uint(0); ; shift += 7 {
  1772  				if shift >= 64 {
  1773  					return ErrIntOverflowNetworkdb
  1774  				}
  1775  				if iNdEx >= l {
  1776  					return io.ErrUnexpectedEOF
  1777  				}
  1778  				b := data[iNdEx]
  1779  				iNdEx++
  1780  				stringLen |= (uint64(b) & 0x7F) << shift
  1781  				if b < 0x80 {
  1782  					break
  1783  				}
  1784  			}
  1785  			intStringLen := int(stringLen)
  1786  			if intStringLen < 0 {
  1787  				return ErrInvalidLengthNetworkdb
  1788  			}
  1789  			postIndex := iNdEx + intStringLen
  1790  			if postIndex > l {
  1791  				return io.ErrUnexpectedEOF
  1792  			}
  1793  			m.NodeName = string(data[iNdEx:postIndex])
  1794  			iNdEx = postIndex
  1795  		default:
  1796  			iNdEx = preIndex
  1797  			skippy, err := skipNetworkdb(data[iNdEx:])
  1798  			if err != nil {
  1799  				return err
  1800  			}
  1801  			if skippy < 0 {
  1802  				return ErrInvalidLengthNetworkdb
  1803  			}
  1804  			if (iNdEx + skippy) > l {
  1805  				return io.ErrUnexpectedEOF
  1806  			}
  1807  			iNdEx += skippy
  1808  		}
  1809  	}
  1810  
  1811  	if iNdEx > l {
  1812  		return io.ErrUnexpectedEOF
  1813  	}
  1814  	return nil
  1815  }
  1816  func (m *TableEvent) Unmarshal(data []byte) error {
  1817  	l := len(data)
  1818  	iNdEx := 0
  1819  	for iNdEx < l {
  1820  		preIndex := iNdEx
  1821  		var wire uint64
  1822  		for shift := uint(0); ; shift += 7 {
  1823  			if shift >= 64 {
  1824  				return ErrIntOverflowNetworkdb
  1825  			}
  1826  			if iNdEx >= l {
  1827  				return io.ErrUnexpectedEOF
  1828  			}
  1829  			b := data[iNdEx]
  1830  			iNdEx++
  1831  			wire |= (uint64(b) & 0x7F) << shift
  1832  			if b < 0x80 {
  1833  				break
  1834  			}
  1835  		}
  1836  		fieldNum := int32(wire >> 3)
  1837  		wireType := int(wire & 0x7)
  1838  		if wireType == 4 {
  1839  			return fmt.Errorf("proto: TableEvent: wiretype end group for non-group")
  1840  		}
  1841  		if fieldNum <= 0 {
  1842  			return fmt.Errorf("proto: TableEvent: illegal tag %d (wire type %d)", fieldNum, wire)
  1843  		}
  1844  		switch fieldNum {
  1845  		case 1:
  1846  			if wireType != 0 {
  1847  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
  1848  			}
  1849  			m.Type = 0
  1850  			for shift := uint(0); ; shift += 7 {
  1851  				if shift >= 64 {
  1852  					return ErrIntOverflowNetworkdb
  1853  				}
  1854  				if iNdEx >= l {
  1855  					return io.ErrUnexpectedEOF
  1856  				}
  1857  				b := data[iNdEx]
  1858  				iNdEx++
  1859  				m.Type |= (TableEvent_Type(b) & 0x7F) << shift
  1860  				if b < 0x80 {
  1861  					break
  1862  				}
  1863  			}
  1864  		case 2:
  1865  			if wireType != 0 {
  1866  				return fmt.Errorf("proto: wrong wireType = %d for field LTime", wireType)
  1867  			}
  1868  			m.LTime = 0
  1869  			for shift := uint(0); ; shift += 7 {
  1870  				if shift >= 64 {
  1871  					return ErrIntOverflowNetworkdb
  1872  				}
  1873  				if iNdEx >= l {
  1874  					return io.ErrUnexpectedEOF
  1875  				}
  1876  				b := data[iNdEx]
  1877  				iNdEx++
  1878  				m.LTime |= (github_com_hashicorp_serf_serf.LamportTime(b) & 0x7F) << shift
  1879  				if b < 0x80 {
  1880  					break
  1881  				}
  1882  			}
  1883  		case 3:
  1884  			if wireType != 2 {
  1885  				return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
  1886  			}
  1887  			var stringLen uint64
  1888  			for shift := uint(0); ; shift += 7 {
  1889  				if shift >= 64 {
  1890  					return ErrIntOverflowNetworkdb
  1891  				}
  1892  				if iNdEx >= l {
  1893  					return io.ErrUnexpectedEOF
  1894  				}
  1895  				b := data[iNdEx]
  1896  				iNdEx++
  1897  				stringLen |= (uint64(b) & 0x7F) << shift
  1898  				if b < 0x80 {
  1899  					break
  1900  				}
  1901  			}
  1902  			intStringLen := int(stringLen)
  1903  			if intStringLen < 0 {
  1904  				return ErrInvalidLengthNetworkdb
  1905  			}
  1906  			postIndex := iNdEx + intStringLen
  1907  			if postIndex > l {
  1908  				return io.ErrUnexpectedEOF
  1909  			}
  1910  			m.NodeName = string(data[iNdEx:postIndex])
  1911  			iNdEx = postIndex
  1912  		case 4:
  1913  			if wireType != 2 {
  1914  				return fmt.Errorf("proto: wrong wireType = %d for field NetworkID", wireType)
  1915  			}
  1916  			var stringLen uint64
  1917  			for shift := uint(0); ; shift += 7 {
  1918  				if shift >= 64 {
  1919  					return ErrIntOverflowNetworkdb
  1920  				}
  1921  				if iNdEx >= l {
  1922  					return io.ErrUnexpectedEOF
  1923  				}
  1924  				b := data[iNdEx]
  1925  				iNdEx++
  1926  				stringLen |= (uint64(b) & 0x7F) << shift
  1927  				if b < 0x80 {
  1928  					break
  1929  				}
  1930  			}
  1931  			intStringLen := int(stringLen)
  1932  			if intStringLen < 0 {
  1933  				return ErrInvalidLengthNetworkdb
  1934  			}
  1935  			postIndex := iNdEx + intStringLen
  1936  			if postIndex > l {
  1937  				return io.ErrUnexpectedEOF
  1938  			}
  1939  			m.NetworkID = string(data[iNdEx:postIndex])
  1940  			iNdEx = postIndex
  1941  		case 5:
  1942  			if wireType != 2 {
  1943  				return fmt.Errorf("proto: wrong wireType = %d for field TableName", wireType)
  1944  			}
  1945  			var stringLen uint64
  1946  			for shift := uint(0); ; shift += 7 {
  1947  				if shift >= 64 {
  1948  					return ErrIntOverflowNetworkdb
  1949  				}
  1950  				if iNdEx >= l {
  1951  					return io.ErrUnexpectedEOF
  1952  				}
  1953  				b := data[iNdEx]
  1954  				iNdEx++
  1955  				stringLen |= (uint64(b) & 0x7F) << shift
  1956  				if b < 0x80 {
  1957  					break
  1958  				}
  1959  			}
  1960  			intStringLen := int(stringLen)
  1961  			if intStringLen < 0 {
  1962  				return ErrInvalidLengthNetworkdb
  1963  			}
  1964  			postIndex := iNdEx + intStringLen
  1965  			if postIndex > l {
  1966  				return io.ErrUnexpectedEOF
  1967  			}
  1968  			m.TableName = string(data[iNdEx:postIndex])
  1969  			iNdEx = postIndex
  1970  		case 6:
  1971  			if wireType != 2 {
  1972  				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
  1973  			}
  1974  			var stringLen uint64
  1975  			for shift := uint(0); ; shift += 7 {
  1976  				if shift >= 64 {
  1977  					return ErrIntOverflowNetworkdb
  1978  				}
  1979  				if iNdEx >= l {
  1980  					return io.ErrUnexpectedEOF
  1981  				}
  1982  				b := data[iNdEx]
  1983  				iNdEx++
  1984  				stringLen |= (uint64(b) & 0x7F) << shift
  1985  				if b < 0x80 {
  1986  					break
  1987  				}
  1988  			}
  1989  			intStringLen := int(stringLen)
  1990  			if intStringLen < 0 {
  1991  				return ErrInvalidLengthNetworkdb
  1992  			}
  1993  			postIndex := iNdEx + intStringLen
  1994  			if postIndex > l {
  1995  				return io.ErrUnexpectedEOF
  1996  			}
  1997  			m.Key = string(data[iNdEx:postIndex])
  1998  			iNdEx = postIndex
  1999  		case 7:
  2000  			if wireType != 2 {
  2001  				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
  2002  			}
  2003  			var byteLen int
  2004  			for shift := uint(0); ; shift += 7 {
  2005  				if shift >= 64 {
  2006  					return ErrIntOverflowNetworkdb
  2007  				}
  2008  				if iNdEx >= l {
  2009  					return io.ErrUnexpectedEOF
  2010  				}
  2011  				b := data[iNdEx]
  2012  				iNdEx++
  2013  				byteLen |= (int(b) & 0x7F) << shift
  2014  				if b < 0x80 {
  2015  					break
  2016  				}
  2017  			}
  2018  			if byteLen < 0 {
  2019  				return ErrInvalidLengthNetworkdb
  2020  			}
  2021  			postIndex := iNdEx + byteLen
  2022  			if postIndex > l {
  2023  				return io.ErrUnexpectedEOF
  2024  			}
  2025  			m.Value = append(m.Value[:0], data[iNdEx:postIndex]...)
  2026  			if m.Value == nil {
  2027  				m.Value = []byte{}
  2028  			}
  2029  			iNdEx = postIndex
  2030  		default:
  2031  			iNdEx = preIndex
  2032  			skippy, err := skipNetworkdb(data[iNdEx:])
  2033  			if err != nil {
  2034  				return err
  2035  			}
  2036  			if skippy < 0 {
  2037  				return ErrInvalidLengthNetworkdb
  2038  			}
  2039  			if (iNdEx + skippy) > l {
  2040  				return io.ErrUnexpectedEOF
  2041  			}
  2042  			iNdEx += skippy
  2043  		}
  2044  	}
  2045  
  2046  	if iNdEx > l {
  2047  		return io.ErrUnexpectedEOF
  2048  	}
  2049  	return nil
  2050  }
  2051  func (m *BulkSyncMessage) Unmarshal(data []byte) error {
  2052  	l := len(data)
  2053  	iNdEx := 0
  2054  	for iNdEx < l {
  2055  		preIndex := iNdEx
  2056  		var wire uint64
  2057  		for shift := uint(0); ; shift += 7 {
  2058  			if shift >= 64 {
  2059  				return ErrIntOverflowNetworkdb
  2060  			}
  2061  			if iNdEx >= l {
  2062  				return io.ErrUnexpectedEOF
  2063  			}
  2064  			b := data[iNdEx]
  2065  			iNdEx++
  2066  			wire |= (uint64(b) & 0x7F) << shift
  2067  			if b < 0x80 {
  2068  				break
  2069  			}
  2070  		}
  2071  		fieldNum := int32(wire >> 3)
  2072  		wireType := int(wire & 0x7)
  2073  		if wireType == 4 {
  2074  			return fmt.Errorf("proto: BulkSyncMessage: wiretype end group for non-group")
  2075  		}
  2076  		if fieldNum <= 0 {
  2077  			return fmt.Errorf("proto: BulkSyncMessage: illegal tag %d (wire type %d)", fieldNum, wire)
  2078  		}
  2079  		switch fieldNum {
  2080  		case 1:
  2081  			if wireType != 0 {
  2082  				return fmt.Errorf("proto: wrong wireType = %d for field LTime", wireType)
  2083  			}
  2084  			m.LTime = 0
  2085  			for shift := uint(0); ; shift += 7 {
  2086  				if shift >= 64 {
  2087  					return ErrIntOverflowNetworkdb
  2088  				}
  2089  				if iNdEx >= l {
  2090  					return io.ErrUnexpectedEOF
  2091  				}
  2092  				b := data[iNdEx]
  2093  				iNdEx++
  2094  				m.LTime |= (github_com_hashicorp_serf_serf.LamportTime(b) & 0x7F) << shift
  2095  				if b < 0x80 {
  2096  					break
  2097  				}
  2098  			}
  2099  		case 2:
  2100  			if wireType != 0 {
  2101  				return fmt.Errorf("proto: wrong wireType = %d for field Unsolicited", wireType)
  2102  			}
  2103  			var v int
  2104  			for shift := uint(0); ; shift += 7 {
  2105  				if shift >= 64 {
  2106  					return ErrIntOverflowNetworkdb
  2107  				}
  2108  				if iNdEx >= l {
  2109  					return io.ErrUnexpectedEOF
  2110  				}
  2111  				b := data[iNdEx]
  2112  				iNdEx++
  2113  				v |= (int(b) & 0x7F) << shift
  2114  				if b < 0x80 {
  2115  					break
  2116  				}
  2117  			}
  2118  			m.Unsolicited = bool(v != 0)
  2119  		case 3:
  2120  			if wireType != 2 {
  2121  				return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
  2122  			}
  2123  			var stringLen uint64
  2124  			for shift := uint(0); ; shift += 7 {
  2125  				if shift >= 64 {
  2126  					return ErrIntOverflowNetworkdb
  2127  				}
  2128  				if iNdEx >= l {
  2129  					return io.ErrUnexpectedEOF
  2130  				}
  2131  				b := data[iNdEx]
  2132  				iNdEx++
  2133  				stringLen |= (uint64(b) & 0x7F) << shift
  2134  				if b < 0x80 {
  2135  					break
  2136  				}
  2137  			}
  2138  			intStringLen := int(stringLen)
  2139  			if intStringLen < 0 {
  2140  				return ErrInvalidLengthNetworkdb
  2141  			}
  2142  			postIndex := iNdEx + intStringLen
  2143  			if postIndex > l {
  2144  				return io.ErrUnexpectedEOF
  2145  			}
  2146  			m.NodeName = string(data[iNdEx:postIndex])
  2147  			iNdEx = postIndex
  2148  		case 4:
  2149  			if wireType != 2 {
  2150  				return fmt.Errorf("proto: wrong wireType = %d for field Networks", wireType)
  2151  			}
  2152  			var stringLen uint64
  2153  			for shift := uint(0); ; shift += 7 {
  2154  				if shift >= 64 {
  2155  					return ErrIntOverflowNetworkdb
  2156  				}
  2157  				if iNdEx >= l {
  2158  					return io.ErrUnexpectedEOF
  2159  				}
  2160  				b := data[iNdEx]
  2161  				iNdEx++
  2162  				stringLen |= (uint64(b) & 0x7F) << shift
  2163  				if b < 0x80 {
  2164  					break
  2165  				}
  2166  			}
  2167  			intStringLen := int(stringLen)
  2168  			if intStringLen < 0 {
  2169  				return ErrInvalidLengthNetworkdb
  2170  			}
  2171  			postIndex := iNdEx + intStringLen
  2172  			if postIndex > l {
  2173  				return io.ErrUnexpectedEOF
  2174  			}
  2175  			m.Networks = append(m.Networks, string(data[iNdEx:postIndex]))
  2176  			iNdEx = postIndex
  2177  		case 5:
  2178  			if wireType != 2 {
  2179  				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
  2180  			}
  2181  			var byteLen int
  2182  			for shift := uint(0); ; shift += 7 {
  2183  				if shift >= 64 {
  2184  					return ErrIntOverflowNetworkdb
  2185  				}
  2186  				if iNdEx >= l {
  2187  					return io.ErrUnexpectedEOF
  2188  				}
  2189  				b := data[iNdEx]
  2190  				iNdEx++
  2191  				byteLen |= (int(b) & 0x7F) << shift
  2192  				if b < 0x80 {
  2193  					break
  2194  				}
  2195  			}
  2196  			if byteLen < 0 {
  2197  				return ErrInvalidLengthNetworkdb
  2198  			}
  2199  			postIndex := iNdEx + byteLen
  2200  			if postIndex > l {
  2201  				return io.ErrUnexpectedEOF
  2202  			}
  2203  			m.Payload = append(m.Payload[:0], data[iNdEx:postIndex]...)
  2204  			if m.Payload == nil {
  2205  				m.Payload = []byte{}
  2206  			}
  2207  			iNdEx = postIndex
  2208  		default:
  2209  			iNdEx = preIndex
  2210  			skippy, err := skipNetworkdb(data[iNdEx:])
  2211  			if err != nil {
  2212  				return err
  2213  			}
  2214  			if skippy < 0 {
  2215  				return ErrInvalidLengthNetworkdb
  2216  			}
  2217  			if (iNdEx + skippy) > l {
  2218  				return io.ErrUnexpectedEOF
  2219  			}
  2220  			iNdEx += skippy
  2221  		}
  2222  	}
  2223  
  2224  	if iNdEx > l {
  2225  		return io.ErrUnexpectedEOF
  2226  	}
  2227  	return nil
  2228  }
  2229  func (m *CompoundMessage) Unmarshal(data []byte) error {
  2230  	l := len(data)
  2231  	iNdEx := 0
  2232  	for iNdEx < l {
  2233  		preIndex := iNdEx
  2234  		var wire uint64
  2235  		for shift := uint(0); ; shift += 7 {
  2236  			if shift >= 64 {
  2237  				return ErrIntOverflowNetworkdb
  2238  			}
  2239  			if iNdEx >= l {
  2240  				return io.ErrUnexpectedEOF
  2241  			}
  2242  			b := data[iNdEx]
  2243  			iNdEx++
  2244  			wire |= (uint64(b) & 0x7F) << shift
  2245  			if b < 0x80 {
  2246  				break
  2247  			}
  2248  		}
  2249  		fieldNum := int32(wire >> 3)
  2250  		wireType := int(wire & 0x7)
  2251  		if wireType == 4 {
  2252  			return fmt.Errorf("proto: CompoundMessage: wiretype end group for non-group")
  2253  		}
  2254  		if fieldNum <= 0 {
  2255  			return fmt.Errorf("proto: CompoundMessage: illegal tag %d (wire type %d)", fieldNum, wire)
  2256  		}
  2257  		switch fieldNum {
  2258  		case 1:
  2259  			if wireType != 2 {
  2260  				return fmt.Errorf("proto: wrong wireType = %d for field Messages", wireType)
  2261  			}
  2262  			var msglen int
  2263  			for shift := uint(0); ; shift += 7 {
  2264  				if shift >= 64 {
  2265  					return ErrIntOverflowNetworkdb
  2266  				}
  2267  				if iNdEx >= l {
  2268  					return io.ErrUnexpectedEOF
  2269  				}
  2270  				b := data[iNdEx]
  2271  				iNdEx++
  2272  				msglen |= (int(b) & 0x7F) << shift
  2273  				if b < 0x80 {
  2274  					break
  2275  				}
  2276  			}
  2277  			if msglen < 0 {
  2278  				return ErrInvalidLengthNetworkdb
  2279  			}
  2280  			postIndex := iNdEx + msglen
  2281  			if postIndex > l {
  2282  				return io.ErrUnexpectedEOF
  2283  			}
  2284  			m.Messages = append(m.Messages, &CompoundMessage_SimpleMessage{})
  2285  			if err := m.Messages[len(m.Messages)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
  2286  				return err
  2287  			}
  2288  			iNdEx = postIndex
  2289  		default:
  2290  			iNdEx = preIndex
  2291  			skippy, err := skipNetworkdb(data[iNdEx:])
  2292  			if err != nil {
  2293  				return err
  2294  			}
  2295  			if skippy < 0 {
  2296  				return ErrInvalidLengthNetworkdb
  2297  			}
  2298  			if (iNdEx + skippy) > l {
  2299  				return io.ErrUnexpectedEOF
  2300  			}
  2301  			iNdEx += skippy
  2302  		}
  2303  	}
  2304  
  2305  	if iNdEx > l {
  2306  		return io.ErrUnexpectedEOF
  2307  	}
  2308  	return nil
  2309  }
  2310  func (m *CompoundMessage_SimpleMessage) Unmarshal(data []byte) error {
  2311  	l := len(data)
  2312  	iNdEx := 0
  2313  	for iNdEx < l {
  2314  		preIndex := iNdEx
  2315  		var wire uint64
  2316  		for shift := uint(0); ; shift += 7 {
  2317  			if shift >= 64 {
  2318  				return ErrIntOverflowNetworkdb
  2319  			}
  2320  			if iNdEx >= l {
  2321  				return io.ErrUnexpectedEOF
  2322  			}
  2323  			b := data[iNdEx]
  2324  			iNdEx++
  2325  			wire |= (uint64(b) & 0x7F) << shift
  2326  			if b < 0x80 {
  2327  				break
  2328  			}
  2329  		}
  2330  		fieldNum := int32(wire >> 3)
  2331  		wireType := int(wire & 0x7)
  2332  		if wireType == 4 {
  2333  			return fmt.Errorf("proto: SimpleMessage: wiretype end group for non-group")
  2334  		}
  2335  		if fieldNum <= 0 {
  2336  			return fmt.Errorf("proto: SimpleMessage: illegal tag %d (wire type %d)", fieldNum, wire)
  2337  		}
  2338  		switch fieldNum {
  2339  		case 1:
  2340  			if wireType != 2 {
  2341  				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
  2342  			}
  2343  			var byteLen int
  2344  			for shift := uint(0); ; shift += 7 {
  2345  				if shift >= 64 {
  2346  					return ErrIntOverflowNetworkdb
  2347  				}
  2348  				if iNdEx >= l {
  2349  					return io.ErrUnexpectedEOF
  2350  				}
  2351  				b := data[iNdEx]
  2352  				iNdEx++
  2353  				byteLen |= (int(b) & 0x7F) << shift
  2354  				if b < 0x80 {
  2355  					break
  2356  				}
  2357  			}
  2358  			if byteLen < 0 {
  2359  				return ErrInvalidLengthNetworkdb
  2360  			}
  2361  			postIndex := iNdEx + byteLen
  2362  			if postIndex > l {
  2363  				return io.ErrUnexpectedEOF
  2364  			}
  2365  			m.Payload = append(m.Payload[:0], data[iNdEx:postIndex]...)
  2366  			if m.Payload == nil {
  2367  				m.Payload = []byte{}
  2368  			}
  2369  			iNdEx = postIndex
  2370  		default:
  2371  			iNdEx = preIndex
  2372  			skippy, err := skipNetworkdb(data[iNdEx:])
  2373  			if err != nil {
  2374  				return err
  2375  			}
  2376  			if skippy < 0 {
  2377  				return ErrInvalidLengthNetworkdb
  2378  			}
  2379  			if (iNdEx + skippy) > l {
  2380  				return io.ErrUnexpectedEOF
  2381  			}
  2382  			iNdEx += skippy
  2383  		}
  2384  	}
  2385  
  2386  	if iNdEx > l {
  2387  		return io.ErrUnexpectedEOF
  2388  	}
  2389  	return nil
  2390  }
  2391  func skipNetworkdb(data []byte) (n int, err error) {
  2392  	l := len(data)
  2393  	iNdEx := 0
  2394  	for iNdEx < l {
  2395  		var wire uint64
  2396  		for shift := uint(0); ; shift += 7 {
  2397  			if shift >= 64 {
  2398  				return 0, ErrIntOverflowNetworkdb
  2399  			}
  2400  			if iNdEx >= l {
  2401  				return 0, io.ErrUnexpectedEOF
  2402  			}
  2403  			b := data[iNdEx]
  2404  			iNdEx++
  2405  			wire |= (uint64(b) & 0x7F) << shift
  2406  			if b < 0x80 {
  2407  				break
  2408  			}
  2409  		}
  2410  		wireType := int(wire & 0x7)
  2411  		switch wireType {
  2412  		case 0:
  2413  			for shift := uint(0); ; shift += 7 {
  2414  				if shift >= 64 {
  2415  					return 0, ErrIntOverflowNetworkdb
  2416  				}
  2417  				if iNdEx >= l {
  2418  					return 0, io.ErrUnexpectedEOF
  2419  				}
  2420  				iNdEx++
  2421  				if data[iNdEx-1] < 0x80 {
  2422  					break
  2423  				}
  2424  			}
  2425  			return iNdEx, nil
  2426  		case 1:
  2427  			iNdEx += 8
  2428  			return iNdEx, nil
  2429  		case 2:
  2430  			var length int
  2431  			for shift := uint(0); ; shift += 7 {
  2432  				if shift >= 64 {
  2433  					return 0, ErrIntOverflowNetworkdb
  2434  				}
  2435  				if iNdEx >= l {
  2436  					return 0, io.ErrUnexpectedEOF
  2437  				}
  2438  				b := data[iNdEx]
  2439  				iNdEx++
  2440  				length |= (int(b) & 0x7F) << shift
  2441  				if b < 0x80 {
  2442  					break
  2443  				}
  2444  			}
  2445  			iNdEx += length
  2446  			if length < 0 {
  2447  				return 0, ErrInvalidLengthNetworkdb
  2448  			}
  2449  			return iNdEx, nil
  2450  		case 3:
  2451  			for {
  2452  				var innerWire uint64
  2453  				var start int = iNdEx
  2454  				for shift := uint(0); ; shift += 7 {
  2455  					if shift >= 64 {
  2456  						return 0, ErrIntOverflowNetworkdb
  2457  					}
  2458  					if iNdEx >= l {
  2459  						return 0, io.ErrUnexpectedEOF
  2460  					}
  2461  					b := data[iNdEx]
  2462  					iNdEx++
  2463  					innerWire |= (uint64(b) & 0x7F) << shift
  2464  					if b < 0x80 {
  2465  						break
  2466  					}
  2467  				}
  2468  				innerWireType := int(innerWire & 0x7)
  2469  				if innerWireType == 4 {
  2470  					break
  2471  				}
  2472  				next, err := skipNetworkdb(data[start:])
  2473  				if err != nil {
  2474  					return 0, err
  2475  				}
  2476  				iNdEx = start + next
  2477  			}
  2478  			return iNdEx, nil
  2479  		case 4:
  2480  			return iNdEx, nil
  2481  		case 5:
  2482  			iNdEx += 4
  2483  			return iNdEx, nil
  2484  		default:
  2485  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  2486  		}
  2487  	}
  2488  	panic("unreachable")
  2489  }
  2490  
  2491  var (
  2492  	ErrInvalidLengthNetworkdb = fmt.Errorf("proto: negative length found during unmarshaling")
  2493  	ErrIntOverflowNetworkdb   = fmt.Errorf("proto: integer overflow")
  2494  )
  2495  
  2496  var fileDescriptorNetworkdb = []byte{
  2497  	// 887 bytes of a gzipped FileDescriptorProto
  2498  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0x96, 0xc1, 0x6e, 0xe3, 0x44,
  2499  	0x18, 0xc7, 0xeb, 0xc4, 0x49, 0xe3, 0xaf, 0x0d, 0x1b, 0xbc, 0xdd, 0xad, 0xd7, 0x0b, 0x49, 0x31,
  2500  	0xcb, 0x2a, 0x44, 0xe0, 0xa2, 0xee, 0x13, 0x24, 0xb1, 0x05, 0xd9, 0xf5, 0x3a, 0x91, 0x93, 0x14,
  2501  	0x71, 0x8a, 0x9c, 0x78, 0x48, 0xac, 0x3a, 0xb6, 0x15, 0x3b, 0x45, 0x39, 0x81, 0x38, 0xad, 0x78,
  2502  	0x07, 0x4e, 0xcb, 0x99, 0x07, 0xe0, 0xc0, 0x89, 0xc3, 0x8a, 0x13, 0xdc, 0x10, 0x87, 0x8a, 0xee,
  2503  	0x13, 0xf0, 0x08, 0x8c, 0xc7, 0x76, 0x32, 0x4e, 0xa3, 0x5e, 0x40, 0xc0, 0xc1, 0xad, 0x67, 0xe6,
  2504  	0xe7, 0xcf, 0xdf, 0xf7, 0x9f, 0xff, 0xe7, 0x09, 0xdc, 0x71, 0x51, 0xf8, 0x85, 0xb7, 0xb8, 0xb0,
  2505  	0xc6, 0xb2, 0xbf, 0xf0, 0x42, 0x8f, 0xe7, 0xd6, 0x13, 0xe2, 0xd1, 0xd4, 0x9b, 0x7a, 0x64, 0xf6,
  2506  	0x34, 0xba, 0x8b, 0x01, 0xa9, 0x0b, 0xe5, 0x8f, 0xbd, 0x20, 0xb0, 0xfd, 0xe7, 0x28, 0x08, 0xcc,
  2507  	0x29, 0xe2, 0x1b, 0xc0, 0x86, 0x2b, 0x1f, 0x09, 0xcc, 0x09, 0x53, 0x7f, 0xe3, 0xec, 0xbe, 0xbc,
  2508  	0x89, 0x98, 0x10, 0x03, 0xbc, 0x6a, 0x10, 0x86, 0xe7, 0x81, 0xb5, 0xcc, 0xd0, 0x14, 0x72, 0x98,
  2509  	0x3d, 0x34, 0xc8, 0xbd, 0xf4, 0x32, 0x07, 0x9c, 0xee, 0x59, 0x48, 0xbd, 0x44, 0x6e, 0xc8, 0x7f,
  2510  	0x98, 0x89, 0xf6, 0x80, 0x8a, 0xb6, 0x66, 0x64, 0x2a, 0x60, 0x07, 0x8a, 0xce, 0x28, 0xb4, 0xe7,
  2511  	0x88, 0x84, 0x64, 0x5b, 0x67, 0xaf, 0xae, 0x6a, 0x7b, 0xbf, 0x5f, 0xd5, 0x1a, 0x53, 0x3b, 0x9c,
  2512  	0x2d, 0xc7, 0xf2, 0xc4, 0x9b, 0x9f, 0xce, 0xcc, 0x60, 0x66, 0x4f, 0xbc, 0x85, 0x7f, 0x1a, 0xa0,
  2513  	0xc5, 0xe7, 0xe4, 0x8f, 0xac, 0x99, 0x73, 0xdf, 0x5b, 0x84, 0x03, 0xfc, 0xa4, 0x51, 0x70, 0xa2,
  2514  	0x7f, 0xfc, 0x43, 0xe0, 0x5c, 0xfc, 0x8a, 0x91, 0x6b, 0xe2, 0x68, 0x79, 0x1c, 0x8d, 0x33, 0x4a,
  2515  	0xd1, 0x84, 0x8e, 0xc7, 0xd2, 0x97, 0xc0, 0x46, 0x6f, 0xe5, 0xdf, 0x83, 0xfd, 0x8e, 0x7e, 0xde,
  2516  	0xd4, 0x3a, 0x4a, 0x65, 0x4f, 0x14, 0xbe, 0xf9, 0xf6, 0xe4, 0x68, 0x9d, 0x56, 0xb4, 0xde, 0x71,
  2517  	0x2f, 0x4d, 0xc7, 0xb6, 0xf8, 0x1a, 0xb0, 0x4f, 0xbb, 0x1d, 0xbd, 0xc2, 0x88, 0xf7, 0x30, 0xf3,
  2518  	0x66, 0x86, 0x79, 0xea, 0xd9, 0x2e, 0xff, 0x0e, 0x14, 0x34, 0xb5, 0x79, 0xae, 0x56, 0x72, 0xe2,
  2519  	0x7d, 0x4c, 0xf0, 0x19, 0x42, 0x43, 0xe6, 0x25, 0x12, 0x0f, 0x5f, 0xbc, 0xac, 0xee, 0xfd, 0xf0,
  2520  	0x5d, 0x95, 0xbc, 0x58, 0xba, 0xce, 0xc1, 0xa1, 0x1e, 0x6b, 0x11, 0x0b, 0xf5, 0x51, 0x46, 0xa8,
  2521  	0xb7, 0x68, 0xa1, 0x28, 0xec, 0x3f, 0xd0, 0x8a, 0xff, 0x00, 0x20, 0x49, 0x66, 0x64, 0x5b, 0x02,
  2522  	0x1b, 0xad, 0xb6, 0xca, 0xaf, 0xaf, 0x6a, 0x5c, 0x92, 0x58, 0x47, 0x31, 0x52, 0x97, 0x75, 0x2c,
  2523  	0xe9, 0x05, 0x93, 0x48, 0x5b, 0xa7, 0xa5, 0x7d, 0x88, 0x45, 0x39, 0xa6, 0x0b, 0xa1, 0xd5, 0x95,
  2524  	0xd6, 0xea, 0xc6, 0x3b, 0xb0, 0x85, 0x11, 0x81, 0x1f, 0x6d, 0x04, 0x7e, 0x80, 0xa1, 0x7b, 0xdb,
  2525  	0xd0, 0x2e, 0x8d, 0x7f, 0x64, 0x36, 0x1a, 0xbb, 0xe1, 0x62, 0xb5, 0x55, 0x09, 0x73, 0x7b, 0x25,
  2526  	0xff, 0x9a, 0xbe, 0x02, 0xec, 0x3b, 0x38, 0x7b, 0xdb, 0x9d, 0x12, 0x71, 0x4b, 0x46, 0x3a, 0x94,
  2527  	0xbe, 0x67, 0xe0, 0x4e, 0x92, 0x5a, 0x6f, 0x19, 0xcc, 0x7a, 0x4b, 0xc7, 0xa1, 0xb2, 0x62, 0xfe,
  2528  	0x6e, 0x56, 0x4f, 0xa0, 0x94, 0x54, 0x1b, 0xe0, 0x12, 0xf3, 0xf5, 0x83, 0xb3, 0xe3, 0x1d, 0xb6,
  2529  	0x8b, 0x94, 0x33, 0xd6, 0xe0, 0xed, 0x6d, 0xf5, 0x73, 0x1e, 0x60, 0x60, 0x8e, 0x9d, 0xa4, 0xf9,
  2530  	0xe5, 0x8c, 0xa7, 0x45, 0x2a, 0xf8, 0x06, 0xfa, 0xdf, 0x3b, 0x9a, 0x7f, 0x1b, 0x20, 0x8c, 0xd2,
  2531  	0x8d, 0x63, 0x15, 0x48, 0x2c, 0x8e, 0xcc, 0x90, 0x60, 0x15, 0xc8, 0x5f, 0xa0, 0x95, 0x50, 0x24,
  2532  	0xf3, 0xd1, 0x2d, 0x7f, 0x04, 0x05, 0x6c, 0xec, 0x25, 0x12, 0xf6, 0xc9, 0x67, 0x31, 0x1e, 0x44,
  2533  	0x9b, 0x19, 0x37, 0xc6, 0x63, 0xba, 0x31, 0x88, 0x99, 0x37, 0x6a, 0xd0, 0x6d, 0xf1, 0x08, 0x8a,
  2534  	0x6d, 0x43, 0x6d, 0x0e, 0xd4, 0xb4, 0x31, 0xb2, 0x58, 0x7b, 0x81, 0xcc, 0x10, 0x45, 0xd4, 0xb0,
  2535  	0xa7, 0x44, 0x54, 0x6e, 0x17, 0x35, 0xf4, 0xad, 0x84, 0x52, 0x54, 0x4d, 0xc5, 0x54, 0x7e, 0x17,
  2536  	0xa5, 0x20, 0x07, 0x85, 0xdb, 0xed, 0xf3, 0x2b, 0x76, 0x5f, 0x6b, 0xe9, 0x5c, 0xf4, 0x57, 0xee,
  2537  	0x24, 0x3d, 0x1c, 0xfe, 0x41, 0xf7, 0x9d, 0xc0, 0xc1, 0xd2, 0x0d, 0x3c, 0xc7, 0x9e, 0xd8, 0x21,
  2538  	0xb2, 0xc8, 0x8e, 0x97, 0x0c, 0x7a, 0xea, 0xf6, 0x3d, 0x14, 0x29, 0xf3, 0xb2, 0xd8, 0xbc, 0x1c,
  2539  	0xe5, 0x51, 0xdc, 0x51, 0xbe, 0xb9, 0x72, 0x3c, 0xd3, 0x22, 0xdb, 0x75, 0x68, 0xa4, 0x43, 0xe9,
  2540  	0x6b, 0x5c, 0x53, 0xdb, 0xc3, 0xb9, 0x2c, 0x5d, 0x2b, 0xad, 0x49, 0x81, 0xd2, 0x3c, 0xbe, 0x0d,
  2541  	0x70, 0x55, 0x51, 0x1b, 0xd4, 0x29, 0xa7, 0x6e, 0xd1, 0x72, 0xdf, 0x9e, 0xfb, 0x0e, 0x4a, 0x46,
  2542  	0xc6, 0xfa, 0x49, 0xf1, 0x7d, 0x28, 0x67, 0x96, 0xa2, 0x24, 0x7a, 0x49, 0x12, 0x4c, 0x26, 0x89,
  2543  	0xc6, 0x4f, 0x39, 0x38, 0xa0, 0xce, 0x52, 0xfe, 0x5d, 0xda, 0x10, 0xe4, 0xf8, 0xa0, 0x56, 0x53,
  2544  	0x37, 0xc8, 0x50, 0xd6, 0xd5, 0xc1, 0xa7, 0x5d, 0xe3, 0xd9, 0x48, 0x3d, 0x57, 0xf5, 0x01, 0x36,
  2545  	0x05, 0xf9, 0xa8, 0x52, 0x68, 0xe6, 0x3c, 0x69, 0xc0, 0xc1, 0xa0, 0xd9, 0xd2, 0xd4, 0x84, 0x4e,
  2546  	0x3e, 0x9b, 0x14, 0x4d, 0xf5, 0xe9, 0x63, 0xe0, 0x7a, 0xc3, 0xfe, 0x27, 0xa3, 0xde, 0x50, 0xd3,
  2547  	0xb0, 0x41, 0x8e, 0x31, 0x79, 0x97, 0x22, 0xd7, 0xdf, 0x1e, 0xcc, 0xb5, 0x86, 0xda, 0xb3, 0x51,
  2548  	0xff, 0x33, 0xbd, 0x5d, 0x61, 0x6f, 0x70, 0xa9, 0x59, 0xf0, 0xa9, 0x5a, 0x6a, 0x77, 0x9f, 0xf7,
  2549  	0xba, 0x43, 0x5d, 0xa9, 0x14, 0x6e, 0x60, 0xa9, 0xa2, 0xf8, 0x84, 0x00, 0xbd, 0xab, 0xa4, 0x19,
  2550  	0x16, 0x63, 0x63, 0xd2, 0xf5, 0xa4, 0x87, 0xa8, 0x78, 0x37, 0x31, 0x26, 0x2d, 0x5b, 0x4b, 0xf8,
  2551  	0xed, 0xba, 0xba, 0xf7, 0xe7, 0x75, 0x95, 0xf9, 0xea, 0x75, 0x95, 0x79, 0x85, 0xaf, 0x5f, 0xf0,
  2552  	0xf5, 0x07, 0xbe, 0xc6, 0x45, 0xf2, 0xd3, 0xe6, 0xc9, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x21,
  2553  	0x78, 0x72, 0xc3, 0x0e, 0x09, 0x00, 0x00,
  2554  }