Job package for Ultimate++
---------------------------

This template class implements a scope-bound, lightweight, single worker thread based on RAII 
principle. It provides a return semantic for result gathering, functionally similar to the
promise-future pattern, including void type specialization, and exception propagation. 

Note that Job class is meant to be a hybrid between the so-called "dedicated thread" and 
"worker thread" models. While Job is a decent general-purpose multithreading tool, for high
performance parallelization scenarios CoWork would be a more suitable option. This class is
mainly designed to allow applications and libraries to gain an easily managable, optional
non-blocking behavior where high latency is expected such as network operations and file I/O,
and a safe, container-style access to the data processed by the worker threads is preferred. 

Features and Highlights
-----------------------

- Uses RAII: All Job instances are scope-bound and will forced to finish job when they get out of scope.
- Smaller overhead. (Does not rely on a pre-allocated thread pool). 
- A safe way to gather results from worker threads.
- Simple and easy-to-use thread halting, and error reporting mechanism.
- Exception propagation.

Known Issues
-----------------------

- Currently none.

History
-----------------------

- 2018-10-29: New version.
              Job heavily refactored.
              Class interface trimmed down.
              Proper waiting mechanism added.
              Improved performance.
              Documents updated.
              Reference example added.
            
- 2017-10-07: Compatibility with U++ single-threaded mode is added.

- 2017-10-01: Global variables moved into JobGlobal namespace in order to avoid multiple
              definitions error. Accordingly, global functions are defined in Job.cpp.

- 2017-09-22: Exception propagation mechanism for job is properly added. From now on
              worker threads will pass exceptions to their caller.
              Void template specialization is re-implemented (without using future/promise).
              Constant reference access operator is added. This is especially useful
              where the data is a container with iterators (such as Vector or Array).

- 2017-09-19: std::exception class exceptions are handled, and treaated as errors. 
              (For the time being.)
              void instantiation is now possible.
              Jobs will notify their workers on shutdown. 
              Clean up & cosmetics...

- 2017-09-18: Clear() method is added. Worker id generator is using int64. Documentation 
              updated.

- 2017-09-17: Future/promise mechanism, and std template library code completely removed.
              From now on Job has its own result gathering mechanism with zero copy/move
              overhead.

- 2017-09-16: Job is redesigned. It is now a proper worker thread.

- 2017-09-10: Initial public beta version is released.

