/
versionedscanner.go
143 lines (128 loc) · 3.75 KB
/
versionedscanner.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
141
142
143
package indexer
import (
"context"
"net/http"
)
const (
Package = "package"
)
// VersionedScanner can be embedded into specific scanner types. This allows for
// methods and functions which only need to compare names and versions of
// scanners not to require each scanner type as an argument.
type VersionedScanner interface {
// unique name of the distribution scanner.
Name() string
// version of this scanner. this information will be persisted with the scan.
Version() string
// the kind of scanner. currently only package is implemented
Kind() string
}
// ConfigDeserializer can be thought of as an Unmarshal function with the byte
// slice provided.
//
// This will typically be something like (*json.Decoder).Decode.
type ConfigDeserializer func(interface{}) error
// RPCScanner is an interface scanners can implement to receive configuration
// and denote that they expect to be able to talk to the network at run time.
type RPCScanner interface {
Configure(context.Context, ConfigDeserializer, *http.Client) error
}
// ConfigurableScanner is an interface scanners can implement to receive
// configuration.
type ConfigurableScanner interface {
Configure(context.Context, ConfigDeserializer) error
}
// VersionedScanners implements a list with construction methods
// not concurrency safe
type VersionedScanners []VersionedScanner
func (vs *VersionedScanners) PStoVS(scnrs []PackageScanner) {
n := len(scnrs)
if cap(*vs) < n {
*vs = make([]VersionedScanner, n)
} else {
*vs = (*vs)[:n]
}
for i := 0; i < n; i++ {
(*vs)[i] = scnrs[i]
}
}
// VStoPS returns an array of PackageScanners
func (vs VersionedScanners) VStoPS() []PackageScanner {
out := make([]PackageScanner, len(vs))
for _, vscnr := range vs {
out = append(out, vscnr.(PackageScanner))
}
return out
}
// DStoVS takes an array of DistributionScanners and appends VersionedScanners with
// VersionScanner types.
func (vs *VersionedScanners) DStoVS(scnrs []DistributionScanner) {
n := len(scnrs)
if cap(*vs) < n {
*vs = make([]VersionedScanner, n)
} else {
*vs = (*vs)[:n]
}
for i := 0; i < n; i++ {
(*vs)[i] = scnrs[i]
}
}
// VStoDS returns an array of DistributionScanners
func (vs VersionedScanners) VStoDS() []DistributionScanner {
out := make([]DistributionScanner, len(vs))
for _, vscnr := range vs {
out = append(out, vscnr.(DistributionScanner))
}
return out
}
// RStoVS takes an array of RepositoryScanners and appends VersionedScanners with
// VersionScanner types.
func (vs *VersionedScanners) RStoVS(scnrs []RepositoryScanner) {
n := len(scnrs)
if cap(*vs) < n {
*vs = make([]VersionedScanner, n)
} else {
*vs = (*vs)[:n]
}
for i := 0; i < n; i++ {
(*vs)[i] = scnrs[i]
}
}
// VStoRS returns an array of RepositoryScanners
func (vs VersionedScanners) VStoRS() []RepositoryScanner {
out := make([]RepositoryScanner, len(vs))
for _, vscnr := range vs {
out = append(out, vscnr.(RepositoryScanner))
}
return out
}
// FStoVS takes an array of FileScanners and appends VersionedScanners with
// VersionScanner types.
func (vs *VersionedScanners) FStoVS(scnrs []FileScanner) {
n := len(scnrs)
if cap(*vs) < n {
*vs = make([]VersionedScanner, n)
} else {
*vs = (*vs)[:n]
}
for i := 0; i < n; i++ {
(*vs)[i] = scnrs[i]
}
}
// MergeVS merges lists of scanners into a single list of VersionedScanner types
func MergeVS(pscnr []PackageScanner, dscnr []DistributionScanner, rscnr []RepositoryScanner, fscnr []FileScanner) VersionedScanners {
out := make([]VersionedScanner, 0)
for _, ps := range pscnr {
out = append(out, VersionedScanner(ps))
}
for _, ds := range dscnr {
out = append(out, VersionedScanner(ds))
}
for _, rs := range rscnr {
out = append(out, VersionedScanner(rs))
}
for _, fs := range fscnr {
out = append(out, VersionedScanner(fs))
}
return out
}