func (st *worker) SetErrorChannel(ch chan *PoolError) {
	st.errorChan = ch
}
*************************************************************************************************************
Error Channel  **********************************************************************************************
*************************************************************************************************************
SetErrorChannel sets the channel to send errors
package goworkerpool
import (
	"fmt"
	"sync"
	"time"
	"github.com/enriquebris/goconcurrentcounter"
)
const (
	ErrorWorkerNilTask    = "worker.nil.task"
	ErrorWorkerNoTaskFunc = "worker.no.func.to.process.task"
	ListenInProgress      = "listen.in.progress"
	WorkerClosed          = "worker.closed"
)
type (
	workerExternalActionFunc func() (reEnqueueWorker bool)
	workerInternalActionFunc func() bool
	workerFeedbackFunc func(wkrID int, reEnqueueWorker bool)
	workerExternalGeneralFunc func()
	workerExternalFailFunc func(tsk *task, err error)
)
type workerFeedback struct {
	workerID        int
	reEnqueueWorker bool
}
type workerFunctionData struct {
	result bool
	err    error
}
type worker struct {
	id          int
	tasksChan   chan *task
	actionsChan chan action
	closeChan chan chan struct{}
	closeListenChan chan struct{}
	internalActions map[string]workerInternalActionFunc
	externalActions map[string]workerExternalActionFunc
	externalFeedbackFunc workerFeedbackFunc
	externalPreActionFunc workerExternalGeneralFunc
	externalPostActionFunc workerExternalGeneralFunc
	externalPreTaskFunc workerExternalGeneralFunc
	externalPostTaskFunc workerExternalGeneralFunc
	externalFailFunc workerExternalFailFunc
	errorChan chan *PoolError
	taskSuccesses         int
	externalTaskSuccesses goconcurrentcounter.Int
	taskFailures          int
	generalInfoMap sync.Map
}
func newWorker(id int) *worker {
	ret := &worker{}
	ret.initialize(id)
	return ret
}
func (st *worker) initialize(id int) {
	st.id = id
	st.tasksChan = make(chan *task)
	st.actionsChan = make(chan action)
	st.closeChan = make(chan chan struct{})
	st.closeListenChan = make(chan struct{})
	st.internalActions = make(map[string]workerInternalActionFunc)
	st.externalActions = make(map[string]workerExternalActionFunc)
	st.setStatus(WorkerClosed, false)
	st.setupInternalFunctionOperations()
}
func (st *worker) GetID() int {
	return st.id
}
func (st *worker) GetTasksChannel() chan *task {
	return st.tasksChan
}
func (st *worker) GetActionsChannel() chan action {
	return st.actionsChan
}
func (st *worker) Close() chan struct{} {
	waitingForListenDown := make(chan struct{})
	select {
	case st.closeChan <- waitingForListenDown:
		<-waitingForListenDown
	default:
		close(waitingForListenDown)
	}
	close(st.closeChan)
	close(st.GetTasksChannel())
	close(st.GetActionsChannel())
	st.setStatus(WorkerClosed, true)
	return st.closeListenChan
}