aboutsummaryrefslogblamecommitdiffstats
path: root/bug/sorting.go
blob: 2e64b92dcfb672a5499e55b32069d761c4c862c6 (plain) (tree)
1
2
3
4
5
6
7
8
9








                                                 
                                                                


                           
                                                                





                                                                                    
                                                                                 

                                                                                   
                                                                  












                                             
                                                            


                           
                                                            





                                                                                    
                                                                                 

                                                                                   
                                                                




                                        
package bug

type BugsByCreationTime []*Bug

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].FirstOp().Time().Before(b[j].FirstOp().Time())
}

func (b BugsByCreationTime) Swap(i, j int) {
	b[i], b[j] = b[j], b[i]
}

type BugsByEditTime []*Bug

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].LastOp().Time().Before(b[j].LastOp().Time())
}

func (b BugsByEditTime) Swap(i, j int) {
	b[i], b[j] = b[j], b[i]
}