fucking ya

Signed-off-by: Jeff Carr <[email protected]>

1 files changed, 20 insertions, 20 deletions

diff --git a/refs.sort.go b/refs.sort.go
index b48bce5..bc8fbaf 100644
--- a/refs.sort.go
+++ b/refs.sort.go
@@ -55,14 +55,14 @@ func (it *RefIterator) Ref() *Ref {
 //		fmt.Println("Ref UUID:", d.Uuid)
 //	}
 
-func (r *Refs) All() *RefIterator {
+func (r *Repo) All() *RefIterator {
 	repoPointers := r.selectAllRefs()
 
 	iterator := NewRefIterator(repoPointers)
 	return iterator
 }
 
-func (r *Refs) SortByName() *RefIterator {
+func (r *Repo) SortByName() *RefIterator {
 	packs := r.selectAllRefs()
 
 	sort.Sort(RefsByName(packs))
@@ -72,17 +72,17 @@ func (r *Refs) SortByName() *RefIterator {
 }
 
 // enforces no duplicate package names
-func (r *Repo) AppendRef(newP *Ref) bool {
+func (repo *Repo) AppendRef(newP *Ref) bool {
 	refslock.Lock()
 	defer refslock.Unlock()
 
-	for _, p := range r.Refs {
+	for _, p := range repo.Refs {
 		if p.RefName == newP.RefName {
 			return false
 		}
 	}
 
-	r.Refs = append(r.Refs, newP)
+	repo.Refs = append(repo.Refs, newP)
 	return true
 }
 
@@ -93,11 +93,11 @@ func (r *Ref) Age(newP *Ref) time.Duration {
 }
 
 // find a package by name
-func (r *Refs) FindByName(name string) *Ref {
+func (repo *Repo) FindRefByName(name string) *Ref {
 	refslock.RLock()
 	defer refslock.RUnlock()
 
-	for _, p := range r.Refs {
+	for _, p := range repo.Refs {
 		if p.RefName == name {
 			return p
 		}
@@ -106,11 +106,11 @@ func (r *Refs) FindByName(name string) *Ref {
 	return nil
 }
 
-func (r *Refs) Len() int {
+func (repo *Repo) LenRefs() int {
 	refslock.RLock()
 	defer refslock.RUnlock()
 
-	return len(r.Refs)
+	return len(repo.Refs)
 }
 
 type RefsByName []*Ref
@@ -120,28 +120,28 @@ func (a RefsByName) Less(i, j int) bool { return a[i].RefName < a[j].RefName }
 func (a RefsByName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
 
 // safely returns a slice of pointers to the Ref protobufs
-func (r *Refs) selectAllRefs() []*Ref {
+func (repo *Repo) selectAllRefs() []*Ref {
 	refslock.RLock()
 	defer refslock.RUnlock()
 
 	// Create a new slice to hold pointers to each Ref
-	var allPacks []*Ref
-	allPacks = make([]*Ref, len(r.Refs))
-	for i, p := range r.Refs {
-		allPacks[i] = p // Copy pointers for safe iteration
+	var allRefs []*Ref
+	allRefs = make([]*Ref, len(repo.Refs))
+	for i, p := range repo.Refs {
+		allRefs[i] = p // Copy pointers for safe iteration
 	}
 
-	return allPacks
+	return allRefs
 }
 
-func (all *Refs) DeleteByHash(hash string) *Ref {
+func (repo *Repo) DeleteByHash(hash string) *Ref {
 	refslock.Lock()
 	defer refslock.Unlock()
 
-	for i, _ := range all.Refs {
-		if all.Refs[i].Hash == hash {
-			all.Refs[i] = all.Refs[len(all.Refs)-1]
-			all.Refs = all.Refs[:len(all.Refs)-1]
+	for i, _ := range repo.Refs {
+		if repo.Refs[i].Hash == hash {
+			repo.Refs[i] = repo.Refs[len(repo.Refs)-1]
+			repo.Refs = repo.Refs[:len(repo.Refs)-1]
 			return nil
 		}
 	}