Add batch WaitAll() function of when result checking is not necessary

Author: joeybloggs

README.md

@@ -1,7 +1,7 @@
 Package pool
 ============
 
-![Project status](https://img.shields.io/badge/version-3.0.0-green.svg)
+![Project status](https://img.shields.io/badge/version-3.1.0-green.svg)
 [![Build Status](https://semaphoreci.com/api/v1/joeybloggs/pool/branches/v3/badge.svg)](https://semaphoreci.com/joeybloggs/pool)
 [![Coverage Status](https://coveralls.io/repos/go-playground/pool/badge.svg?branch=v3&service=github)](https://coveralls.io/github/go-playground/pool?branch=v3)
 [![Go Report Card](https://goreportcard.com/badge/gopkg.in/go-playground/pool.v3)](https://goreportcard.com/report/gopkg.in/go-playground/pool.v3)
@@ -49,7 +49,7 @@ Important Information READ THIS!
 
 - It is recommended that you cancel a pool or batch from the calling function and not inside of the Unit of Work, it will work fine, however because of the goroutine scheduler and context switching it may not cancel as soon as if called from outside.
 - When Batching DO NOT FORGET TO CALL batch.QueueComplete(), if you do the Batch WILL deadlock
-- It is your responsibility to call WorkUnit.IsCancelled() to check if it's cancelled after a blocking operation like waiting for a connection from a pool.
+- It is your responsibility to call WorkUnit.IsCancelled() to check if it's cancelled after a blocking operation like waiting for a connection from a pool. (optional)
 
 Usage and documentation
 ------

batch.go

@@ -22,6 +22,13 @@ type Batch interface {
 	// Results returns a Work Unit result channel that will output all
 	// completed units of work.
 	Results() <-chan WorkUnit
+
+	// WaitAll is an alternative to Results() where you
+	// may want/need to wait until all work has been
+	// processed, but don't need to check results.
+	// eg. individual units of work may handle their own
+	// errors, logging...
+	WaitAll()
 }
 
 // batch contains all information for a batch run of WorkUnits
@@ -111,3 +118,14 @@ func (b *batch) Results() <-chan WorkUnit {
 
 	return b.results
 }
+
+// WaitAll is an alternative to Results() where you
+// may want/need to wait until all work has been
+// processed, but don't need to check results.
+// eg. individual units of work may handle their own
+// errors and logging...
+func (b *batch) WaitAll() {
+
+	for range b.Results() {
+	}
+}

batch_limited_test.go

@@ -1,6 +1,7 @@
 package pool
 
 import (
+	"sync"
 	"testing"
 	"time"
 
@@ -135,3 +136,37 @@ func TestLimitedBatchCancelItemsCancelledAfterward(t *testing.T) {
 
 	Equal(t, count, 40)
 }
+
+func TestLimitedBatchWaitAll(t *testing.T) {
+
+	var count int
+	var m sync.Mutex
+
+	newFunc := func(i int) func(WorkUnit) (interface{}, error) {
+		return func(WorkUnit) (interface{}, error) {
+			time.Sleep(time.Second * 1)
+			m.Lock()
+			count++
+			m.Unlock()
+			return i, nil
+		}
+	}
+
+	pool := NewLimited(4)
+	defer pool.Close()
+
+	batch := pool.Batch()
+
+	go func() {
+
+		for i := 0; i < 10; i++ {
+			batch.Queue(newFunc(i))
+		}
+
+		batch.QueueComplete()
+	}()
+
+	batch.WaitAll()
+
+	Equal(t, count, 10)
+}

batch_unlimited_test.go

@@ -1,6 +1,7 @@
 package pool
 
 import (
+	"sync"
 	"testing"
 	"time"
 
@@ -135,3 +136,37 @@ func TestUnlimitedBatchCancelItemsCancelledAfterward(t *testing.T) {
 
 	Equal(t, count, 40)
 }
+
+func TestUnlimitedBatchWaitAll(t *testing.T) {
+
+	var count int
+	var m sync.Mutex
+
+	newFunc := func(i int) func(WorkUnit) (interface{}, error) {
+		return func(WorkUnit) (interface{}, error) {
+			time.Sleep(time.Second * 1)
+			m.Lock()
+			count++
+			m.Unlock()
+			return i, nil
+		}
+	}
+
+	pool := New()
+	defer pool.Close()
+
+	batch := pool.Batch()
+
+	go func() {
+
+		for i := 0; i < 10; i++ {
+			batch.Queue(newFunc(i))
+		}
+
+		batch.QueueComplete()
+	}()
+
+	batch.WaitAll()
+
+	Equal(t, count, 10)
+}

doc.go

@@ -41,7 +41,7 @@ important usage information
       if you do the Batch WILL deadlock
 
     - It is your responsibility to call WorkUnit.IsCancelled() to check if it's cancelled
-      after a blocking operation like waiting for a connection from a pool.
+      after a blocking operation like waiting for a connection from a pool. (optional)
 
 
 Usage and documentation

unlimited_pool_test.go

@@ -73,12 +73,9 @@ func TestUnlimitedCancel(t *testing.T) {
 
 			go func(ch chan WorkUnit) {
 				m.RLock()
-				if closed {
-					m.RUnlock()
-					return
+				if !closed {
+					ch <- pool.Queue(newFunc(time.Second * 1))
 				}
-
-				ch <- pool.Queue(newFunc(time.Second * 1))
 				m.RUnlock()
 			}(ch)
 		}