mirror of
https://github.com/MichaelMure/git-bug.git
synced 2024-12-14 17:51:44 +03:00
100 lines
2.6 KiB
Go
100 lines
2.6 KiB
Go
package cache
|
|
|
|
import (
|
|
"encoding/gob"
|
|
|
|
"github.com/MichaelMure/git-bug/bug"
|
|
"github.com/MichaelMure/git-bug/util"
|
|
)
|
|
|
|
// BugExcerpt hold a subset of the bug values to be able to sort and filter bugs
|
|
// efficiently without having to read and compile each raw bugs.
|
|
type BugExcerpt struct {
|
|
Id string
|
|
|
|
CreateLamportTime util.LamportTime
|
|
EditLamportTime util.LamportTime
|
|
CreateUnixTime int64
|
|
EditUnixTime int64
|
|
|
|
Status bug.Status
|
|
Author bug.Person
|
|
}
|
|
|
|
func NewBugExcerpt(b bug.Interface, snap *bug.Snapshot) BugExcerpt {
|
|
return BugExcerpt{
|
|
Id: b.Id(),
|
|
CreateLamportTime: b.CreateLamportTime(),
|
|
EditLamportTime: b.EditLamportTime(),
|
|
CreateUnixTime: b.FirstOp().UnixTime(),
|
|
EditUnixTime: snap.LastEditUnix(),
|
|
Status: snap.Status,
|
|
Author: snap.Author,
|
|
}
|
|
}
|
|
|
|
// Package initialisation used to register the type for (de)serialization
|
|
func init() {
|
|
gob.Register(BugExcerpt{})
|
|
}
|
|
|
|
/*
|
|
* Sorting
|
|
*/
|
|
|
|
type BugsByCreationTime []BugExcerpt
|
|
|
|
func (b BugsByCreationTime) Len() int {
|
|
return len(b)
|
|
}
|
|
|
|
func (b BugsByCreationTime) Less(i, j int) bool {
|
|
if b[i].CreateLamportTime < b[j].CreateLamportTime {
|
|
return true
|
|
}
|
|
|
|
if b[i].CreateLamportTime > b[j].CreateLamportTime {
|
|
return false
|
|
}
|
|
|
|
// When the logical clocks are identical, that means we had a concurrent
|
|
// edition. In this case we rely on the timestamp. While the timestamp might
|
|
// be incorrect due to a badly set clock, the drift in sorting is bounded
|
|
// by the first sorting using the logical clock. That means that if users
|
|
// synchronize their bugs regularly, the timestamp will rarely be used, and
|
|
// should still provide a kinda accurate sorting when needed.
|
|
return b[i].CreateUnixTime < b[j].CreateUnixTime
|
|
}
|
|
|
|
func (b BugsByCreationTime) Swap(i, j int) {
|
|
b[i], b[j] = b[j], b[i]
|
|
}
|
|
|
|
type BugsByEditTime []BugExcerpt
|
|
|
|
func (b BugsByEditTime) Len() int {
|
|
return len(b)
|
|
}
|
|
|
|
func (b BugsByEditTime) Less(i, j int) bool {
|
|
if b[i].EditLamportTime < b[j].EditLamportTime {
|
|
return true
|
|
}
|
|
|
|
if b[i].EditLamportTime > b[j].EditLamportTime {
|
|
return false
|
|
}
|
|
|
|
// When the logical clocks are identical, that means we had a concurrent
|
|
// edition. In this case we rely on the timestamp. While the timestamp might
|
|
// be incorrect due to a badly set clock, the drift in sorting is bounded
|
|
// by the first sorting using the logical clock. That means that if users
|
|
// synchronize their bugs regularly, the timestamp will rarely be used, and
|
|
// should still provide a kinda accurate sorting when needed.
|
|
return b[i].EditUnixTime < b[j].EditUnixTime
|
|
}
|
|
|
|
func (b BugsByEditTime) Swap(i, j int) {
|
|
b[i], b[j] = b[j], b[i]
|
|
}
|