1 files changed, 42 insertions, 45 deletions

diff --git a/reference.go b/reference.go
index d246c55..8c8b282 100644
--- a/reference.go
+++ b/reference.go
@@ -22,9 +22,8 @@ type Reference struct {
 }
 
 func newReferenceFromC(ptr *C.git_reference) *Reference {
-	ref := &Reference{ptr}
+	ref := &Reference{ptr: ptr}
 	runtime.SetFinalizer(ref, (*Reference).Free)
-
 	return ref
 }
 
@@ -149,6 +148,19 @@ func (v *Reference) Delete() error {
 	return nil
 }
 
+func (v *Reference) Peel(t ObjectType) (Object, error) {
+	var cobj *C.git_object
+
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	if err := C.git_reference_peel(&cobj, v.ptr, C.git_otype(t)); err < 0 {
+		return nil, MakeGitError(err)
+	}
+
+	return allocObject(cobj), nil
+}
+
 // Cmp compares both references, retursn 0 on equality, otherwise a
 // stable sorting.
 func (v *Reference) Cmp(ref2 *Reference) int {
@@ -190,6 +202,10 @@ type ReferenceIterator struct {
 	repo *Repository
 }
 
+type ReferenceNameIterator struct {
+	*ReferenceIterator
+}
+
 // NewReferenceIterator creates a new iterator over reference names
 func (repo *Repository) NewReferenceIterator() (*ReferenceIterator, error) {
 	var ptr *C.git_reference_iterator
@@ -202,11 +218,28 @@ func (repo *Repository) NewReferenceIterator() (*ReferenceIterator, error) {
 		return nil, MakeGitError(ret)
 	}
 
-	iter := &ReferenceIterator{repo: repo, ptr: ptr}
+	iter := &ReferenceIterator{ptr: ptr, repo: repo}
 	runtime.SetFinalizer(iter, (*ReferenceIterator).Free)
 	return iter, nil
 }
 
+// NewReferenceIterator creates a new branch iterator over reference names
+func (repo *Repository) NewReferenceNameIterator() (*ReferenceNameIterator, error) {
+	var ptr *C.git_reference_iterator
+
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	ret := C.git_reference_iterator_new(&ptr, repo.ptr)
+	if ret < 0 {
+		return nil, MakeGitError(ret)
+	}
+
+	iter := &ReferenceIterator{ptr: ptr, repo: repo}
+	runtime.SetFinalizer(iter, (*ReferenceIterator).Free)
+	return iter.Names(), nil
+}
+
 // NewReferenceIteratorGlob creates an iterator over reference names
 // that match the speicified glob. The glob is of the usual fnmatch
 // type.
@@ -223,23 +256,24 @@ func (repo *Repository) NewReferenceIteratorGlob(glob string) (*ReferenceIterato
 		return nil, MakeGitError(ret)
 	}
 
-	iter := &ReferenceIterator{repo: repo, ptr: ptr}
+	iter := &ReferenceIterator{ptr: ptr}
 	runtime.SetFinalizer(iter, (*ReferenceIterator).Free)
 	return iter, nil
 }
 
+func (i *ReferenceIterator) Names() *ReferenceNameIterator {
+	return &ReferenceNameIterator{i}
+}
+
 // NextName retrieves the next reference name. If the iteration is over,
 // the returned error is git.ErrIterOver
-func (v *ReferenceIterator) NextName() (string, error) {
+func (v *ReferenceNameIterator) Next() (string, error) {
 	var ptr *C.char
 
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
 	ret := C.git_reference_next_name(&ptr, v.ptr)
-	if ret == ITEROVER {
-		return "", ErrIterOver
-	}
 	if ret < 0 {
 		return "", MakeGitError(ret)
 	}
@@ -247,31 +281,11 @@ func (v *ReferenceIterator) NextName() (string, error) {
 	return C.GoString(ptr), nil
 }
 
-// Create a channel from the iterator. You can use range on the
-// returned channel to iterate over all the references names. The channel
-// will be closed in case any error is found.
-func (v *ReferenceIterator) NameIter() <-chan string {
-	ch := make(chan string)
-	go func() {
-		defer close(ch)
-		name, err := v.NextName()
-		for err == nil {
-			ch <- name
-			name, err = v.NextName()
-		}
-	}()
-
-	return ch
-}
-
 // Next retrieves the next reference. If the iterationis over, the
 // returned error is git.ErrIterOver
 func (v *ReferenceIterator) Next() (*Reference, error) {
 	var ptr *C.git_reference
 	ret := C.git_reference_next(&ptr, v.ptr)
-	if ret == ITEROVER {
-		return nil, ErrIterOver
-	}
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
@@ -279,23 +293,6 @@ func (v *ReferenceIterator) Next() (*Reference, error) {
 	return newReferenceFromC(ptr), nil
 }
 
-// Create a channel from the iterator. You can use range on the
-// returned channel to iterate over all the references names. The channel
-// will be closed in case any error is found.
-func (v *ReferenceIterator) Iter() <-chan *Reference {
-	ch := make(chan *Reference)
-	go func() {
-		defer close(ch)
-		name, err := v.Next()
-		for err == nil {
-			ch <- name
-			name, err = v.Next()
-		}
-	}()
-
-	return ch
-}
-
 // Free the reference iterator
 func (v *ReferenceIterator) Free() {
 	runtime.SetFinalizer(v, nil)