From e096ea05d4a800dc729f30f1fe2da4f586a3c67f Mon Sep 17 00:00:00 2001 From: Jeff Carr Date: Sun, 15 Dec 2024 15:56:13 -0600 Subject: [PATCH] Notes added by 'git notes append' --- df42b367e7d6aeb0ede367888a011b7445d1d7cf | 252 +++++++++++++++++++++++ 1 file changed, 252 insertions(+) diff --git a/df42b367e7d6aeb0ede367888a011b7445d1d7cf b/df42b367e7d6aeb0ede367888a011b7445d1d7cf index d6541c9..bd528d2 100644 --- a/df42b367e7d6aeb0ede367888a011b7445d1d7cf +++ b/df42b367e7d6aeb0ede367888a011b7445d1d7cf @@ -379,3 +379,255 @@ func file_gitTag_proto_init() { } // `autogen:gitTag.sort.pb.go` + +package gitpb + +// This file was autogenerated with autogenpb. +// go install go.wit.com/apps/autogenpb@latest +// +// You can use it on simple protobuf files +// The .proto file must have a singular and plural form of a message +// (for those of you that know ruby on rails, it's like that) +// +// You can mark which repos you want to auto generate sort.pb.go and marshal.pb.go files for +// +// For an example, +// go-clone go.wit.com/lib/protobuf/gitpb +// + +import ( + "fmt" + "os" + "sort" + "sync" +) + +type GitTagIterator struct { + sync.RWMutex + + packs []*GitTag + index int +} + +// NewGitTagIterator initializes a new iterator. +func NewGitTagIterator(packs []*GitTag) *GitTagIterator { + return &GitTagIterator{packs: packs} +} + +// Scan moves to the next element and returns false if there are no more packs. +// Use Scan() in a loop, similar to a while loop +// +// for iterator.Scan() +// d := iterator.Next( +// fmt.Println("found UUID:", d.Uuid +// } +func (it *GitTagIterator) Scan() bool { + if it.index >= len(it.packs) { + return false + } + it.index++ + return true +} + +// Next() returns the next thing in the array +func (it *GitTagIterator) Next() *GitTag { + if it.packs[it.index-1] == nil { + for i, d := range it.packs { + fmt.Println("i =", i, d) + } + fmt.Println("protobuf autogenpb sort error len =", len(it.packs)) + fmt.Println("protobuf autogenpb sort error next == nil", it.index, it.index-1) + os.Exit(-1) + } + return it.packs[it.index-1] +} + +// does not enforce any unique fields +func (all *GitTags) Append(newP *GitTag) bool { + all.Lock.RLock() + defer all.Lock.RUnlock() + + all.GitTags = append(all.GitTags, newP) + return true +} + +func (all *GitTags) All() *GitTagIterator { + gitTagPointers := all.selectAllGitTag() + + iterator := NewGitTagIterator(gitTagPointers) + return iterator +} + +func (all *GitTags) Len() int { + all.Lock.RLock() + defer all.Lock.RUnlock() + + return len(all.GitTags) +} + +func (all *GitTags) SortByRefname() *GitTagIterator { + packs := all.selectAllGitTag() + + sort.Sort(GitTagRefname(packs)) + + iterator := NewGitTagIterator(packs) + return iterator +} + +type GitTagRefname []*GitTag + +func (a GitTagRefname) Len() int { return len(a) } +func (a GitTagRefname) Less(i, j int) bool { return a[i].Refname < a[j].Refname } +func (a GitTagRefname) Swap(i, j int) { a[i], a[j] = a[j], a[i] } + +// enforces Refname is unique +func (all *GitTags) AppendUniqueRefname(newP *GitTag) bool { + all.Lock.RLock() + defer all.Lock.RUnlock() + + for _, p := range all.GitTags { + if p.Refname == newP.Refname { + return false + } + } + + all.GitTags = append(all.GitTags, newP) + return true +} + +func (all *GitTags) DeleteByRefname(s string) bool { + all.Lock.RLock() + defer all.Lock.RUnlock() + + for i, _ := range all.GitTags { + if all.GitTags[i].Refname == s { + all.GitTags[i] = all.GitTags[len(all.GitTags)-1] + all.GitTags = all.GitTags[:len(all.GitTags)-1] + return true + } + } + return false +} + +// enforces Refname is unique +func (all *GitTags) ReplaceRefname(newP *GitTag) bool { // todo: make unique name here + all.Lock.RLock() + defer all.Lock.RUnlock() + + for _, p := range all.GitTags { + if p.Refname == newP.Refname { + return false + } + } + + all.GitTags = append(all.GitTags, newP) + return true +} + +// find a dependancy by the go path +func (all *GitTags) FindByRefname(s string) *GitTag { + if all == nil { + return nil + } + + all.Lock.RLock() + defer all.Lock.RUnlock() + + for i, _ := range all.GitTags { + if all.GitTags[i].Refname == s { + return all.GitTags[i] + } + } + return nil +} + +func (all *GitTags) SortByHash() *GitTagIterator { + packs := all.selectAllGitTag() + + sort.Sort(GitTagHash(packs)) + + iterator := NewGitTagIterator(packs) + return iterator +} + +type GitTagHash []*GitTag + +func (a GitTagHash) Len() int { return len(a) } +func (a GitTagHash) Less(i, j int) bool { return a[i].Hash < a[j].Hash } +func (a GitTagHash) Swap(i, j int) { a[i], a[j] = a[j], a[i] } + +// enforces Hash is unique +func (all *GitTags) AppendUniqueHash(newP *GitTag) bool { + all.Lock.RLock() + defer all.Lock.RUnlock() + + for _, p := range all.GitTags { + if p.Hash == newP.Hash { + return false + } + } + + all.GitTags = append(all.GitTags, newP) + return true +} + +func (all *GitTags) DeleteByHash(s string) bool { + all.Lock.RLock() + defer all.Lock.RUnlock() + + for i, _ := range all.GitTags { + if all.GitTags[i].Hash == s { + all.GitTags[i] = all.GitTags[len(all.GitTags)-1] + all.GitTags = all.GitTags[:len(all.GitTags)-1] + return true + } + } + return false +} + +// enforces Hash is unique +func (all *GitTags) ReplaceHash(newP *GitTag) bool { // todo: make unique name here + all.Lock.RLock() + defer all.Lock.RUnlock() + + for _, p := range all.GitTags { + if p.Hash == newP.Hash { + return false + } + } + + all.GitTags = append(all.GitTags, newP) + return true +} + +// find a dependancy by the go path +func (all *GitTags) FindByHash(s string) *GitTag { + if all == nil { + return nil + } + + all.Lock.RLock() + defer all.Lock.RUnlock() + + for i, _ := range all.GitTags { + if all.GitTags[i].Hash == s { + return all.GitTags[i] + } + } + return nil +} + +// safely returns a slice of pointers to the GitTag protobufs +func (all *GitTags) selectAllGitTag() []*GitTag { + all.Lock.RLock() + defer all.Lock.RUnlock() + + // Create a new slice to hold pointers to each GitTag + var aStuff []*GitTag + aStuff = make([]*GitTag, len(all.GitTags)) + for i, p := range all.GitTags { + aStuff[i] = p // Copy pointers for safe iteration + } + + return aStuff +}