Peter M. Groen / redox

Add EVRUN_ONCE evloop call at the start of the event loop thread,
instead of just an EVRUN_NOWAIT call. We want to block until the
connection happens, or else we hang on the condition variable wait.

Fix logger include path

Fix the path for logger.hpp, otherwise make install fails.

Change-Id: I50aa9667e512c4fdf6de471dc16312d9eb3dbe30

Better timing statistics, better printing, adding pub sub test modes.

User can now enable no-wait mode, which chooses whether we use the
EVRUN_NOWAIT flag in ev_run. The default is off, so that we don't
use 100% CPU. Note added in tutorial to enable when performance
is critical. Added to the speed test examples.

Bump to 0.2.1. Remove patch number from HISTORY entry - that's what the
git log is for. Make note on minor release.

Useful for analyzing the delay between signals.

Instructions in README, some minor changes to comments.

Things are faster with vectors! Also added a note about strToVec and
vecToStr, and made them static methods.

This enables full support for binary data, with no tokenization needed
and all the assumptions that come with that. All of the core methods are
changed to accept vector<string>& instead of string&. Ported all
examples and tutorial as well.

Call Redox::disconnectCallback from processReply

This makes more sense logically, and lets the Redox object get default
constructed with nothing but the optional logger parameters.

Explain core commands, pubsub, and reply types.

Separate include directory so that examples can reference the same thing
whether installed in the system or from the local folder.

Made redox into a more formal package with CMake. It now by default
builds a dynamic library in release mode. Tests and examples can be
enabled with options. Added semantic versioning. Documented the install
from source procedure which is very easy, just make and make install.

Users now have to just link one library (redox) and include one header
(redox.hpp), and the rest is linked from those.

Used CPack to add capability to create a debian package. Useful for
getting it into the apt repos.

Also redid the readme introduction.

More intuitive if disconnect() blocks like connect(). Most clients will
want to use these two methods. For more fine grained control,
disconnect() is just a combo of stop() and wait().

Configure CMake to generate libredox.so and libredox_static.a, and have
all examples use the dynamic library. This is how Redox should be used
in practice, and greatly reduces the compilation time of the examples.

Also renamed redox.[ch]pp to client.[ch]pp and created one master header
redox.hpp for users to include. This header right now just includes
client.hpp, command.hpp, and subscriber.hpp.

Make .free() on commands send a message over an async watcher to the
event loop, just like adding commands. This gets rid of some very tough
to find memory bugs. Combined .cancel() with .free(), so there is only
one method to call, whether for synchronous commands or for looped
commands.

Also debug some horrible segfaults related to Subscriber. Something is
odd with hiredis and subscriptions, need to ask them. It seems when we
flood with commands it doesn't disconnect cleanly. Look for a way to
wait until all commands are processed.

Conform (mostly) to Google C++ guidelines.

Apache license notice and link above each core file.

Refactor state management code to use three methods .connect(),
.disconnect(), and .wait(). Start conforming to uniform coding style
already applied to Command class.

Split off subscribe functionality into its own class Subscriber. This is
good because it was introducing unnecessary state and complexity into
the main client. Now, Redox handles publishing like any other command
and the Subscriber receives messages.

Using free_guard_ as the same mutex in .reply() causes deadlock when a
callback accesses .reply(). Make a separate mutex.

Also make cmd.reply() copy the value and use a mutex to make it thread
safe. No noticable speed hits, probably thanks to RVO.

Split up command into command, command_blocking, and command_looping.
The original command no longer returns anything, which clarifies how it
should be used in most cases. command_looping and command_blocking both
return a command object.

Also added a waiting CV to the Command object, though it is not used in
command_blocking yet.