83 lines
1.8 KiB
Go
83 lines
1.8 KiB
Go
package docker
|
|
|
|
import "sort"
|
|
|
|
type imageSorter struct {
|
|
images []APIImages
|
|
by func(i1, i2 *APIImages) bool // Closure used in the Less method.
|
|
}
|
|
|
|
// Len is part of sort.Interface.
|
|
func (s *imageSorter) Len() int {
|
|
return len(s.images)
|
|
}
|
|
|
|
// Swap is part of sort.Interface.
|
|
func (s *imageSorter) Swap(i, j int) {
|
|
s.images[i], s.images[j] = s.images[j], s.images[i]
|
|
}
|
|
|
|
// Less is part of sort.Interface. It is implemented by calling the "by" closure in the sorter.
|
|
func (s *imageSorter) Less(i, j int) bool {
|
|
return s.by(&s.images[i], &s.images[j])
|
|
}
|
|
|
|
// Sort []ApiImages by most recent creation date and tag name.
|
|
func sortImagesByCreationAndTag(images []APIImages) {
|
|
creationAndTag := func(i1, i2 *APIImages) bool {
|
|
return i1.Created > i2.Created
|
|
}
|
|
|
|
sorter := &imageSorter{
|
|
images: images,
|
|
by: creationAndTag}
|
|
|
|
sort.Sort(sorter)
|
|
}
|
|
|
|
type portSorter struct {
|
|
ports []Port
|
|
by func(i, j Port) bool
|
|
}
|
|
|
|
func (s *portSorter) Len() int {
|
|
return len(s.ports)
|
|
}
|
|
|
|
func (s *portSorter) Swap(i, j int) {
|
|
s.ports[i], s.ports[j] = s.ports[j], s.ports[i]
|
|
}
|
|
|
|
func (s *portSorter) Less(i, j int) bool {
|
|
ip := s.ports[i]
|
|
jp := s.ports[j]
|
|
|
|
return s.by(ip, jp)
|
|
}
|
|
|
|
func sortPorts(ports []Port, predicate func(i, j Port) bool) {
|
|
s := &portSorter{ports, predicate}
|
|
sort.Sort(s)
|
|
}
|
|
|
|
type containerSorter struct {
|
|
containers []*Container
|
|
by func(i, j *Container) bool
|
|
}
|
|
|
|
func (s *containerSorter) Len() int {
|
|
return len(s.containers)
|
|
}
|
|
|
|
func (s *containerSorter) Swap(i, j int) {
|
|
s.containers[i], s.containers[j] = s.containers[j], s.containers[i]
|
|
}
|
|
|
|
func (s *containerSorter) Less(i, j int) bool {
|
|
return s.by(s.containers[i], s.containers[j])
|
|
}
|
|
|
|
func sortContainers(containers []*Container, predicate func(i, j *Container) bool) {
|
|
s := &containerSorter{containers, predicate}
|
|
sort.Sort(s)
|
|
}
|