From fa75ab40f9d0447a8b670c991c3fcf8c1d5c3081 Mon Sep 17 00:00:00 2001 From: Antonio Jesus Navarro Perez Date: Wed, 1 Mar 2017 17:51:11 +0100 Subject: git: Repository methods changes To have a more consistent public API, we decided to rename some methods, and add others: - Commit method renamed to CommitObject - Commits method renamed to CommitObjects - Tree method renamed to TreeObject - Trees method renamed to TreeObjects - Tags method renamed to TagObjects - Tag method renamed to TagObject - Added method Tags that returns tag references - Added method Branches that returns branch references - Added method Notes that returns note references - Added BlobObject method - Added BlobObjects method Also, we added more functionality related to references: - Added iterator to iterate References with a specific filter Some notes: - #298 --- plumbing/storer/reference.go | 63 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 62 insertions(+), 1 deletion(-) (limited to 'plumbing/storer/reference.go') diff --git a/plumbing/storer/reference.go b/plumbing/storer/reference.go index d821ecf..32265fe 100644 --- a/plumbing/storer/reference.go +++ b/plumbing/storer/reference.go @@ -28,6 +28,67 @@ type ReferenceIter interface { Close() } +type ReferenceFilteredIter struct { + ff func(r *plumbing.Reference) bool + iter ReferenceIter +} + +// NewReferenceFilteredIter returns a reference iterator for the given reference +// Iterator. This iterator will iterate only references that accomplish the +// provided function. +func NewReferenceFilteredIter( + ff func(r *plumbing.Reference) bool, iter ReferenceIter) ReferenceIter { + return &ReferenceFilteredIter{ff, iter} +} + +// Next returns the next reference from the iterator. If the iterator has reached +// the end it will return io.EOF as an error. +func (iter *ReferenceFilteredIter) Next() (*plumbing.Reference, error) { + for { + r, err := iter.iter.Next() + if err != nil { + return nil, err + } + + if iter.ff(r) { + return r, nil + } + + continue + } +} + +// ForEach call the cb function for each reference contained on this iter until +// an error happens or the end of the iter is reached. If ErrStop is sent +// the iteration is stopped but no error is returned. The iterator is closed. +func (iter *ReferenceFilteredIter) ForEach(cb func(*plumbing.Reference) error) error { + defer iter.Close() + for { + r, err := iter.Next() + if err == io.EOF { + break + } + if err != nil { + return err + } + + if err := cb(r); err != nil { + if err == ErrStop { + break + } + + return err + } + } + + return nil +} + +// Close releases any resources used by the iterator. +func (iter *ReferenceFilteredIter) Close() { + iter.iter.Close() +} + // ReferenceSliceIter implements ReferenceIter. It iterates over a series of // references stored in a slice and yields each one in turn when Next() is // called. @@ -41,7 +102,7 @@ type ReferenceSliceIter struct { // NewReferenceSliceIter returns a reference iterator for the given slice of // objects. -func NewReferenceSliceIter(series []*plumbing.Reference) *ReferenceSliceIter { +func NewReferenceSliceIter(series []*plumbing.Reference) ReferenceIter { return &ReferenceSliceIter{ series: series, } -- cgit From 0c82b411f6cdf4ec66689042d77c35efe41106c3 Mon Sep 17 00:00:00 2001 From: Antonio Jesus Navarro Perez Date: Mon, 6 Mar 2017 10:31:21 +0100 Subject: Make referenceFilteredIter private --- plumbing/storer/reference.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'plumbing/storer/reference.go') diff --git a/plumbing/storer/reference.go b/plumbing/storer/reference.go index 32265fe..a261486 100644 --- a/plumbing/storer/reference.go +++ b/plumbing/storer/reference.go @@ -28,7 +28,7 @@ type ReferenceIter interface { Close() } -type ReferenceFilteredIter struct { +type referenceFilteredIter struct { ff func(r *plumbing.Reference) bool iter ReferenceIter } @@ -38,12 +38,12 @@ type ReferenceFilteredIter struct { // provided function. func NewReferenceFilteredIter( ff func(r *plumbing.Reference) bool, iter ReferenceIter) ReferenceIter { - return &ReferenceFilteredIter{ff, iter} + return &referenceFilteredIter{ff, iter} } // Next returns the next reference from the iterator. If the iterator has reached // the end it will return io.EOF as an error. -func (iter *ReferenceFilteredIter) Next() (*plumbing.Reference, error) { +func (iter *referenceFilteredIter) Next() (*plumbing.Reference, error) { for { r, err := iter.iter.Next() if err != nil { @@ -61,7 +61,7 @@ func (iter *ReferenceFilteredIter) Next() (*plumbing.Reference, error) { // ForEach call the cb function for each reference contained on this iter until // an error happens or the end of the iter is reached. If ErrStop is sent // the iteration is stopped but no error is returned. The iterator is closed. -func (iter *ReferenceFilteredIter) ForEach(cb func(*plumbing.Reference) error) error { +func (iter *referenceFilteredIter) ForEach(cb func(*plumbing.Reference) error) error { defer iter.Close() for { r, err := iter.Next() @@ -85,7 +85,7 @@ func (iter *ReferenceFilteredIter) ForEach(cb func(*plumbing.Reference) error) e } // Close releases any resources used by the iterator. -func (iter *ReferenceFilteredIter) Close() { +func (iter *referenceFilteredIter) Close() { iter.iter.Close() } -- cgit