Source file src/github.com/Microsoft/hcsshim/cmd/containerd-shim-runhcs-v1/stats/stats.pb.go

Documentation: github.com/Microsoft/hcsshim/cmd/containerd-shim-runhcs-v1/stats

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

View as plain text