//
For simplicity assume "Callback" is a c-style function

// Worker class uses the callback to do some work, when the callback 
// returns false work is done and the workerclass reports itself as 
// available at the managerclass 
template <typename ManagerClass, typename Callback>
class WorkerClass
{
  private:
    SomeClass* manager;
    Callback callback

  public:
     WorkerClass (ManagerClass* _mgr)
     {
       manager = _mgr;
     }

     void doWork (void)
     {  
       // doWork is called by a thread 
       if (!callback(...))
         manager->returnToPool (this);
     }
}


// We can push work into the manager class. The manager will 
// distribute it over the workers (or queue it if all busy)
template <typename Callback>
class ManagerClass
{
  private:
    // Is this def. correct?! Shouldn't it involve something like
    // WorkerClass<This::type, callback> 
    std::vector<WorkerClass*> workers; 
    
    ManagerClass()
    {
      workers.resize (4); // hardcoded for the moment
      for (i=0; i<4; i++)
        workers = new WorkerClass<???, Callback> (this); // ???
    }

    void queueJob (Callback callback)
    {
      // push Job into queue
      // while WorkerClasses available & work to be done, 
      //   assign jobs to the workerclasses 
    }

    void returnToPool (WorkerClass* _worker)
    {
      // if Jobs in queue, accept Job and continue work
      // otherwise, register as 'available' worker
    }
}