Use interface instead of function references

Signed-off-by: Javi Fontan <[email protected]>

Author: jfontan

repositories.go

@@ -95,47 +95,42 @@ func (i *RepositoryIter) Close() error {
 	return nil
 }
 
-type funcInitRepository func(Repository, interface{}) error
-type funcNextRow func(interface{}) (sql.Row, error)
-type funcClose func(interface{}) error
+// RowRepoIterImplementation is the interface needed by each iterator
+// implementation
+type RowRepoIterImplementation interface {
+	InitRepository(Repository) error
+	Next() (sql.Row, error)
+	Close() error
+}
 
 // RowRepoIter is used as the base to iterate over all the repositories
 // in the pool. It needs three functions that execute specific code per
 // implemented iterator.
 type RowRepoIter struct {
 	repositoryIter *RepositoryIter
 	repository     *Repository
-	data           interface{}
-
-	funcInitRepository funcInitRepository
-	funcNextRow        funcNextRow
-	funcClose          funcClose
+	implementation RowRepoIterImplementation
 }
 
 // NewRowRepoIter initializes a new repository iterator.
 //
 // * pool: is a RepositoryPool we want to iterate
-// * data: this pointer will be passed to the provided functions and is useful
-//      to save state like initialized iterators or other needed variables
-// * init: called when a new repository is about to be iterated, initialize
-//      its iterator there
-// * next: called for each row
-// * close: called when a repository finished iterating
-func NewRowRepoIter(pool *RepositoryPool, data interface{},
-	init funcInitRepository, next funcNextRow,
-	close funcClose) (RowRepoIter, error) {
+// * impl: implementation with RowRepoIterImplementation interface
+//     * InitRepository: called when a new repository is about to be iterated,
+//         initialize its iterator there
+//     * Next: called for each row
+//     * Close: called when a repository finished iterating
+func NewRowRepoIter(pool *RepositoryPool,
+	impl RowRepoIterImplementation) (RowRepoIter, error) {
 
 	rIter, err := pool.RepoIter()
 	if err != nil {
 		return RowRepoIter{}, err
 	}
 
 	repo := RowRepoIter{
-		repositoryIter:     rIter,
-		funcInitRepository: init,
-		funcNextRow:        next,
-		funcClose:          close,
-		data:               data,
+		repositoryIter: rIter,
+		implementation: impl,
 	}
 
 	err = repo.nextRepository()
@@ -156,7 +151,7 @@ func (i *RowRepoIter) nextRepository() error {
 	}
 
 	i.repository = repo
-	err = i.funcInitRepository(*repo, i.data)
+	err = i.implementation.InitRepository(*repo)
 	if err != nil {
 		return err
 	}
@@ -167,7 +162,7 @@ func (i *RowRepoIter) nextRepository() error {
 // Next gets the next row
 func (i *RowRepoIter) Next() (sql.Row, error) {
 	for {
-		row, err := i.funcNextRow(i.data)
+		row, err := i.implementation.Next()
 
 		switch err {
 		case nil:
@@ -191,9 +186,7 @@ func (i *RowRepoIter) Next() (sql.Row, error) {
 
 // Close called to close the iterator
 func (i *RowRepoIter) Close() error {
-	if i.funcClose != nil {
-		return i.funcClose(i.data)
-	}
+	return i.implementation.Close()
 
 	return nil
 }

repositories_test.go

@@ -135,9 +135,7 @@ type testCommitIter struct {
 	iter object.CommitIter
 }
 
-func testInitRepository(repo Repository, data interface{}) error {
-	d := data.(*testCommitIter)
-
+func (d *testCommitIter) InitRepository(repo Repository) error {
 	cIter, err := repo.Repo.CommitObjects()
 	if err != nil {
 		return err
@@ -148,9 +146,7 @@ func testInitRepository(repo Repository, data interface{}) error {
 	return nil
 }
 
-func testNextRow(data interface{}) (sql.Row, error) {
-	d := data.(*testCommitIter)
-
+func (d *testCommitIter) Next() (sql.Row, error) {
 	_, err := d.iter.Next()
 	if err != nil {
 		return nil, err
@@ -159,9 +155,7 @@ func testNextRow(data interface{}) (sql.Row, error) {
 	return nil, nil
 }
 
-func testClose(data interface{}) error {
-	d := data.(*testCommitIter)
-
+func (d *testCommitIter) Close() error {
 	if d.iter != nil {
 		d.iter.Close()
 	}
@@ -185,8 +179,7 @@ func TestRepositoryRowIterator(t *testing.T) {
 
 	cIter := &testCommitIter{}
 
-	rowRepoIter, err := NewRowRepoIter(pool, cIter, testInitRepository,
-		testNextRow, testClose)
+	rowRepoIter, err := NewRowRepoIter(&pool, cIter)
 	require.Nil(err)
 
 	count := 0