mirror of
https://github.com/mudler/luet.git
synced 2025-07-13 15:14:33 +00:00
4adc0dc9b9
Instead of using gox on one side and an action to release, we can merge them together with goreleaser which will build for extra targets (arm, mips if needed in the future) and it also takes care of creating checksums, a source archive, and a changelog and creating a release with all the artifacts. All binaries should respect the old naming convention, so any scripts out there should still work. Signed-off-by: Itxaka <igarcia@suse.com>
116 lines
2.7 KiB
Go
116 lines
2.7 KiB
Go
// Copyright 2020 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Package order provides ordered access to messages and maps.
|
|
package order
|
|
|
|
import (
|
|
"sort"
|
|
"sync"
|
|
|
|
pref "google.golang.org/protobuf/reflect/protoreflect"
|
|
)
|
|
|
|
type messageField struct {
|
|
fd pref.FieldDescriptor
|
|
v pref.Value
|
|
}
|
|
|
|
var messageFieldPool = sync.Pool{
|
|
New: func() interface{} { return new([]messageField) },
|
|
}
|
|
|
|
type (
|
|
// FieldRnger is an interface for visiting all fields in a message.
|
|
// The protoreflect.Message type implements this interface.
|
|
FieldRanger interface{ Range(VisitField) }
|
|
// VisitField is called everytime a message field is visited.
|
|
VisitField = func(pref.FieldDescriptor, pref.Value) bool
|
|
)
|
|
|
|
// RangeFields iterates over the fields of fs according to the specified order.
|
|
func RangeFields(fs FieldRanger, less FieldOrder, fn VisitField) {
|
|
if less == nil {
|
|
fs.Range(fn)
|
|
return
|
|
}
|
|
|
|
// Obtain a pre-allocated scratch buffer.
|
|
p := messageFieldPool.Get().(*[]messageField)
|
|
fields := (*p)[:0]
|
|
defer func() {
|
|
if cap(fields) < 1024 {
|
|
*p = fields
|
|
messageFieldPool.Put(p)
|
|
}
|
|
}()
|
|
|
|
// Collect all fields in the message and sort them.
|
|
fs.Range(func(fd pref.FieldDescriptor, v pref.Value) bool {
|
|
fields = append(fields, messageField{fd, v})
|
|
return true
|
|
})
|
|
sort.Slice(fields, func(i, j int) bool {
|
|
return less(fields[i].fd, fields[j].fd)
|
|
})
|
|
|
|
// Visit the fields in the specified ordering.
|
|
for _, f := range fields {
|
|
if !fn(f.fd, f.v) {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
type mapEntry struct {
|
|
k pref.MapKey
|
|
v pref.Value
|
|
}
|
|
|
|
var mapEntryPool = sync.Pool{
|
|
New: func() interface{} { return new([]mapEntry) },
|
|
}
|
|
|
|
type (
|
|
// EntryRanger is an interface for visiting all fields in a message.
|
|
// The protoreflect.Map type implements this interface.
|
|
EntryRanger interface{ Range(VisitEntry) }
|
|
// VisitEntry is called everytime a map entry is visited.
|
|
VisitEntry = func(pref.MapKey, pref.Value) bool
|
|
)
|
|
|
|
// RangeEntries iterates over the entries of es according to the specified order.
|
|
func RangeEntries(es EntryRanger, less KeyOrder, fn VisitEntry) {
|
|
if less == nil {
|
|
es.Range(fn)
|
|
return
|
|
}
|
|
|
|
// Obtain a pre-allocated scratch buffer.
|
|
p := mapEntryPool.Get().(*[]mapEntry)
|
|
entries := (*p)[:0]
|
|
defer func() {
|
|
if cap(entries) < 1024 {
|
|
*p = entries
|
|
mapEntryPool.Put(p)
|
|
}
|
|
}()
|
|
|
|
// Collect all entries in the map and sort them.
|
|
es.Range(func(k pref.MapKey, v pref.Value) bool {
|
|
entries = append(entries, mapEntry{k, v})
|
|
return true
|
|
})
|
|
sort.Slice(entries, func(i, j int) bool {
|
|
return less(entries[i].k, entries[j].k)
|
|
})
|
|
|
|
// Visit the entries in the specified ordering.
|
|
for _, e := range entries {
|
|
if !fn(e.k, e.v) {
|
|
return
|
|
}
|
|
}
|
|
}
|