// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. // protoc-gen-go-vtproto version: v0.6.1-0.20240319094008-0393e58bdf10 // source: github.com/moby/buildkit/frontend/gateway/pb/gateway.proto package moby_buildkit_v1_frontend import ( fmt "fmt" types1 "github.com/moby/buildkit/api/types" pb "github.com/moby/buildkit/solver/pb" pb1 "github.com/moby/buildkit/sourcepolicy/pb" pb2 "github.com/moby/buildkit/util/apicaps/pb" protohelpers "github.com/planetscale/vtprotobuf/protohelpers" types "github.com/tonistiigi/fsutil/types" status "google.golang.org/genproto/googleapis/rpc/status" proto "google.golang.org/protobuf/proto" protoimpl "google.golang.org/protobuf/runtime/protoimpl" io "io" ) const ( // Verify that this generated code is sufficiently up-to-date. _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) // Verify that runtime/protoimpl is sufficiently up-to-date. _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) func (m *Result) CloneVT() *Result { if m == nil { return (*Result)(nil) } r := new(Result) if m.Result != nil { r.Result = m.Result.(interface{ CloneVT() isResult_Result }).CloneVT() } if rhs := m.Metadata; rhs != nil { tmpContainer := make(map[string][]byte, len(rhs)) for k, v := range rhs { tmpBytes := make([]byte, len(v)) copy(tmpBytes, v) tmpContainer[k] = tmpBytes } r.Metadata = tmpContainer } if rhs := m.Attestations; rhs != nil { tmpContainer := make(map[string]*Attestations, len(rhs)) for k, v := range rhs { tmpContainer[k] = v.CloneVT() } r.Attestations = tmpContainer } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *Result) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *Result_RefDeprecated) CloneVT() isResult_Result { if m == nil { return (*Result_RefDeprecated)(nil) } r := new(Result_RefDeprecated) r.RefDeprecated = m.RefDeprecated return r } func (m *Result_RefsDeprecated) CloneVT() isResult_Result { if m == nil { return (*Result_RefsDeprecated)(nil) } r := new(Result_RefsDeprecated) r.RefsDeprecated = m.RefsDeprecated.CloneVT() return r } func (m *Result_Ref) CloneVT() isResult_Result { if m == nil { return (*Result_Ref)(nil) } r := new(Result_Ref) r.Ref = m.Ref.CloneVT() return r } func (m *Result_Refs) CloneVT() isResult_Result { if m == nil { return (*Result_Refs)(nil) } r := new(Result_Refs) r.Refs = m.Refs.CloneVT() return r } func (m *RefMapDeprecated) CloneVT() *RefMapDeprecated { if m == nil { return (*RefMapDeprecated)(nil) } r := new(RefMapDeprecated) if rhs := m.Refs; rhs != nil { tmpContainer := make(map[string]string, len(rhs)) for k, v := range rhs { tmpContainer[k] = v } r.Refs = tmpContainer } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *RefMapDeprecated) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *Ref) CloneVT() *Ref { if m == nil { return (*Ref)(nil) } r := new(Ref) r.Id = m.Id r.Def = m.Def.CloneVT() if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *Ref) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *RefMap) CloneVT() *RefMap { if m == nil { return (*RefMap)(nil) } r := new(RefMap) if rhs := m.Refs; rhs != nil { tmpContainer := make(map[string]*Ref, len(rhs)) for k, v := range rhs { tmpContainer[k] = v.CloneVT() } r.Refs = tmpContainer } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *RefMap) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *Attestations) CloneVT() *Attestations { if m == nil { return (*Attestations)(nil) } r := new(Attestations) if rhs := m.Attestation; rhs != nil { tmpContainer := make([]*Attestation, len(rhs)) for k, v := range rhs { tmpContainer[k] = v.CloneVT() } r.Attestation = tmpContainer } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *Attestations) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *Attestation) CloneVT() *Attestation { if m == nil { return (*Attestation)(nil) } r := new(Attestation) r.Kind = m.Kind r.Ref = m.Ref.CloneVT() r.Path = m.Path r.InTotoPredicateType = m.InTotoPredicateType if rhs := m.Metadata; rhs != nil { tmpContainer := make(map[string][]byte, len(rhs)) for k, v := range rhs { tmpBytes := make([]byte, len(v)) copy(tmpBytes, v) tmpContainer[k] = tmpBytes } r.Metadata = tmpContainer } if rhs := m.InTotoSubjects; rhs != nil { tmpContainer := make([]*InTotoSubject, len(rhs)) for k, v := range rhs { tmpContainer[k] = v.CloneVT() } r.InTotoSubjects = tmpContainer } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *Attestation) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *InTotoSubject) CloneVT() *InTotoSubject { if m == nil { return (*InTotoSubject)(nil) } r := new(InTotoSubject) r.Kind = m.Kind r.Name = m.Name if rhs := m.Digest; rhs != nil { tmpContainer := make([]string, len(rhs)) copy(tmpContainer, rhs) r.Digest = tmpContainer } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *InTotoSubject) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *ReturnRequest) CloneVT() *ReturnRequest { if m == nil { return (*ReturnRequest)(nil) } r := new(ReturnRequest) r.Result = m.Result.CloneVT() if rhs := m.Error; rhs != nil { if vtpb, ok := interface{}(rhs).(interface{ CloneVT() *status.Status }); ok { r.Error = vtpb.CloneVT() } else { r.Error = proto.Clone(rhs).(*status.Status) } } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *ReturnRequest) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *ReturnResponse) CloneVT() *ReturnResponse { if m == nil { return (*ReturnResponse)(nil) } r := new(ReturnResponse) if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *ReturnResponse) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *InputsRequest) CloneVT() *InputsRequest { if m == nil { return (*InputsRequest)(nil) } r := new(InputsRequest) if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *InputsRequest) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *InputsResponse) CloneVT() *InputsResponse { if m == nil { return (*InputsResponse)(nil) } r := new(InputsResponse) if rhs := m.Definitions; rhs != nil { tmpContainer := make(map[string]*pb.Definition, len(rhs)) for k, v := range rhs { tmpContainer[k] = v.CloneVT() } r.Definitions = tmpContainer } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *InputsResponse) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *ResolveImageConfigRequest) CloneVT() *ResolveImageConfigRequest { if m == nil { return (*ResolveImageConfigRequest)(nil) } r := new(ResolveImageConfigRequest) r.Ref = m.Ref r.Platform = m.Platform.CloneVT() r.ResolveMode = m.ResolveMode r.LogName = m.LogName r.ResolverType = m.ResolverType r.SessionID = m.SessionID r.StoreID = m.StoreID if rhs := m.SourcePolicies; rhs != nil { tmpContainer := make([]*pb1.Policy, len(rhs)) for k, v := range rhs { tmpContainer[k] = v.CloneVT() } r.SourcePolicies = tmpContainer } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *ResolveImageConfigRequest) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *ResolveImageConfigResponse) CloneVT() *ResolveImageConfigResponse { if m == nil { return (*ResolveImageConfigResponse)(nil) } r := new(ResolveImageConfigResponse) r.Digest = m.Digest r.Ref = m.Ref if rhs := m.Config; rhs != nil { tmpBytes := make([]byte, len(rhs)) copy(tmpBytes, rhs) r.Config = tmpBytes } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *ResolveImageConfigResponse) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *ResolveSourceMetaRequest) CloneVT() *ResolveSourceMetaRequest { if m == nil { return (*ResolveSourceMetaRequest)(nil) } r := new(ResolveSourceMetaRequest) r.Source = m.Source.CloneVT() r.Platform = m.Platform.CloneVT() r.LogName = m.LogName r.ResolveMode = m.ResolveMode if rhs := m.SourcePolicies; rhs != nil { tmpContainer := make([]*pb1.Policy, len(rhs)) for k, v := range rhs { tmpContainer[k] = v.CloneVT() } r.SourcePolicies = tmpContainer } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *ResolveSourceMetaRequest) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *ResolveSourceMetaResponse) CloneVT() *ResolveSourceMetaResponse { if m == nil { return (*ResolveSourceMetaResponse)(nil) } r := new(ResolveSourceMetaResponse) r.Source = m.Source.CloneVT() r.Image = m.Image.CloneVT() if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *ResolveSourceMetaResponse) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *ResolveSourceImageResponse) CloneVT() *ResolveSourceImageResponse { if m == nil { return (*ResolveSourceImageResponse)(nil) } r := new(ResolveSourceImageResponse) r.Digest = m.Digest if rhs := m.Config; rhs != nil { tmpBytes := make([]byte, len(rhs)) copy(tmpBytes, rhs) r.Config = tmpBytes } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *ResolveSourceImageResponse) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *SolveRequest) CloneVT() *SolveRequest { if m == nil { return (*SolveRequest)(nil) } r := new(SolveRequest) r.Definition = m.Definition.CloneVT() r.Frontend = m.Frontend r.AllowResultReturn = m.AllowResultReturn r.AllowResultArrayRef = m.AllowResultArrayRef r.Final = m.Final r.Evaluate = m.Evaluate if rhs := m.FrontendOpt; rhs != nil { tmpContainer := make(map[string]string, len(rhs)) for k, v := range rhs { tmpContainer[k] = v } r.FrontendOpt = tmpContainer } if rhs := m.ExporterAttr; rhs != nil { tmpBytes := make([]byte, len(rhs)) copy(tmpBytes, rhs) r.ExporterAttr = tmpBytes } if rhs := m.CacheImports; rhs != nil { tmpContainer := make([]*CacheOptionsEntry, len(rhs)) for k, v := range rhs { tmpContainer[k] = v.CloneVT() } r.CacheImports = tmpContainer } if rhs := m.FrontendInputs; rhs != nil { tmpContainer := make(map[string]*pb.Definition, len(rhs)) for k, v := range rhs { tmpContainer[k] = v.CloneVT() } r.FrontendInputs = tmpContainer } if rhs := m.SourcePolicies; rhs != nil { tmpContainer := make([]*pb1.Policy, len(rhs)) for k, v := range rhs { tmpContainer[k] = v.CloneVT() } r.SourcePolicies = tmpContainer } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *SolveRequest) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *CacheOptionsEntry) CloneVT() *CacheOptionsEntry { if m == nil { return (*CacheOptionsEntry)(nil) } r := new(CacheOptionsEntry) r.Type = m.Type if rhs := m.Attrs; rhs != nil { tmpContainer := make(map[string]string, len(rhs)) for k, v := range rhs { tmpContainer[k] = v } r.Attrs = tmpContainer } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *CacheOptionsEntry) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *SolveResponse) CloneVT() *SolveResponse { if m == nil { return (*SolveResponse)(nil) } r := new(SolveResponse) r.Ref = m.Ref r.Result = m.Result.CloneVT() if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *SolveResponse) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *ReadFileRequest) CloneVT() *ReadFileRequest { if m == nil { return (*ReadFileRequest)(nil) } r := new(ReadFileRequest) r.Ref = m.Ref r.FilePath = m.FilePath r.Range = m.Range.CloneVT() if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *ReadFileRequest) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *FileRange) CloneVT() *FileRange { if m == nil { return (*FileRange)(nil) } r := new(FileRange) r.Offset = m.Offset r.Length = m.Length if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *FileRange) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *ReadFileResponse) CloneVT() *ReadFileResponse { if m == nil { return (*ReadFileResponse)(nil) } r := new(ReadFileResponse) if rhs := m.Data; rhs != nil { tmpBytes := make([]byte, len(rhs)) copy(tmpBytes, rhs) r.Data = tmpBytes } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *ReadFileResponse) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *ReadDirRequest) CloneVT() *ReadDirRequest { if m == nil { return (*ReadDirRequest)(nil) } r := new(ReadDirRequest) r.Ref = m.Ref r.DirPath = m.DirPath r.IncludePattern = m.IncludePattern if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *ReadDirRequest) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *ReadDirResponse) CloneVT() *ReadDirResponse { if m == nil { return (*ReadDirResponse)(nil) } r := new(ReadDirResponse) if rhs := m.Entries; rhs != nil { tmpContainer := make([]*types.Stat, len(rhs)) for k, v := range rhs { if vtpb, ok := interface{}(v).(interface{ CloneVT() *types.Stat }); ok { tmpContainer[k] = vtpb.CloneVT() } else { tmpContainer[k] = proto.Clone(v).(*types.Stat) } } r.Entries = tmpContainer } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *ReadDirResponse) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *StatFileRequest) CloneVT() *StatFileRequest { if m == nil { return (*StatFileRequest)(nil) } r := new(StatFileRequest) r.Ref = m.Ref r.Path = m.Path if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *StatFileRequest) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *StatFileResponse) CloneVT() *StatFileResponse { if m == nil { return (*StatFileResponse)(nil) } r := new(StatFileResponse) if rhs := m.Stat; rhs != nil { if vtpb, ok := interface{}(rhs).(interface{ CloneVT() *types.Stat }); ok { r.Stat = vtpb.CloneVT() } else { r.Stat = proto.Clone(rhs).(*types.Stat) } } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *StatFileResponse) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *EvaluateRequest) CloneVT() *EvaluateRequest { if m == nil { return (*EvaluateRequest)(nil) } r := new(EvaluateRequest) r.Ref = m.Ref if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *EvaluateRequest) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *EvaluateResponse) CloneVT() *EvaluateResponse { if m == nil { return (*EvaluateResponse)(nil) } r := new(EvaluateResponse) if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *EvaluateResponse) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *PingRequest) CloneVT() *PingRequest { if m == nil { return (*PingRequest)(nil) } r := new(PingRequest) if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *PingRequest) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *PongResponse) CloneVT() *PongResponse { if m == nil { return (*PongResponse)(nil) } r := new(PongResponse) if rhs := m.FrontendAPICaps; rhs != nil { tmpContainer := make([]*pb2.APICap, len(rhs)) for k, v := range rhs { tmpContainer[k] = v.CloneVT() } r.FrontendAPICaps = tmpContainer } if rhs := m.LLBCaps; rhs != nil { tmpContainer := make([]*pb2.APICap, len(rhs)) for k, v := range rhs { tmpContainer[k] = v.CloneVT() } r.LLBCaps = tmpContainer } if rhs := m.Workers; rhs != nil { tmpContainer := make([]*types1.WorkerRecord, len(rhs)) for k, v := range rhs { tmpContainer[k] = v.CloneVT() } r.Workers = tmpContainer } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *PongResponse) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *WarnRequest) CloneVT() *WarnRequest { if m == nil { return (*WarnRequest)(nil) } r := new(WarnRequest) r.Digest = m.Digest r.Level = m.Level r.Url = m.Url r.Info = m.Info.CloneVT() if rhs := m.Short; rhs != nil { tmpBytes := make([]byte, len(rhs)) copy(tmpBytes, rhs) r.Short = tmpBytes } if rhs := m.Detail; rhs != nil { tmpContainer := make([][]byte, len(rhs)) for k, v := range rhs { tmpBytes := make([]byte, len(v)) copy(tmpBytes, v) tmpContainer[k] = tmpBytes } r.Detail = tmpContainer } if rhs := m.Ranges; rhs != nil { tmpContainer := make([]*pb.Range, len(rhs)) for k, v := range rhs { tmpContainer[k] = v.CloneVT() } r.Ranges = tmpContainer } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *WarnRequest) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *WarnResponse) CloneVT() *WarnResponse { if m == nil { return (*WarnResponse)(nil) } r := new(WarnResponse) if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *WarnResponse) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *NewContainerRequest) CloneVT() *NewContainerRequest { if m == nil { return (*NewContainerRequest)(nil) } r := new(NewContainerRequest) r.ContainerID = m.ContainerID r.Network = m.Network r.Platform = m.Platform.CloneVT() r.Constraints = m.Constraints.CloneVT() r.Hostname = m.Hostname if rhs := m.Mounts; rhs != nil { tmpContainer := make([]*pb.Mount, len(rhs)) for k, v := range rhs { tmpContainer[k] = v.CloneVT() } r.Mounts = tmpContainer } if rhs := m.ExtraHosts; rhs != nil { tmpContainer := make([]*pb.HostIP, len(rhs)) for k, v := range rhs { tmpContainer[k] = v.CloneVT() } r.ExtraHosts = tmpContainer } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *NewContainerRequest) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *NewContainerResponse) CloneVT() *NewContainerResponse { if m == nil { return (*NewContainerResponse)(nil) } r := new(NewContainerResponse) if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *NewContainerResponse) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *ReleaseContainerRequest) CloneVT() *ReleaseContainerRequest { if m == nil { return (*ReleaseContainerRequest)(nil) } r := new(ReleaseContainerRequest) r.ContainerID = m.ContainerID if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *ReleaseContainerRequest) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *ReleaseContainerResponse) CloneVT() *ReleaseContainerResponse { if m == nil { return (*ReleaseContainerResponse)(nil) } r := new(ReleaseContainerResponse) if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *ReleaseContainerResponse) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *ExecMessage) CloneVT() *ExecMessage { if m == nil { return (*ExecMessage)(nil) } r := new(ExecMessage) r.ProcessID = m.ProcessID if m.Input != nil { r.Input = m.Input.(interface{ CloneVT() isExecMessage_Input }).CloneVT() } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *ExecMessage) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *ExecMessage_Init) CloneVT() isExecMessage_Input { if m == nil { return (*ExecMessage_Init)(nil) } r := new(ExecMessage_Init) r.Init = m.Init.CloneVT() return r } func (m *ExecMessage_File) CloneVT() isExecMessage_Input { if m == nil { return (*ExecMessage_File)(nil) } r := new(ExecMessage_File) r.File = m.File.CloneVT() return r } func (m *ExecMessage_Resize) CloneVT() isExecMessage_Input { if m == nil { return (*ExecMessage_Resize)(nil) } r := new(ExecMessage_Resize) r.Resize = m.Resize.CloneVT() return r } func (m *ExecMessage_Started) CloneVT() isExecMessage_Input { if m == nil { return (*ExecMessage_Started)(nil) } r := new(ExecMessage_Started) r.Started = m.Started.CloneVT() return r } func (m *ExecMessage_Exit) CloneVT() isExecMessage_Input { if m == nil { return (*ExecMessage_Exit)(nil) } r := new(ExecMessage_Exit) r.Exit = m.Exit.CloneVT() return r } func (m *ExecMessage_Done) CloneVT() isExecMessage_Input { if m == nil { return (*ExecMessage_Done)(nil) } r := new(ExecMessage_Done) r.Done = m.Done.CloneVT() return r } func (m *ExecMessage_Signal) CloneVT() isExecMessage_Input { if m == nil { return (*ExecMessage_Signal)(nil) } r := new(ExecMessage_Signal) r.Signal = m.Signal.CloneVT() return r } func (m *InitMessage) CloneVT() *InitMessage { if m == nil { return (*InitMessage)(nil) } r := new(InitMessage) r.ContainerID = m.ContainerID r.Meta = m.Meta.CloneVT() r.Tty = m.Tty r.Security = m.Security if rhs := m.Fds; rhs != nil { tmpContainer := make([]uint32, len(rhs)) copy(tmpContainer, rhs) r.Fds = tmpContainer } if rhs := m.Secretenv; rhs != nil { tmpContainer := make([]*pb.SecretEnv, len(rhs)) for k, v := range rhs { tmpContainer[k] = v.CloneVT() } r.Secretenv = tmpContainer } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *InitMessage) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *ExitMessage) CloneVT() *ExitMessage { if m == nil { return (*ExitMessage)(nil) } r := new(ExitMessage) r.Code = m.Code if rhs := m.Error; rhs != nil { if vtpb, ok := interface{}(rhs).(interface{ CloneVT() *status.Status }); ok { r.Error = vtpb.CloneVT() } else { r.Error = proto.Clone(rhs).(*status.Status) } } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *ExitMessage) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *StartedMessage) CloneVT() *StartedMessage { if m == nil { return (*StartedMessage)(nil) } r := new(StartedMessage) if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *StartedMessage) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *DoneMessage) CloneVT() *DoneMessage { if m == nil { return (*DoneMessage)(nil) } r := new(DoneMessage) if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *DoneMessage) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *FdMessage) CloneVT() *FdMessage { if m == nil { return (*FdMessage)(nil) } r := new(FdMessage) r.Fd = m.Fd r.EOF = m.EOF if rhs := m.Data; rhs != nil { tmpBytes := make([]byte, len(rhs)) copy(tmpBytes, rhs) r.Data = tmpBytes } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *FdMessage) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *ResizeMessage) CloneVT() *ResizeMessage { if m == nil { return (*ResizeMessage)(nil) } r := new(ResizeMessage) r.Rows = m.Rows r.Cols = m.Cols if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *ResizeMessage) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *SignalMessage) CloneVT() *SignalMessage { if m == nil { return (*SignalMessage)(nil) } r := new(SignalMessage) r.Name = m.Name if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *SignalMessage) CloneMessageVT() proto.Message { return m.CloneVT() } func (this *Result) EqualVT(that *Result) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Result == nil && that.Result != nil { return false } else if this.Result != nil { if that.Result == nil { return false } if !this.Result.(interface{ EqualVT(isResult_Result) bool }).EqualVT(that.Result) { return false } } if len(this.Metadata) != len(that.Metadata) { return false } for i, vx := range this.Metadata { vy, ok := that.Metadata[i] if !ok { return false } if string(vx) != string(vy) { return false } } if len(this.Attestations) != len(that.Attestations) { return false } for i, vx := range this.Attestations { vy, ok := that.Attestations[i] if !ok { return false } if p, q := vx, vy; p != q { if p == nil { p = &Attestations{} } if q == nil { q = &Attestations{} } if !p.EqualVT(q) { return false } } } return string(this.unknownFields) == string(that.unknownFields) } func (this *Result) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*Result) if !ok { return false } return this.EqualVT(that) } func (this *Result_RefDeprecated) EqualVT(thatIface isResult_Result) bool { that, ok := thatIface.(*Result_RefDeprecated) if !ok { return false } if this == that { return true } if this == nil && that != nil || this != nil && that == nil { return false } if this.RefDeprecated != that.RefDeprecated { return false } return true } func (this *Result_RefsDeprecated) EqualVT(thatIface isResult_Result) bool { that, ok := thatIface.(*Result_RefsDeprecated) if !ok { return false } if this == that { return true } if this == nil && that != nil || this != nil && that == nil { return false } if p, q := this.RefsDeprecated, that.RefsDeprecated; p != q { if p == nil { p = &RefMapDeprecated{} } if q == nil { q = &RefMapDeprecated{} } if !p.EqualVT(q) { return false } } return true } func (this *Result_Ref) EqualVT(thatIface isResult_Result) bool { that, ok := thatIface.(*Result_Ref) if !ok { return false } if this == that { return true } if this == nil && that != nil || this != nil && that == nil { return false } if p, q := this.Ref, that.Ref; p != q { if p == nil { p = &Ref{} } if q == nil { q = &Ref{} } if !p.EqualVT(q) { return false } } return true } func (this *Result_Refs) EqualVT(thatIface isResult_Result) bool { that, ok := thatIface.(*Result_Refs) if !ok { return false } if this == that { return true } if this == nil && that != nil || this != nil && that == nil { return false } if p, q := this.Refs, that.Refs; p != q { if p == nil { p = &RefMap{} } if q == nil { q = &RefMap{} } if !p.EqualVT(q) { return false } } return true } func (this *RefMapDeprecated) EqualVT(that *RefMapDeprecated) bool { if this == that { return true } else if this == nil || that == nil { return false } if len(this.Refs) != len(that.Refs) { return false } for i, vx := range this.Refs { vy, ok := that.Refs[i] if !ok { return false } if vx != vy { return false } } return string(this.unknownFields) == string(that.unknownFields) } func (this *RefMapDeprecated) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*RefMapDeprecated) if !ok { return false } return this.EqualVT(that) } func (this *Ref) EqualVT(that *Ref) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Id != that.Id { return false } if !this.Def.EqualVT(that.Def) { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *Ref) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*Ref) if !ok { return false } return this.EqualVT(that) } func (this *RefMap) EqualVT(that *RefMap) bool { if this == that { return true } else if this == nil || that == nil { return false } if len(this.Refs) != len(that.Refs) { return false } for i, vx := range this.Refs { vy, ok := that.Refs[i] if !ok { return false } if p, q := vx, vy; p != q { if p == nil { p = &Ref{} } if q == nil { q = &Ref{} } if !p.EqualVT(q) { return false } } } return string(this.unknownFields) == string(that.unknownFields) } func (this *RefMap) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*RefMap) if !ok { return false } return this.EqualVT(that) } func (this *Attestations) EqualVT(that *Attestations) bool { if this == that { return true } else if this == nil || that == nil { return false } if len(this.Attestation) != len(that.Attestation) { return false } for i, vx := range this.Attestation { vy := that.Attestation[i] if p, q := vx, vy; p != q { if p == nil { p = &Attestation{} } if q == nil { q = &Attestation{} } if !p.EqualVT(q) { return false } } } return string(this.unknownFields) == string(that.unknownFields) } func (this *Attestations) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*Attestations) if !ok { return false } return this.EqualVT(that) } func (this *Attestation) EqualVT(that *Attestation) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Kind != that.Kind { return false } if len(this.Metadata) != len(that.Metadata) { return false } for i, vx := range this.Metadata { vy, ok := that.Metadata[i] if !ok { return false } if string(vx) != string(vy) { return false } } if !this.Ref.EqualVT(that.Ref) { return false } if this.Path != that.Path { return false } if this.InTotoPredicateType != that.InTotoPredicateType { return false } if len(this.InTotoSubjects) != len(that.InTotoSubjects) { return false } for i, vx := range this.InTotoSubjects { vy := that.InTotoSubjects[i] if p, q := vx, vy; p != q { if p == nil { p = &InTotoSubject{} } if q == nil { q = &InTotoSubject{} } if !p.EqualVT(q) { return false } } } return string(this.unknownFields) == string(that.unknownFields) } func (this *Attestation) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*Attestation) if !ok { return false } return this.EqualVT(that) } func (this *InTotoSubject) EqualVT(that *InTotoSubject) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Kind != that.Kind { return false } if len(this.Digest) != len(that.Digest) { return false } for i, vx := range this.Digest { vy := that.Digest[i] if vx != vy { return false } } if this.Name != that.Name { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *InTotoSubject) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*InTotoSubject) if !ok { return false } return this.EqualVT(that) } func (this *ReturnRequest) EqualVT(that *ReturnRequest) bool { if this == that { return true } else if this == nil || that == nil { return false } if !this.Result.EqualVT(that.Result) { return false } if equal, ok := interface{}(this.Error).(interface{ EqualVT(*status.Status) bool }); ok { if !equal.EqualVT(that.Error) { return false } } else if !proto.Equal(this.Error, that.Error) { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *ReturnRequest) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*ReturnRequest) if !ok { return false } return this.EqualVT(that) } func (this *ReturnResponse) EqualVT(that *ReturnResponse) bool { if this == that { return true } else if this == nil || that == nil { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *ReturnResponse) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*ReturnResponse) if !ok { return false } return this.EqualVT(that) } func (this *InputsRequest) EqualVT(that *InputsRequest) bool { if this == that { return true } else if this == nil || that == nil { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *InputsRequest) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*InputsRequest) if !ok { return false } return this.EqualVT(that) } func (this *InputsResponse) EqualVT(that *InputsResponse) bool { if this == that { return true } else if this == nil || that == nil { return false } if len(this.Definitions) != len(that.Definitions) { return false } for i, vx := range this.Definitions { vy, ok := that.Definitions[i] if !ok { return false } if p, q := vx, vy; p != q { if p == nil { p = &pb.Definition{} } if q == nil { q = &pb.Definition{} } if !p.EqualVT(q) { return false } } } return string(this.unknownFields) == string(that.unknownFields) } func (this *InputsResponse) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*InputsResponse) if !ok { return false } return this.EqualVT(that) } func (this *ResolveImageConfigRequest) EqualVT(that *ResolveImageConfigRequest) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Ref != that.Ref { return false } if !this.Platform.EqualVT(that.Platform) { return false } if this.ResolveMode != that.ResolveMode { return false } if this.LogName != that.LogName { return false } if this.ResolverType != that.ResolverType { return false } if this.SessionID != that.SessionID { return false } if this.StoreID != that.StoreID { return false } if len(this.SourcePolicies) != len(that.SourcePolicies) { return false } for i, vx := range this.SourcePolicies { vy := that.SourcePolicies[i] if p, q := vx, vy; p != q { if p == nil { p = &pb1.Policy{} } if q == nil { q = &pb1.Policy{} } if !p.EqualVT(q) { return false } } } return string(this.unknownFields) == string(that.unknownFields) } func (this *ResolveImageConfigRequest) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*ResolveImageConfigRequest) if !ok { return false } return this.EqualVT(that) } func (this *ResolveImageConfigResponse) EqualVT(that *ResolveImageConfigResponse) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Digest != that.Digest { return false } if string(this.Config) != string(that.Config) { return false } if this.Ref != that.Ref { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *ResolveImageConfigResponse) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*ResolveImageConfigResponse) if !ok { return false } return this.EqualVT(that) } func (this *ResolveSourceMetaRequest) EqualVT(that *ResolveSourceMetaRequest) bool { if this == that { return true } else if this == nil || that == nil { return false } if !this.Source.EqualVT(that.Source) { return false } if !this.Platform.EqualVT(that.Platform) { return false } if this.LogName != that.LogName { return false } if this.ResolveMode != that.ResolveMode { return false } if len(this.SourcePolicies) != len(that.SourcePolicies) { return false } for i, vx := range this.SourcePolicies { vy := that.SourcePolicies[i] if p, q := vx, vy; p != q { if p == nil { p = &pb1.Policy{} } if q == nil { q = &pb1.Policy{} } if !p.EqualVT(q) { return false } } } return string(this.unknownFields) == string(that.unknownFields) } func (this *ResolveSourceMetaRequest) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*ResolveSourceMetaRequest) if !ok { return false } return this.EqualVT(that) } func (this *ResolveSourceMetaResponse) EqualVT(that *ResolveSourceMetaResponse) bool { if this == that { return true } else if this == nil || that == nil { return false } if !this.Source.EqualVT(that.Source) { return false } if !this.Image.EqualVT(that.Image) { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *ResolveSourceMetaResponse) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*ResolveSourceMetaResponse) if !ok { return false } return this.EqualVT(that) } func (this *ResolveSourceImageResponse) EqualVT(that *ResolveSourceImageResponse) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Digest != that.Digest { return false } if string(this.Config) != string(that.Config) { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *ResolveSourceImageResponse) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*ResolveSourceImageResponse) if !ok { return false } return this.EqualVT(that) } func (this *SolveRequest) EqualVT(that *SolveRequest) bool { if this == that { return true } else if this == nil || that == nil { return false } if !this.Definition.EqualVT(that.Definition) { return false } if this.Frontend != that.Frontend { return false } if len(this.FrontendOpt) != len(that.FrontendOpt) { return false } for i, vx := range this.FrontendOpt { vy, ok := that.FrontendOpt[i] if !ok { return false } if vx != vy { return false } } if this.AllowResultReturn != that.AllowResultReturn { return false } if this.AllowResultArrayRef != that.AllowResultArrayRef { return false } if this.Final != that.Final { return false } if string(this.ExporterAttr) != string(that.ExporterAttr) { return false } if len(this.CacheImports) != len(that.CacheImports) { return false } for i, vx := range this.CacheImports { vy := that.CacheImports[i] if p, q := vx, vy; p != q { if p == nil { p = &CacheOptionsEntry{} } if q == nil { q = &CacheOptionsEntry{} } if !p.EqualVT(q) { return false } } } if len(this.FrontendInputs) != len(that.FrontendInputs) { return false } for i, vx := range this.FrontendInputs { vy, ok := that.FrontendInputs[i] if !ok { return false } if p, q := vx, vy; p != q { if p == nil { p = &pb.Definition{} } if q == nil { q = &pb.Definition{} } if !p.EqualVT(q) { return false } } } if this.Evaluate != that.Evaluate { return false } if len(this.SourcePolicies) != len(that.SourcePolicies) { return false } for i, vx := range this.SourcePolicies { vy := that.SourcePolicies[i] if p, q := vx, vy; p != q { if p == nil { p = &pb1.Policy{} } if q == nil { q = &pb1.Policy{} } if !p.EqualVT(q) { return false } } } return string(this.unknownFields) == string(that.unknownFields) } func (this *SolveRequest) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*SolveRequest) if !ok { return false } return this.EqualVT(that) } func (this *CacheOptionsEntry) EqualVT(that *CacheOptionsEntry) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Type != that.Type { return false } if len(this.Attrs) != len(that.Attrs) { return false } for i, vx := range this.Attrs { vy, ok := that.Attrs[i] if !ok { return false } if vx != vy { return false } } return string(this.unknownFields) == string(that.unknownFields) } func (this *CacheOptionsEntry) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*CacheOptionsEntry) if !ok { return false } return this.EqualVT(that) } func (this *SolveResponse) EqualVT(that *SolveResponse) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Ref != that.Ref { return false } if !this.Result.EqualVT(that.Result) { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *SolveResponse) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*SolveResponse) if !ok { return false } return this.EqualVT(that) } func (this *ReadFileRequest) EqualVT(that *ReadFileRequest) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Ref != that.Ref { return false } if this.FilePath != that.FilePath { return false } if !this.Range.EqualVT(that.Range) { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *ReadFileRequest) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*ReadFileRequest) if !ok { return false } return this.EqualVT(that) } func (this *FileRange) EqualVT(that *FileRange) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Offset != that.Offset { return false } if this.Length != that.Length { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *FileRange) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*FileRange) if !ok { return false } return this.EqualVT(that) } func (this *ReadFileResponse) EqualVT(that *ReadFileResponse) bool { if this == that { return true } else if this == nil || that == nil { return false } if string(this.Data) != string(that.Data) { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *ReadFileResponse) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*ReadFileResponse) if !ok { return false } return this.EqualVT(that) } func (this *ReadDirRequest) EqualVT(that *ReadDirRequest) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Ref != that.Ref { return false } if this.DirPath != that.DirPath { return false } if this.IncludePattern != that.IncludePattern { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *ReadDirRequest) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*ReadDirRequest) if !ok { return false } return this.EqualVT(that) } func (this *ReadDirResponse) EqualVT(that *ReadDirResponse) bool { if this == that { return true } else if this == nil || that == nil { return false } if len(this.Entries) != len(that.Entries) { return false } for i, vx := range this.Entries { vy := that.Entries[i] if p, q := vx, vy; p != q { if p == nil { p = &types.Stat{} } if q == nil { q = &types.Stat{} } if equal, ok := interface{}(p).(interface{ EqualVT(*types.Stat) bool }); ok { if !equal.EqualVT(q) { return false } } else if !proto.Equal(p, q) { return false } } } return string(this.unknownFields) == string(that.unknownFields) } func (this *ReadDirResponse) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*ReadDirResponse) if !ok { return false } return this.EqualVT(that) } func (this *StatFileRequest) EqualVT(that *StatFileRequest) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Ref != that.Ref { return false } if this.Path != that.Path { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *StatFileRequest) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*StatFileRequest) if !ok { return false } return this.EqualVT(that) } func (this *StatFileResponse) EqualVT(that *StatFileResponse) bool { if this == that { return true } else if this == nil || that == nil { return false } if equal, ok := interface{}(this.Stat).(interface{ EqualVT(*types.Stat) bool }); ok { if !equal.EqualVT(that.Stat) { return false } } else if !proto.Equal(this.Stat, that.Stat) { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *StatFileResponse) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*StatFileResponse) if !ok { return false } return this.EqualVT(that) } func (this *EvaluateRequest) EqualVT(that *EvaluateRequest) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Ref != that.Ref { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *EvaluateRequest) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*EvaluateRequest) if !ok { return false } return this.EqualVT(that) } func (this *EvaluateResponse) EqualVT(that *EvaluateResponse) bool { if this == that { return true } else if this == nil || that == nil { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *EvaluateResponse) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*EvaluateResponse) if !ok { return false } return this.EqualVT(that) } func (this *PingRequest) EqualVT(that *PingRequest) bool { if this == that { return true } else if this == nil || that == nil { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *PingRequest) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*PingRequest) if !ok { return false } return this.EqualVT(that) } func (this *PongResponse) EqualVT(that *PongResponse) bool { if this == that { return true } else if this == nil || that == nil { return false } if len(this.FrontendAPICaps) != len(that.FrontendAPICaps) { return false } for i, vx := range this.FrontendAPICaps { vy := that.FrontendAPICaps[i] if p, q := vx, vy; p != q { if p == nil { p = &pb2.APICap{} } if q == nil { q = &pb2.APICap{} } if !p.EqualVT(q) { return false } } } if len(this.LLBCaps) != len(that.LLBCaps) { return false } for i, vx := range this.LLBCaps { vy := that.LLBCaps[i] if p, q := vx, vy; p != q { if p == nil { p = &pb2.APICap{} } if q == nil { q = &pb2.APICap{} } if !p.EqualVT(q) { return false } } } if len(this.Workers) != len(that.Workers) { return false } for i, vx := range this.Workers { vy := that.Workers[i] if p, q := vx, vy; p != q { if p == nil { p = &types1.WorkerRecord{} } if q == nil { q = &types1.WorkerRecord{} } if !p.EqualVT(q) { return false } } } return string(this.unknownFields) == string(that.unknownFields) } func (this *PongResponse) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*PongResponse) if !ok { return false } return this.EqualVT(that) } func (this *WarnRequest) EqualVT(that *WarnRequest) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Digest != that.Digest { return false } if this.Level != that.Level { return false } if string(this.Short) != string(that.Short) { return false } if len(this.Detail) != len(that.Detail) { return false } for i, vx := range this.Detail { vy := that.Detail[i] if string(vx) != string(vy) { return false } } if this.Url != that.Url { return false } if !this.Info.EqualVT(that.Info) { return false } if len(this.Ranges) != len(that.Ranges) { return false } for i, vx := range this.Ranges { vy := that.Ranges[i] if p, q := vx, vy; p != q { if p == nil { p = &pb.Range{} } if q == nil { q = &pb.Range{} } if !p.EqualVT(q) { return false } } } return string(this.unknownFields) == string(that.unknownFields) } func (this *WarnRequest) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*WarnRequest) if !ok { return false } return this.EqualVT(that) } func (this *WarnResponse) EqualVT(that *WarnResponse) bool { if this == that { return true } else if this == nil || that == nil { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *WarnResponse) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*WarnResponse) if !ok { return false } return this.EqualVT(that) } func (this *NewContainerRequest) EqualVT(that *NewContainerRequest) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.ContainerID != that.ContainerID { return false } if len(this.Mounts) != len(that.Mounts) { return false } for i, vx := range this.Mounts { vy := that.Mounts[i] if p, q := vx, vy; p != q { if p == nil { p = &pb.Mount{} } if q == nil { q = &pb.Mount{} } if !p.EqualVT(q) { return false } } } if this.Network != that.Network { return false } if !this.Platform.EqualVT(that.Platform) { return false } if !this.Constraints.EqualVT(that.Constraints) { return false } if len(this.ExtraHosts) != len(that.ExtraHosts) { return false } for i, vx := range this.ExtraHosts { vy := that.ExtraHosts[i] if p, q := vx, vy; p != q { if p == nil { p = &pb.HostIP{} } if q == nil { q = &pb.HostIP{} } if !p.EqualVT(q) { return false } } } if this.Hostname != that.Hostname { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *NewContainerRequest) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*NewContainerRequest) if !ok { return false } return this.EqualVT(that) } func (this *NewContainerResponse) EqualVT(that *NewContainerResponse) bool { if this == that { return true } else if this == nil || that == nil { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *NewContainerResponse) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*NewContainerResponse) if !ok { return false } return this.EqualVT(that) } func (this *ReleaseContainerRequest) EqualVT(that *ReleaseContainerRequest) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.ContainerID != that.ContainerID { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *ReleaseContainerRequest) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*ReleaseContainerRequest) if !ok { return false } return this.EqualVT(that) } func (this *ReleaseContainerResponse) EqualVT(that *ReleaseContainerResponse) bool { if this == that { return true } else if this == nil || that == nil { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *ReleaseContainerResponse) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*ReleaseContainerResponse) if !ok { return false } return this.EqualVT(that) } func (this *ExecMessage) EqualVT(that *ExecMessage) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Input == nil && that.Input != nil { return false } else if this.Input != nil { if that.Input == nil { return false } if !this.Input.(interface { EqualVT(isExecMessage_Input) bool }).EqualVT(that.Input) { return false } } if this.ProcessID != that.ProcessID { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *ExecMessage) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*ExecMessage) if !ok { return false } return this.EqualVT(that) } func (this *ExecMessage_Init) EqualVT(thatIface isExecMessage_Input) bool { that, ok := thatIface.(*ExecMessage_Init) if !ok { return false } if this == that { return true } if this == nil && that != nil || this != nil && that == nil { return false } if p, q := this.Init, that.Init; p != q { if p == nil { p = &InitMessage{} } if q == nil { q = &InitMessage{} } if !p.EqualVT(q) { return false } } return true } func (this *ExecMessage_File) EqualVT(thatIface isExecMessage_Input) bool { that, ok := thatIface.(*ExecMessage_File) if !ok { return false } if this == that { return true } if this == nil && that != nil || this != nil && that == nil { return false } if p, q := this.File, that.File; p != q { if p == nil { p = &FdMessage{} } if q == nil { q = &FdMessage{} } if !p.EqualVT(q) { return false } } return true } func (this *ExecMessage_Resize) EqualVT(thatIface isExecMessage_Input) bool { that, ok := thatIface.(*ExecMessage_Resize) if !ok { return false } if this == that { return true } if this == nil && that != nil || this != nil && that == nil { return false } if p, q := this.Resize, that.Resize; p != q { if p == nil { p = &ResizeMessage{} } if q == nil { q = &ResizeMessage{} } if !p.EqualVT(q) { return false } } return true } func (this *ExecMessage_Started) EqualVT(thatIface isExecMessage_Input) bool { that, ok := thatIface.(*ExecMessage_Started) if !ok { return false } if this == that { return true } if this == nil && that != nil || this != nil && that == nil { return false } if p, q := this.Started, that.Started; p != q { if p == nil { p = &StartedMessage{} } if q == nil { q = &StartedMessage{} } if !p.EqualVT(q) { return false } } return true } func (this *ExecMessage_Exit) EqualVT(thatIface isExecMessage_Input) bool { that, ok := thatIface.(*ExecMessage_Exit) if !ok { return false } if this == that { return true } if this == nil && that != nil || this != nil && that == nil { return false } if p, q := this.Exit, that.Exit; p != q { if p == nil { p = &ExitMessage{} } if q == nil { q = &ExitMessage{} } if !p.EqualVT(q) { return false } } return true } func (this *ExecMessage_Done) EqualVT(thatIface isExecMessage_Input) bool { that, ok := thatIface.(*ExecMessage_Done) if !ok { return false } if this == that { return true } if this == nil && that != nil || this != nil && that == nil { return false } if p, q := this.Done, that.Done; p != q { if p == nil { p = &DoneMessage{} } if q == nil { q = &DoneMessage{} } if !p.EqualVT(q) { return false } } return true } func (this *ExecMessage_Signal) EqualVT(thatIface isExecMessage_Input) bool { that, ok := thatIface.(*ExecMessage_Signal) if !ok { return false } if this == that { return true } if this == nil && that != nil || this != nil && that == nil { return false } if p, q := this.Signal, that.Signal; p != q { if p == nil { p = &SignalMessage{} } if q == nil { q = &SignalMessage{} } if !p.EqualVT(q) { return false } } return true } func (this *InitMessage) EqualVT(that *InitMessage) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.ContainerID != that.ContainerID { return false } if !this.Meta.EqualVT(that.Meta) { return false } if len(this.Fds) != len(that.Fds) { return false } for i, vx := range this.Fds { vy := that.Fds[i] if vx != vy { return false } } if this.Tty != that.Tty { return false } if this.Security != that.Security { return false } if len(this.Secretenv) != len(that.Secretenv) { return false } for i, vx := range this.Secretenv { vy := that.Secretenv[i] if p, q := vx, vy; p != q { if p == nil { p = &pb.SecretEnv{} } if q == nil { q = &pb.SecretEnv{} } if !p.EqualVT(q) { return false } } } return string(this.unknownFields) == string(that.unknownFields) } func (this *InitMessage) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*InitMessage) if !ok { return false } return this.EqualVT(that) } func (this *ExitMessage) EqualVT(that *ExitMessage) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Code != that.Code { return false } if equal, ok := interface{}(this.Error).(interface{ EqualVT(*status.Status) bool }); ok { if !equal.EqualVT(that.Error) { return false } } else if !proto.Equal(this.Error, that.Error) { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *ExitMessage) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*ExitMessage) if !ok { return false } return this.EqualVT(that) } func (this *StartedMessage) EqualVT(that *StartedMessage) bool { if this == that { return true } else if this == nil || that == nil { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *StartedMessage) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*StartedMessage) if !ok { return false } return this.EqualVT(that) } func (this *DoneMessage) EqualVT(that *DoneMessage) bool { if this == that { return true } else if this == nil || that == nil { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *DoneMessage) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*DoneMessage) if !ok { return false } return this.EqualVT(that) } func (this *FdMessage) EqualVT(that *FdMessage) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Fd != that.Fd { return false } if this.EOF != that.EOF { return false } if string(this.Data) != string(that.Data) { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *FdMessage) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*FdMessage) if !ok { return false } return this.EqualVT(that) } func (this *ResizeMessage) EqualVT(that *ResizeMessage) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Rows != that.Rows { return false } if this.Cols != that.Cols { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *ResizeMessage) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*ResizeMessage) if !ok { return false } return this.EqualVT(that) } func (this *SignalMessage) EqualVT(that *SignalMessage) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Name != that.Name { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *SignalMessage) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*SignalMessage) if !ok { return false } return this.EqualVT(that) } func (m *Result) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Result) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *Result) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if vtmsg, ok := m.Result.(interface { MarshalToSizedBufferVT([]byte) (int, error) }); ok { size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size } if len(m.Attestations) > 0 { for k := range m.Attestations { v := m.Attestations[k] baseI := i size, err := v.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x62 } } if len(m.Metadata) > 0 { for k := range m.Metadata { v := m.Metadata[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x52 } } return len(dAtA) - i, nil } func (m *Result_RefDeprecated) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *Result_RefDeprecated) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i := len(dAtA) i -= len(m.RefDeprecated) copy(dAtA[i:], m.RefDeprecated) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RefDeprecated))) i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *Result_RefsDeprecated) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *Result_RefsDeprecated) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i := len(dAtA) if m.RefsDeprecated != nil { size, err := m.RefsDeprecated.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x12 } else { i = protohelpers.EncodeVarint(dAtA, i, 0) i-- dAtA[i] = 0x12 } return len(dAtA) - i, nil } func (m *Result_Ref) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *Result_Ref) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i := len(dAtA) if m.Ref != nil { size, err := m.Ref.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x1a } else { i = protohelpers.EncodeVarint(dAtA, i, 0) i-- dAtA[i] = 0x1a } return len(dAtA) - i, nil } func (m *Result_Refs) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *Result_Refs) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i := len(dAtA) if m.Refs != nil { size, err := m.Refs.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x22 } else { i = protohelpers.EncodeVarint(dAtA, i, 0) i-- dAtA[i] = 0x22 } return len(dAtA) - i, nil } func (m *RefMapDeprecated) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RefMapDeprecated) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *RefMapDeprecated) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Refs) > 0 { for k := range m.Refs { v := m.Refs[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *Ref) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Ref) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *Ref) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if m.Def != nil { size, err := m.Def.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x12 } if len(m.Id) > 0 { i -= len(m.Id) copy(dAtA[i:], m.Id) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Id))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *RefMap) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RefMap) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *RefMap) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Refs) > 0 { for k := range m.Refs { v := m.Refs[k] baseI := i size, err := v.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *Attestations) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Attestations) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *Attestations) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Attestation) > 0 { for iNdEx := len(m.Attestation) - 1; iNdEx >= 0; iNdEx-- { size, err := m.Attestation[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *Attestation) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Attestation) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *Attestation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.InTotoSubjects) > 0 { for iNdEx := len(m.InTotoSubjects) - 1; iNdEx >= 0; iNdEx-- { size, err := m.InTotoSubjects[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x32 } } if len(m.InTotoPredicateType) > 0 { i -= len(m.InTotoPredicateType) copy(dAtA[i:], m.InTotoPredicateType) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.InTotoPredicateType))) i-- dAtA[i] = 0x2a } if len(m.Path) > 0 { i -= len(m.Path) copy(dAtA[i:], m.Path) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Path))) i-- dAtA[i] = 0x22 } if m.Ref != nil { size, err := m.Ref.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x1a } if len(m.Metadata) > 0 { for k := range m.Metadata { v := m.Metadata[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x12 } } if m.Kind != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Kind)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *InTotoSubject) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *InTotoSubject) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *InTotoSubject) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Name) > 0 { i -= len(m.Name) copy(dAtA[i:], m.Name) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0x1a } if len(m.Digest) > 0 { for iNdEx := len(m.Digest) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Digest[iNdEx]) copy(dAtA[i:], m.Digest[iNdEx]) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Digest[iNdEx]))) i-- dAtA[i] = 0x12 } } if m.Kind != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Kind)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *ReturnRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReturnRequest) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ReturnRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if m.Error != nil { if vtmsg, ok := interface{}(m.Error).(interface { MarshalToSizedBufferVT([]byte) (int, error) }); ok { size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) } else { encoded, err := proto.Marshal(m.Error) if err != nil { return 0, err } i -= len(encoded) copy(dAtA[i:], encoded) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded))) } i-- dAtA[i] = 0x12 } if m.Result != nil { size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ReturnResponse) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReturnResponse) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ReturnResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } return len(dAtA) - i, nil } func (m *InputsRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *InputsRequest) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *InputsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } return len(dAtA) - i, nil } func (m *InputsResponse) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *InputsResponse) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *InputsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Definitions) > 0 { for k := range m.Definitions { v := m.Definitions[k] baseI := i size, err := v.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *ResolveImageConfigRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ResolveImageConfigRequest) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ResolveImageConfigRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.SourcePolicies) > 0 { for iNdEx := len(m.SourcePolicies) - 1; iNdEx >= 0; iNdEx-- { size, err := m.SourcePolicies[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x42 } } if len(m.StoreID) > 0 { i -= len(m.StoreID) copy(dAtA[i:], m.StoreID) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StoreID))) i-- dAtA[i] = 0x3a } if len(m.SessionID) > 0 { i -= len(m.SessionID) copy(dAtA[i:], m.SessionID) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SessionID))) i-- dAtA[i] = 0x32 } if m.ResolverType != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ResolverType)) i-- dAtA[i] = 0x28 } if len(m.LogName) > 0 { i -= len(m.LogName) copy(dAtA[i:], m.LogName) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LogName))) i-- dAtA[i] = 0x22 } if len(m.ResolveMode) > 0 { i -= len(m.ResolveMode) copy(dAtA[i:], m.ResolveMode) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ResolveMode))) i-- dAtA[i] = 0x1a } if m.Platform != nil { size, err := m.Platform.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x12 } if len(m.Ref) > 0 { i -= len(m.Ref) copy(dAtA[i:], m.Ref) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ref))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ResolveImageConfigResponse) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ResolveImageConfigResponse) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ResolveImageConfigResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Ref) > 0 { i -= len(m.Ref) copy(dAtA[i:], m.Ref) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ref))) i-- dAtA[i] = 0x1a } if len(m.Config) > 0 { i -= len(m.Config) copy(dAtA[i:], m.Config) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Config))) i-- dAtA[i] = 0x12 } if len(m.Digest) > 0 { i -= len(m.Digest) copy(dAtA[i:], m.Digest) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Digest))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ResolveSourceMetaRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ResolveSourceMetaRequest) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ResolveSourceMetaRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.SourcePolicies) > 0 { for iNdEx := len(m.SourcePolicies) - 1; iNdEx >= 0; iNdEx-- { size, err := m.SourcePolicies[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x42 } } if len(m.ResolveMode) > 0 { i -= len(m.ResolveMode) copy(dAtA[i:], m.ResolveMode) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ResolveMode))) i-- dAtA[i] = 0x22 } if len(m.LogName) > 0 { i -= len(m.LogName) copy(dAtA[i:], m.LogName) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LogName))) i-- dAtA[i] = 0x1a } if m.Platform != nil { size, err := m.Platform.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x12 } if m.Source != nil { size, err := m.Source.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ResolveSourceMetaResponse) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ResolveSourceMetaResponse) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ResolveSourceMetaResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if m.Image != nil { size, err := m.Image.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x12 } if m.Source != nil { size, err := m.Source.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ResolveSourceImageResponse) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ResolveSourceImageResponse) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ResolveSourceImageResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Config) > 0 { i -= len(m.Config) copy(dAtA[i:], m.Config) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Config))) i-- dAtA[i] = 0x12 } if len(m.Digest) > 0 { i -= len(m.Digest) copy(dAtA[i:], m.Digest) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Digest))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *SolveRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SolveRequest) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *SolveRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.SourcePolicies) > 0 { for iNdEx := len(m.SourcePolicies) - 1; iNdEx >= 0; iNdEx-- { size, err := m.SourcePolicies[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x7a } } if m.Evaluate { i-- if m.Evaluate { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x70 } if len(m.FrontendInputs) > 0 { for k := range m.FrontendInputs { v := m.FrontendInputs[k] baseI := i size, err := v.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x6a } } if len(m.CacheImports) > 0 { for iNdEx := len(m.CacheImports) - 1; iNdEx >= 0; iNdEx-- { size, err := m.CacheImports[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x62 } } if len(m.ExporterAttr) > 0 { i -= len(m.ExporterAttr) copy(dAtA[i:], m.ExporterAttr) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExporterAttr))) i-- dAtA[i] = 0x5a } if m.Final { i-- if m.Final { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x50 } if m.AllowResultArrayRef { i-- if m.AllowResultArrayRef { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x30 } if m.AllowResultReturn { i-- if m.AllowResultReturn { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x28 } if len(m.FrontendOpt) > 0 { for k := range m.FrontendOpt { v := m.FrontendOpt[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x1a } } if len(m.Frontend) > 0 { i -= len(m.Frontend) copy(dAtA[i:], m.Frontend) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Frontend))) i-- dAtA[i] = 0x12 } if m.Definition != nil { size, err := m.Definition.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *CacheOptionsEntry) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CacheOptionsEntry) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *CacheOptionsEntry) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Attrs) > 0 { for k := range m.Attrs { v := m.Attrs[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x12 } } if len(m.Type) > 0 { i -= len(m.Type) copy(dAtA[i:], m.Type) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Type))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *SolveResponse) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SolveResponse) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *SolveResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if m.Result != nil { size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x1a } if len(m.Ref) > 0 { i -= len(m.Ref) copy(dAtA[i:], m.Ref) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ref))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ReadFileRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReadFileRequest) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ReadFileRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if m.Range != nil { size, err := m.Range.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x1a } if len(m.FilePath) > 0 { i -= len(m.FilePath) copy(dAtA[i:], m.FilePath) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FilePath))) i-- dAtA[i] = 0x12 } if len(m.Ref) > 0 { i -= len(m.Ref) copy(dAtA[i:], m.Ref) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ref))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *FileRange) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *FileRange) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *FileRange) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if m.Length != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Length)) i-- dAtA[i] = 0x10 } if m.Offset != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Offset)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *ReadFileResponse) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReadFileResponse) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ReadFileResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Data) > 0 { i -= len(m.Data) copy(dAtA[i:], m.Data) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Data))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ReadDirRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReadDirRequest) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ReadDirRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.IncludePattern) > 0 { i -= len(m.IncludePattern) copy(dAtA[i:], m.IncludePattern) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.IncludePattern))) i-- dAtA[i] = 0x1a } if len(m.DirPath) > 0 { i -= len(m.DirPath) copy(dAtA[i:], m.DirPath) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DirPath))) i-- dAtA[i] = 0x12 } if len(m.Ref) > 0 { i -= len(m.Ref) copy(dAtA[i:], m.Ref) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ref))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ReadDirResponse) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReadDirResponse) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ReadDirResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Entries) > 0 { for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- { if vtmsg, ok := interface{}(m.Entries[iNdEx]).(interface { MarshalToSizedBufferVT([]byte) (int, error) }); ok { size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) } else { encoded, err := proto.Marshal(m.Entries[iNdEx]) if err != nil { return 0, err } i -= len(encoded) copy(dAtA[i:], encoded) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded))) } i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *StatFileRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StatFileRequest) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *StatFileRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Path) > 0 { i -= len(m.Path) copy(dAtA[i:], m.Path) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Path))) i-- dAtA[i] = 0x12 } if len(m.Ref) > 0 { i -= len(m.Ref) copy(dAtA[i:], m.Ref) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ref))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *StatFileResponse) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StatFileResponse) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *StatFileResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if m.Stat != nil { if vtmsg, ok := interface{}(m.Stat).(interface { MarshalToSizedBufferVT([]byte) (int, error) }); ok { size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) } else { encoded, err := proto.Marshal(m.Stat) if err != nil { return 0, err } i -= len(encoded) copy(dAtA[i:], encoded) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded))) } i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *EvaluateRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *EvaluateRequest) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *EvaluateRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Ref) > 0 { i -= len(m.Ref) copy(dAtA[i:], m.Ref) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ref))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *EvaluateResponse) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *EvaluateResponse) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *EvaluateResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } return len(dAtA) - i, nil } func (m *PingRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PingRequest) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *PingRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } return len(dAtA) - i, nil } func (m *PongResponse) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PongResponse) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *PongResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Workers) > 0 { for iNdEx := len(m.Workers) - 1; iNdEx >= 0; iNdEx-- { size, err := m.Workers[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x1a } } if len(m.LLBCaps) > 0 { for iNdEx := len(m.LLBCaps) - 1; iNdEx >= 0; iNdEx-- { size, err := m.LLBCaps[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x12 } } if len(m.FrontendAPICaps) > 0 { for iNdEx := len(m.FrontendAPICaps) - 1; iNdEx >= 0; iNdEx-- { size, err := m.FrontendAPICaps[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *WarnRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WarnRequest) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *WarnRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Ranges) > 0 { for iNdEx := len(m.Ranges) - 1; iNdEx >= 0; iNdEx-- { size, err := m.Ranges[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x3a } } if m.Info != nil { size, err := m.Info.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x32 } if len(m.Url) > 0 { i -= len(m.Url) copy(dAtA[i:], m.Url) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Url))) i-- dAtA[i] = 0x2a } if len(m.Detail) > 0 { for iNdEx := len(m.Detail) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Detail[iNdEx]) copy(dAtA[i:], m.Detail[iNdEx]) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Detail[iNdEx]))) i-- dAtA[i] = 0x22 } } if len(m.Short) > 0 { i -= len(m.Short) copy(dAtA[i:], m.Short) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Short))) i-- dAtA[i] = 0x1a } if m.Level != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Level)) i-- dAtA[i] = 0x10 } if len(m.Digest) > 0 { i -= len(m.Digest) copy(dAtA[i:], m.Digest) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Digest))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *WarnResponse) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WarnResponse) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *WarnResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } return len(dAtA) - i, nil } func (m *NewContainerRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *NewContainerRequest) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *NewContainerRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Hostname) > 0 { i -= len(m.Hostname) copy(dAtA[i:], m.Hostname) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostname))) i-- dAtA[i] = 0x3a } if len(m.ExtraHosts) > 0 { for iNdEx := len(m.ExtraHosts) - 1; iNdEx >= 0; iNdEx-- { size, err := m.ExtraHosts[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x32 } } if m.Constraints != nil { size, err := m.Constraints.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x2a } if m.Platform != nil { size, err := m.Platform.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x22 } if m.Network != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Network)) i-- dAtA[i] = 0x18 } if len(m.Mounts) > 0 { for iNdEx := len(m.Mounts) - 1; iNdEx >= 0; iNdEx-- { size, err := m.Mounts[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x12 } } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *NewContainerResponse) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *NewContainerResponse) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *NewContainerResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } return len(dAtA) - i, nil } func (m *ReleaseContainerRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReleaseContainerRequest) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ReleaseContainerRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ReleaseContainerResponse) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReleaseContainerResponse) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ReleaseContainerResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } return len(dAtA) - i, nil } func (m *ExecMessage) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ExecMessage) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ExecMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if vtmsg, ok := m.Input.(interface { MarshalToSizedBufferVT([]byte) (int, error) }); ok { size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size } if len(m.ProcessID) > 0 { i -= len(m.ProcessID) copy(dAtA[i:], m.ProcessID) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ProcessID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ExecMessage_Init) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ExecMessage_Init) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i := len(dAtA) if m.Init != nil { size, err := m.Init.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x12 } else { i = protohelpers.EncodeVarint(dAtA, i, 0) i-- dAtA[i] = 0x12 } return len(dAtA) - i, nil } func (m *ExecMessage_File) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ExecMessage_File) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i := len(dAtA) if m.File != nil { size, err := m.File.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x1a } else { i = protohelpers.EncodeVarint(dAtA, i, 0) i-- dAtA[i] = 0x1a } return len(dAtA) - i, nil } func (m *ExecMessage_Resize) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ExecMessage_Resize) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i := len(dAtA) if m.Resize != nil { size, err := m.Resize.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x22 } else { i = protohelpers.EncodeVarint(dAtA, i, 0) i-- dAtA[i] = 0x22 } return len(dAtA) - i, nil } func (m *ExecMessage_Started) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ExecMessage_Started) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i := len(dAtA) if m.Started != nil { size, err := m.Started.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x2a } else { i = protohelpers.EncodeVarint(dAtA, i, 0) i-- dAtA[i] = 0x2a } return len(dAtA) - i, nil } func (m *ExecMessage_Exit) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ExecMessage_Exit) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i := len(dAtA) if m.Exit != nil { size, err := m.Exit.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x32 } else { i = protohelpers.EncodeVarint(dAtA, i, 0) i-- dAtA[i] = 0x32 } return len(dAtA) - i, nil } func (m *ExecMessage_Done) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ExecMessage_Done) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i := len(dAtA) if m.Done != nil { size, err := m.Done.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x3a } else { i = protohelpers.EncodeVarint(dAtA, i, 0) i-- dAtA[i] = 0x3a } return len(dAtA) - i, nil } func (m *ExecMessage_Signal) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ExecMessage_Signal) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i := len(dAtA) if m.Signal != nil { size, err := m.Signal.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x42 } else { i = protohelpers.EncodeVarint(dAtA, i, 0) i-- dAtA[i] = 0x42 } return len(dAtA) - i, nil } func (m *InitMessage) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *InitMessage) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *InitMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Secretenv) > 0 { for iNdEx := len(m.Secretenv) - 1; iNdEx >= 0; iNdEx-- { size, err := m.Secretenv[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x32 } } if m.Security != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Security)) i-- dAtA[i] = 0x28 } if m.Tty { i-- if m.Tty { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x20 } if len(m.Fds) > 0 { var pksize2 int for _, num := range m.Fds { pksize2 += protohelpers.SizeOfVarint(uint64(num)) } i -= pksize2 j1 := i for _, num := range m.Fds { for num >= 1<<7 { dAtA[j1] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j1++ } dAtA[j1] = uint8(num) j1++ } i = protohelpers.EncodeVarint(dAtA, i, uint64(pksize2)) i-- dAtA[i] = 0x1a } if m.Meta != nil { size, err := m.Meta.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x12 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ExitMessage) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ExitMessage) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ExitMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if m.Error != nil { if vtmsg, ok := interface{}(m.Error).(interface { MarshalToSizedBufferVT([]byte) (int, error) }); ok { size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) } else { encoded, err := proto.Marshal(m.Error) if err != nil { return 0, err } i -= len(encoded) copy(dAtA[i:], encoded) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded))) } i-- dAtA[i] = 0x12 } if m.Code != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Code)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *StartedMessage) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StartedMessage) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *StartedMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } return len(dAtA) - i, nil } func (m *DoneMessage) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DoneMessage) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *DoneMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } return len(dAtA) - i, nil } func (m *FdMessage) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *FdMessage) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *FdMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Data) > 0 { i -= len(m.Data) copy(dAtA[i:], m.Data) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Data))) i-- dAtA[i] = 0x1a } if m.EOF { i-- if m.EOF { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x10 } if m.Fd != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Fd)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *ResizeMessage) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ResizeMessage) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *ResizeMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if m.Cols != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Cols)) i-- dAtA[i] = 0x10 } if m.Rows != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Rows)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *SignalMessage) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SignalMessage) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *SignalMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Name) > 0 { i -= len(m.Name) copy(dAtA[i:], m.Name) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *Result) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if vtmsg, ok := m.Result.(interface{ SizeVT() int }); ok { n += vtmsg.SizeVT() } if len(m.Metadata) > 0 { for k, v := range m.Metadata { _ = k _ = v l = 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v))) mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) } } if len(m.Attestations) > 0 { for k, v := range m.Attestations { _ = k _ = v l = 0 if v != nil { l = v.SizeVT() } l += 1 + protohelpers.SizeOfVarint(uint64(l)) mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) } } n += len(m.unknownFields) return n } func (m *Result_RefDeprecated) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.RefDeprecated) n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) return n } func (m *Result_RefsDeprecated) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.RefsDeprecated != nil { l = m.RefsDeprecated.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } else { n += 3 } return n } func (m *Result_Ref) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Ref != nil { l = m.Ref.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } else { n += 3 } return n } func (m *Result_Refs) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Refs != nil { l = m.Refs.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } else { n += 3 } return n } func (m *RefMapDeprecated) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Refs) > 0 { for k, v := range m.Refs { _ = k _ = v mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v))) n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) } } n += len(m.unknownFields) return n } func (m *Ref) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Id) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if m.Def != nil { l = m.Def.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) return n } func (m *RefMap) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Refs) > 0 { for k, v := range m.Refs { _ = k _ = v l = 0 if v != nil { l = v.SizeVT() } l += 1 + protohelpers.SizeOfVarint(uint64(l)) mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) } } n += len(m.unknownFields) return n } func (m *Attestations) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Attestation) > 0 { for _, e := range m.Attestation { l = e.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } } n += len(m.unknownFields) return n } func (m *Attestation) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Kind != 0 { n += 1 + protohelpers.SizeOfVarint(uint64(m.Kind)) } if len(m.Metadata) > 0 { for k, v := range m.Metadata { _ = k _ = v l = 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v))) mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) } } if m.Ref != nil { l = m.Ref.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } l = len(m.Path) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } l = len(m.InTotoPredicateType) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if len(m.InTotoSubjects) > 0 { for _, e := range m.InTotoSubjects { l = e.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } } n += len(m.unknownFields) return n } func (m *InTotoSubject) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Kind != 0 { n += 1 + protohelpers.SizeOfVarint(uint64(m.Kind)) } if len(m.Digest) > 0 { for _, s := range m.Digest { l = len(s) n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } } l = len(m.Name) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) return n } func (m *ReturnRequest) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Result != nil { l = m.Result.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if m.Error != nil { if size, ok := interface{}(m.Error).(interface { SizeVT() int }); ok { l = size.SizeVT() } else { l = proto.Size(m.Error) } n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) return n } func (m *ReturnResponse) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l n += len(m.unknownFields) return n } func (m *InputsRequest) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l n += len(m.unknownFields) return n } func (m *InputsResponse) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Definitions) > 0 { for k, v := range m.Definitions { _ = k _ = v l = 0 if v != nil { l = v.SizeVT() } l += 1 + protohelpers.SizeOfVarint(uint64(l)) mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) } } n += len(m.unknownFields) return n } func (m *ResolveImageConfigRequest) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Ref) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if m.Platform != nil { l = m.Platform.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } l = len(m.ResolveMode) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } l = len(m.LogName) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if m.ResolverType != 0 { n += 1 + protohelpers.SizeOfVarint(uint64(m.ResolverType)) } l = len(m.SessionID) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } l = len(m.StoreID) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if len(m.SourcePolicies) > 0 { for _, e := range m.SourcePolicies { l = e.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } } n += len(m.unknownFields) return n } func (m *ResolveImageConfigResponse) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Digest) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } l = len(m.Config) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } l = len(m.Ref) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) return n } func (m *ResolveSourceMetaRequest) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Source != nil { l = m.Source.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if m.Platform != nil { l = m.Platform.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } l = len(m.LogName) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } l = len(m.ResolveMode) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if len(m.SourcePolicies) > 0 { for _, e := range m.SourcePolicies { l = e.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } } n += len(m.unknownFields) return n } func (m *ResolveSourceMetaResponse) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Source != nil { l = m.Source.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if m.Image != nil { l = m.Image.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) return n } func (m *ResolveSourceImageResponse) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Digest) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } l = len(m.Config) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) return n } func (m *SolveRequest) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Definition != nil { l = m.Definition.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } l = len(m.Frontend) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if len(m.FrontendOpt) > 0 { for k, v := range m.FrontendOpt { _ = k _ = v mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v))) n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) } } if m.AllowResultReturn { n += 2 } if m.AllowResultArrayRef { n += 2 } if m.Final { n += 2 } l = len(m.ExporterAttr) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if len(m.CacheImports) > 0 { for _, e := range m.CacheImports { l = e.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } } if len(m.FrontendInputs) > 0 { for k, v := range m.FrontendInputs { _ = k _ = v l = 0 if v != nil { l = v.SizeVT() } l += 1 + protohelpers.SizeOfVarint(uint64(l)) mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) } } if m.Evaluate { n += 2 } if len(m.SourcePolicies) > 0 { for _, e := range m.SourcePolicies { l = e.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } } n += len(m.unknownFields) return n } func (m *CacheOptionsEntry) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Type) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if len(m.Attrs) > 0 { for k, v := range m.Attrs { _ = k _ = v mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v))) n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) } } n += len(m.unknownFields) return n } func (m *SolveResponse) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Ref) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if m.Result != nil { l = m.Result.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) return n } func (m *ReadFileRequest) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Ref) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } l = len(m.FilePath) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if m.Range != nil { l = m.Range.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) return n } func (m *FileRange) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Offset != 0 { n += 1 + protohelpers.SizeOfVarint(uint64(m.Offset)) } if m.Length != 0 { n += 1 + protohelpers.SizeOfVarint(uint64(m.Length)) } n += len(m.unknownFields) return n } func (m *ReadFileResponse) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Data) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) return n } func (m *ReadDirRequest) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Ref) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } l = len(m.DirPath) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } l = len(m.IncludePattern) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) return n } func (m *ReadDirResponse) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Entries) > 0 { for _, e := range m.Entries { if size, ok := interface{}(e).(interface { SizeVT() int }); ok { l = size.SizeVT() } else { l = proto.Size(e) } n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } } n += len(m.unknownFields) return n } func (m *StatFileRequest) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Ref) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } l = len(m.Path) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) return n } func (m *StatFileResponse) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Stat != nil { if size, ok := interface{}(m.Stat).(interface { SizeVT() int }); ok { l = size.SizeVT() } else { l = proto.Size(m.Stat) } n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) return n } func (m *EvaluateRequest) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Ref) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) return n } func (m *EvaluateResponse) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l n += len(m.unknownFields) return n } func (m *PingRequest) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l n += len(m.unknownFields) return n } func (m *PongResponse) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if len(m.FrontendAPICaps) > 0 { for _, e := range m.FrontendAPICaps { l = e.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } } if len(m.LLBCaps) > 0 { for _, e := range m.LLBCaps { l = e.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } } if len(m.Workers) > 0 { for _, e := range m.Workers { l = e.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } } n += len(m.unknownFields) return n } func (m *WarnRequest) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Digest) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if m.Level != 0 { n += 1 + protohelpers.SizeOfVarint(uint64(m.Level)) } l = len(m.Short) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if len(m.Detail) > 0 { for _, b := range m.Detail { l = len(b) n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } } l = len(m.Url) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if m.Info != nil { l = m.Info.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if len(m.Ranges) > 0 { for _, e := range m.Ranges { l = e.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } } n += len(m.unknownFields) return n } func (m *WarnResponse) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l n += len(m.unknownFields) return n } func (m *NewContainerRequest) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if len(m.Mounts) > 0 { for _, e := range m.Mounts { l = e.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } } if m.Network != 0 { n += 1 + protohelpers.SizeOfVarint(uint64(m.Network)) } if m.Platform != nil { l = m.Platform.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if m.Constraints != nil { l = m.Constraints.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if len(m.ExtraHosts) > 0 { for _, e := range m.ExtraHosts { l = e.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } } l = len(m.Hostname) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) return n } func (m *NewContainerResponse) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l n += len(m.unknownFields) return n } func (m *ReleaseContainerRequest) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) return n } func (m *ReleaseContainerResponse) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l n += len(m.unknownFields) return n } func (m *ExecMessage) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ProcessID) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if vtmsg, ok := m.Input.(interface{ SizeVT() int }); ok { n += vtmsg.SizeVT() } n += len(m.unknownFields) return n } func (m *ExecMessage_Init) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Init != nil { l = m.Init.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } else { n += 3 } return n } func (m *ExecMessage_File) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.File != nil { l = m.File.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } else { n += 3 } return n } func (m *ExecMessage_Resize) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Resize != nil { l = m.Resize.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } else { n += 3 } return n } func (m *ExecMessage_Started) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Started != nil { l = m.Started.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } else { n += 3 } return n } func (m *ExecMessage_Exit) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Exit != nil { l = m.Exit.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } else { n += 3 } return n } func (m *ExecMessage_Done) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Done != nil { l = m.Done.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } else { n += 3 } return n } func (m *ExecMessage_Signal) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Signal != nil { l = m.Signal.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } else { n += 3 } return n } func (m *InitMessage) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if m.Meta != nil { l = m.Meta.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if len(m.Fds) > 0 { l = 0 for _, e := range m.Fds { l += protohelpers.SizeOfVarint(uint64(e)) } n += 1 + protohelpers.SizeOfVarint(uint64(l)) + l } if m.Tty { n += 2 } if m.Security != 0 { n += 1 + protohelpers.SizeOfVarint(uint64(m.Security)) } if len(m.Secretenv) > 0 { for _, e := range m.Secretenv { l = e.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } } n += len(m.unknownFields) return n } func (m *ExitMessage) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Code != 0 { n += 1 + protohelpers.SizeOfVarint(uint64(m.Code)) } if m.Error != nil { if size, ok := interface{}(m.Error).(interface { SizeVT() int }); ok { l = size.SizeVT() } else { l = proto.Size(m.Error) } n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) return n } func (m *StartedMessage) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l n += len(m.unknownFields) return n } func (m *DoneMessage) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l n += len(m.unknownFields) return n } func (m *FdMessage) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Fd != 0 { n += 1 + protohelpers.SizeOfVarint(uint64(m.Fd)) } if m.EOF { n += 2 } l = len(m.Data) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) return n } func (m *ResizeMessage) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Rows != 0 { n += 1 + protohelpers.SizeOfVarint(uint64(m.Rows)) } if m.Cols != 0 { n += 1 + protohelpers.SizeOfVarint(uint64(m.Cols)) } n += len(m.unknownFields) return n } func (m *SignalMessage) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) return n } func (m *Result) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Result: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Result: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RefDeprecated", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Result = &Result_RefDeprecated{RefDeprecated: string(dAtA[iNdEx:postIndex])} iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RefsDeprecated", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Result.(*Result_RefsDeprecated); ok { if err := oneof.RefsDeprecated.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &RefMapDeprecated{} if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } m.Result = &Result_RefsDeprecated{RefsDeprecated: v} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Result.(*Result_Ref); ok { if err := oneof.Ref.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &Ref{} if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } m.Result = &Result_Ref{Ref: v} } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Refs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Result.(*Result_Refs); ok { if err := oneof.Refs.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &RefMap{} if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } m.Result = &Result_Refs{Refs: v} } iNdEx = postIndex case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Metadata == nil { m.Metadata = make(map[string][]byte) } var mapkey string var mapvalue []byte for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return protohelpers.ErrInvalidLength } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return protohelpers.ErrInvalidLength } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var mapbyteLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ mapbyteLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intMapbyteLen := int(mapbyteLen) if intMapbyteLen < 0 { return protohelpers.ErrInvalidLength } postbytesIndex := iNdEx + intMapbyteLen if postbytesIndex < 0 { return protohelpers.ErrInvalidLength } if postbytesIndex > l { return io.ErrUnexpectedEOF } mapvalue = make([]byte, mapbyteLen) copy(mapvalue, dAtA[iNdEx:postbytesIndex]) iNdEx = postbytesIndex } else { iNdEx = entryPreIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Metadata[mapkey] = mapvalue iNdEx = postIndex case 12: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Attestations", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Attestations == nil { m.Attestations = make(map[string]*Attestations) } var mapkey string var mapvalue *Attestations for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return protohelpers.ErrInvalidLength } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return protohelpers.ErrInvalidLength } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var mapmsglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ mapmsglen |= int(b&0x7F) << shift if b < 0x80 { break } } if mapmsglen < 0 { return protohelpers.ErrInvalidLength } postmsgIndex := iNdEx + mapmsglen if postmsgIndex < 0 { return protohelpers.ErrInvalidLength } if postmsgIndex > l { return io.ErrUnexpectedEOF } mapvalue = &Attestations{} if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil { return err } iNdEx = postmsgIndex } else { iNdEx = entryPreIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Attestations[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *RefMapDeprecated) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: RefMapDeprecated: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RefMapDeprecated: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Refs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Refs == nil { m.Refs = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return protohelpers.ErrInvalidLength } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return protohelpers.ErrInvalidLength } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return protohelpers.ErrInvalidLength } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return protohelpers.ErrInvalidLength } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Refs[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *Ref) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Ref: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Ref: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Id = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Def", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Def == nil { m.Def = &pb.Definition{} } if err := m.Def.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *RefMap) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: RefMap: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RefMap: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Refs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Refs == nil { m.Refs = make(map[string]*Ref) } var mapkey string var mapvalue *Ref for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return protohelpers.ErrInvalidLength } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return protohelpers.ErrInvalidLength } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var mapmsglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ mapmsglen |= int(b&0x7F) << shift if b < 0x80 { break } } if mapmsglen < 0 { return protohelpers.ErrInvalidLength } postmsgIndex := iNdEx + mapmsglen if postmsgIndex < 0 { return protohelpers.ErrInvalidLength } if postmsgIndex > l { return io.ErrUnexpectedEOF } mapvalue = &Ref{} if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil { return err } iNdEx = postmsgIndex } else { iNdEx = entryPreIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Refs[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *Attestations) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Attestations: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Attestations: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Attestation", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Attestation = append(m.Attestation, &Attestation{}) if err := m.Attestation[len(m.Attestation)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *Attestation) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Attestation: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Attestation: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) } m.Kind = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Kind |= AttestationKind(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Metadata == nil { m.Metadata = make(map[string][]byte) } var mapkey string var mapvalue []byte for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return protohelpers.ErrInvalidLength } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return protohelpers.ErrInvalidLength } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var mapbyteLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ mapbyteLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intMapbyteLen := int(mapbyteLen) if intMapbyteLen < 0 { return protohelpers.ErrInvalidLength } postbytesIndex := iNdEx + intMapbyteLen if postbytesIndex < 0 { return protohelpers.ErrInvalidLength } if postbytesIndex > l { return io.ErrUnexpectedEOF } mapvalue = make([]byte, mapbyteLen) copy(mapvalue, dAtA[iNdEx:postbytesIndex]) iNdEx = postbytesIndex } else { iNdEx = entryPreIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Metadata[mapkey] = mapvalue iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Ref == nil { m.Ref = &Ref{} } if err := m.Ref.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Path = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field InTotoPredicateType", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.InTotoPredicateType = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field InTotoSubjects", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.InTotoSubjects = append(m.InTotoSubjects, &InTotoSubject{}) if err := m.InTotoSubjects[len(m.InTotoSubjects)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *InTotoSubject) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: InTotoSubject: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: InTotoSubject: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) } m.Kind = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Kind |= InTotoSubjectKind(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Digest = append(m.Digest, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ReturnRequest) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ReturnRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReturnRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Result == nil { m.Result = &Result{} } if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &status.Status{} } if unmarshal, ok := interface{}(m.Error).(interface { UnmarshalVT([]byte) error }); ok { if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } } else { if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Error); err != nil { return err } } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ReturnResponse) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ReturnResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReturnResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *InputsRequest) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: InputsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: InputsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *InputsResponse) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: InputsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: InputsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Definitions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Definitions == nil { m.Definitions = make(map[string]*pb.Definition) } var mapkey string var mapvalue *pb.Definition for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return protohelpers.ErrInvalidLength } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return protohelpers.ErrInvalidLength } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var mapmsglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ mapmsglen |= int(b&0x7F) << shift if b < 0x80 { break } } if mapmsglen < 0 { return protohelpers.ErrInvalidLength } postmsgIndex := iNdEx + mapmsglen if postmsgIndex < 0 { return protohelpers.ErrInvalidLength } if postmsgIndex > l { return io.ErrUnexpectedEOF } mapvalue = &pb.Definition{} if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil { return err } iNdEx = postmsgIndex } else { iNdEx = entryPreIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Definitions[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ResolveImageConfigRequest) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ResolveImageConfigRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ResolveImageConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Ref = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Platform", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Platform == nil { m.Platform = &pb.Platform{} } if err := m.Platform.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ResolveMode", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.ResolveMode = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LogName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.LogName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ResolverType", wireType) } m.ResolverType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ResolverType |= int32(b&0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SessionID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.SessionID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StoreID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.StoreID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SourcePolicies", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.SourcePolicies = append(m.SourcePolicies, &pb1.Policy{}) if err := m.SourcePolicies[len(m.SourcePolicies)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ResolveImageConfigResponse) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ResolveImageConfigResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ResolveImageConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Digest = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + byteLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Config = append(m.Config[:0], dAtA[iNdEx:postIndex]...) if m.Config == nil { m.Config = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Ref = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ResolveSourceMetaRequest) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ResolveSourceMetaRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ResolveSourceMetaRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Source == nil { m.Source = &pb.SourceOp{} } if err := m.Source.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Platform", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Platform == nil { m.Platform = &pb.Platform{} } if err := m.Platform.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LogName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.LogName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ResolveMode", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.ResolveMode = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SourcePolicies", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.SourcePolicies = append(m.SourcePolicies, &pb1.Policy{}) if err := m.SourcePolicies[len(m.SourcePolicies)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ResolveSourceMetaResponse) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ResolveSourceMetaResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ResolveSourceMetaResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Source == nil { m.Source = &pb.SourceOp{} } if err := m.Source.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Image == nil { m.Image = &ResolveSourceImageResponse{} } if err := m.Image.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ResolveSourceImageResponse) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ResolveSourceImageResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ResolveSourceImageResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Digest = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + byteLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Config = append(m.Config[:0], dAtA[iNdEx:postIndex]...) if m.Config == nil { m.Config = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *SolveRequest) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: SolveRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SolveRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Definition", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Definition == nil { m.Definition = &pb.Definition{} } if err := m.Definition.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Frontend", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Frontend = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field FrontendOpt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.FrontendOpt == nil { m.FrontendOpt = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return protohelpers.ErrInvalidLength } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return protohelpers.ErrInvalidLength } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return protohelpers.ErrInvalidLength } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return protohelpers.ErrInvalidLength } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.FrontendOpt[mapkey] = mapvalue iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field AllowResultReturn", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int(b&0x7F) << shift if b < 0x80 { break } } m.AllowResultReturn = bool(v != 0) case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field AllowResultArrayRef", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int(b&0x7F) << shift if b < 0x80 { break } } m.AllowResultArrayRef = bool(v != 0) case 10: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Final", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int(b&0x7F) << shift if b < 0x80 { break } } m.Final = bool(v != 0) case 11: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExporterAttr", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + byteLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.ExporterAttr = append(m.ExporterAttr[:0], dAtA[iNdEx:postIndex]...) if m.ExporterAttr == nil { m.ExporterAttr = []byte{} } iNdEx = postIndex case 12: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CacheImports", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.CacheImports = append(m.CacheImports, &CacheOptionsEntry{}) if err := m.CacheImports[len(m.CacheImports)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 13: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field FrontendInputs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.FrontendInputs == nil { m.FrontendInputs = make(map[string]*pb.Definition) } var mapkey string var mapvalue *pb.Definition for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return protohelpers.ErrInvalidLength } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return protohelpers.ErrInvalidLength } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var mapmsglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ mapmsglen |= int(b&0x7F) << shift if b < 0x80 { break } } if mapmsglen < 0 { return protohelpers.ErrInvalidLength } postmsgIndex := iNdEx + mapmsglen if postmsgIndex < 0 { return protohelpers.ErrInvalidLength } if postmsgIndex > l { return io.ErrUnexpectedEOF } mapvalue = &pb.Definition{} if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil { return err } iNdEx = postmsgIndex } else { iNdEx = entryPreIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.FrontendInputs[mapkey] = mapvalue iNdEx = postIndex case 14: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Evaluate", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int(b&0x7F) << shift if b < 0x80 { break } } m.Evaluate = bool(v != 0) case 15: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SourcePolicies", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.SourcePolicies = append(m.SourcePolicies, &pb1.Policy{}) if err := m.SourcePolicies[len(m.SourcePolicies)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *CacheOptionsEntry) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: CacheOptionsEntry: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CacheOptionsEntry: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Type = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Attrs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Attrs == nil { m.Attrs = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return protohelpers.ErrInvalidLength } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return protohelpers.ErrInvalidLength } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return protohelpers.ErrInvalidLength } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return protohelpers.ErrInvalidLength } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Attrs[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *SolveResponse) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: SolveResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SolveResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Ref = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Result == nil { m.Result = &Result{} } if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ReadFileRequest) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ReadFileRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReadFileRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Ref = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field FilePath", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.FilePath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Range == nil { m.Range = &FileRange{} } if err := m.Range.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *FileRange) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: FileRange: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: FileRange: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType) } m.Offset = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Offset |= int64(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType) } m.Length = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Length |= int64(b&0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ReadFileResponse) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ReadFileResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReadFileResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + byteLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) if m.Data == nil { m.Data = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ReadDirRequest) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ReadDirRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReadDirRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Ref = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DirPath", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.DirPath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field IncludePattern", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.IncludePattern = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ReadDirResponse) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ReadDirResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReadDirResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Entries = append(m.Entries, &types.Stat{}) if unmarshal, ok := interface{}(m.Entries[len(m.Entries)-1]).(interface { UnmarshalVT([]byte) error }); ok { if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } } else { if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Entries[len(m.Entries)-1]); err != nil { return err } } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *StatFileRequest) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: StatFileRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StatFileRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Ref = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Path = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *StatFileResponse) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: StatFileResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StatFileResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stat", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Stat == nil { m.Stat = &types.Stat{} } if unmarshal, ok := interface{}(m.Stat).(interface { UnmarshalVT([]byte) error }); ok { if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } } else { if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Stat); err != nil { return err } } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *EvaluateRequest) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: EvaluateRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: EvaluateRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Ref = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *EvaluateResponse) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: EvaluateResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: EvaluateResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *PingRequest) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: PingRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PingRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *PongResponse) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: PongResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PongResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field FrontendAPICaps", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.FrontendAPICaps = append(m.FrontendAPICaps, &pb2.APICap{}) if err := m.FrontendAPICaps[len(m.FrontendAPICaps)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LLBCaps", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.LLBCaps = append(m.LLBCaps, &pb2.APICap{}) if err := m.LLBCaps[len(m.LLBCaps)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Workers", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Workers = append(m.Workers, &types1.WorkerRecord{}) if err := m.Workers[len(m.Workers)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *WarnRequest) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: WarnRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WarnRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Digest = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Level", wireType) } m.Level = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Level |= int64(b&0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Short", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + byteLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Short = append(m.Short[:0], dAtA[iNdEx:postIndex]...) if m.Short == nil { m.Short = []byte{} } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Detail", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + byteLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Detail = append(m.Detail, make([]byte, postIndex-iNdEx)) copy(m.Detail[len(m.Detail)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Url = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Info == nil { m.Info = &pb.SourceInfo{} } if err := m.Info.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Ranges = append(m.Ranges, &pb.Range{}) if err := m.Ranges[len(m.Ranges)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *WarnResponse) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: WarnResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WarnResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *NewContainerRequest) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: NewContainerRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: NewContainerRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Mounts", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Mounts = append(m.Mounts, &pb.Mount{}) if err := m.Mounts[len(m.Mounts)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType) } m.Network = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Network |= pb.NetMode(b&0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Platform", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Platform == nil { m.Platform = &pb.Platform{} } if err := m.Platform.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Constraints", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Constraints == nil { m.Constraints = &pb.WorkerConstraints{} } if err := m.Constraints.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExtraHosts", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.ExtraHosts = append(m.ExtraHosts, &pb.HostIP{}) if err := m.ExtraHosts[len(m.ExtraHosts)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Hostname = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *NewContainerResponse) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: NewContainerResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: NewContainerResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ReleaseContainerRequest) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ReleaseContainerRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReleaseContainerRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ReleaseContainerResponse) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ReleaseContainerResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReleaseContainerResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ExecMessage) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ExecMessage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ExecMessage: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ProcessID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.ProcessID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Init", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Input.(*ExecMessage_Init); ok { if err := oneof.Init.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &InitMessage{} if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } m.Input = &ExecMessage_Init{Init: v} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field File", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Input.(*ExecMessage_File); ok { if err := oneof.File.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &FdMessage{} if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } m.Input = &ExecMessage_File{File: v} } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Resize", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Input.(*ExecMessage_Resize); ok { if err := oneof.Resize.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &ResizeMessage{} if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } m.Input = &ExecMessage_Resize{Resize: v} } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Started", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Input.(*ExecMessage_Started); ok { if err := oneof.Started.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &StartedMessage{} if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } m.Input = &ExecMessage_Started{Started: v} } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Exit", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Input.(*ExecMessage_Exit); ok { if err := oneof.Exit.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &ExitMessage{} if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } m.Input = &ExecMessage_Exit{Exit: v} } iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Done", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Input.(*ExecMessage_Done); ok { if err := oneof.Done.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &DoneMessage{} if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } m.Input = &ExecMessage_Done{Done: v} } iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Signal", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Input.(*ExecMessage_Signal); ok { if err := oneof.Signal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &SignalMessage{} if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } m.Input = &ExecMessage_Signal{Signal: v} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *InitMessage) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: InitMessage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: InitMessage: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Meta == nil { m.Meta = &pb.Meta{} } if err := m.Meta.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType == 0 { var v uint32 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= uint32(b&0x7F) << shift if b < 0x80 { break } } m.Fds = append(m.Fds, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= int(b&0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + packedLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } var elementCount int var count int for _, integer := range dAtA[iNdEx:postIndex] { if integer < 128 { count++ } } elementCount = count if elementCount != 0 && len(m.Fds) == 0 { m.Fds = make([]uint32, 0, elementCount) } for iNdEx < postIndex { var v uint32 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= uint32(b&0x7F) << shift if b < 0x80 { break } } m.Fds = append(m.Fds, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field Fds", wireType) } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Tty", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int(b&0x7F) << shift if b < 0x80 { break } } m.Tty = bool(v != 0) case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Security", wireType) } m.Security = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Security |= pb.SecurityMode(b&0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Secretenv", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Secretenv = append(m.Secretenv, &pb.SecretEnv{}) if err := m.Secretenv[len(m.Secretenv)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ExitMessage) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ExitMessage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ExitMessage: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) } m.Code = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Code |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &status.Status{} } if unmarshal, ok := interface{}(m.Error).(interface { UnmarshalVT([]byte) error }); ok { if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } } else { if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Error); err != nil { return err } } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *StartedMessage) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: StartedMessage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StartedMessage: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *DoneMessage) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: DoneMessage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DoneMessage: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *FdMessage) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: FdMessage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: FdMessage: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Fd", wireType) } m.Fd = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Fd |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EOF", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int(b&0x7F) << shift if b < 0x80 { break } } m.EOF = bool(v != 0) case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + byteLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) if m.Data == nil { m.Data = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ResizeMessage) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ResizeMessage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ResizeMessage: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Rows", wireType) } m.Rows = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Rows |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Cols", wireType) } m.Cols = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Cols |= uint32(b&0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *SignalMessage) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: SignalMessage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SignalMessage: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil }