missing include
Merge pull request #80 from reneme/file_chunking

New Backend Implementation



Contains:

    Concurrent and Extendable Backend Spooler
    (Experimental) Riak Backend Adapter
    (extensible) File Chunking
    various utility classes (UniquePtr, Observable template, Callbacks template, ConcurrentWorkers template, PolymorphicConstruction template, LockGuard template, ...)

Descriptions from Previous (deleted) Pull Requests:
While the internal procedures are still the same, the structure of the code changed substantially. Compression and Hashing of files is now implemented as a ConcurrentWorker class (FileProcessor) which is used by the ConcurrentWorkers template to spread the work over all available CPU cores.
Additionally the actual spooler implementation is not forked into a child process anymore, obsoleting the named-pipe descriptions in the spooler definition strings.

Contents:

    A rather simple StopWatch class was added, allowing for time measurements using gettimeofday()

    Added a base class SingleCopy that defines the copy-constructor and assignment operator to be private. Therefore classes that inherit from SingleCopy will not be copyable.

    Added a simple UniquePtr template to manage pointer allocation in a RAII-fashion.

    The base class Lockable implements a simple mutex lock mechanism. It allows inheriting classes to implement mutual exclusive access easily, through a common interface

    Using the RAII-style LockGuard template one can easily create scoped locks of objects that implement Lockable or using raw constructs such as pthread_mutex_t or pthread_rwlock_t

    The base class Observable allows inheriting classes to provide an asynchronous callback interface, to which arbitrary other classes can register callback functions or methods.

    Finally ConcurrentWorkers is a generic implementation of a Producer/Consumer pattern that allows arbitrary Workers to process Jobs concurrently. Workers are classes that inherit from the ConcurrentWorker base class and define their input as well as output data and an interface to process a Job. Scheduling and synchronization is transparently done in the ConcurrentWorkers template. See the code documentation for further usage instructions.
build system revision: configure externals only on demand + vjson added as an external
fix gcc 4.1 warnings
Merge pull request #81 from reneme/move_vjson_to_externals

Build System: Re-Configure now takes about 10 Seconds instead of 10 Minutes

+ vjson now added to externals
Merge pull request #82 from reneme/fix_gcc4_1-warnings

FIX: gcc4 1 warnings
FIX: dependency handling for concurrent builds
speed up sparse hash building (no time consuming unit test building anymore)
Merge pull request #83 from reneme/fix_concurrent_build

FIX: Concurrent build + sparsehash build speedup

    - fixed the dependency tree in order to allow for concurrent builds
    - changed build hook for sparsehash to avoid useless building of unit tests