/
repo.go
140 lines (107 loc) · 2.55 KB
/
repo.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
/*
* Copyright 2019 Zachary Schneider
*/
package zps
import (
"sort"
"time"
)
type Repo struct {
Uri string
Priority int
Enabled bool
Updated time.Time
channels map[string]bool
solvables Solvables
index map[string]Solvables
}
type Repos []*Repo
func NewRepo(uri string, priority int, enabled bool, channels []string, solvables Solvables) *Repo {
repo := &Repo{Uri: uri, Priority: priority, Enabled: enabled, channels: make(map[string]bool), solvables: solvables}
repo.Index()
for _, ch := range channels {
repo.channels[ch] = true
}
return repo
}
func (r *Repo) Index() {
r.index = make(map[string]Solvables)
sort.Sort(r.solvables)
for _, solvable := range r.solvables {
r.index[solvable.Name()] = append(r.index[solvable.Name()], solvable)
}
}
func (r *Repo) Add(pkgs ...*Pkg) Solvables {
var rejects Solvables
for _, p := range pkgs {
if !r.Contains(p) {
r.solvables = append(r.solvables, p)
} else {
rejects = append(rejects, p)
}
}
r.Index()
return rejects
}
func (r *Repo) Remove(pkg *Pkg) error {
return nil
}
func (r *Repo) Contains(pkg *Pkg) bool {
if _, ok := r.index[pkg.Name()]; ok {
for _, candidate := range r.index[pkg.Name()] {
if candidate.Version().EXQ(pkg.Version()) {
return true
}
}
}
return false
}
func (r *Repo) Prune(count int) (Solvables, error) {
var pruned Solvables
var result Solvables
for name := range r.index {
for len(r.index[name]) > count {
var prune Solvable
prune, r.index[name] = r.index[name][len(r.index[name])-1], r.index[name][:len(r.index[name])-1]
pruned = append(pruned, prune)
}
result = append(result, r.index[name]...)
}
r.solvables = result
return pruned, nil
}
func (r *Repo) Load(pkgs []*Pkg) {
for _, pkg := range pkgs {
r.solvables = append(r.solvables, pkg)
}
r.Index()
}
func (r *Repo) Solvables() Solvables {
if len(r.channels) > 0 {
var filtered Solvables
for index, solvable := range r.solvables {
for _, ch := range solvable.Channels() {
if r.channels[ch] {
filtered = append(filtered, r.solvables[index])
break
}
}
}
return filtered
}
return r.solvables
}
func (slice Repos) Len() int {
return len(slice)
}
func (slice Repos) Less(i, j int) bool {
return slice[i].Priority < slice[j].Priority
}
func (slice Repos) Swap(i, j int) {
slice[i], slice[j] = slice[j], slice[i]
}