diff --git a/include/rosa/config/config.h b/include/rosa/config/config.h
index e340325..487ceb9 100644
--- a/include/rosa/config/config.h
+++ b/include/rosa/config/config.h
@@ -1,56 +1,55 @@
 /*******************************************************************************
  *
  * File:     config.h
  *
  * Contents: Configuration nformation on the build of the library.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #ifndef ROSA_CONFIG_CONFIG_H
 #define ROSA_CONFIG_CONFIG_H
 
-#include <iostream>
-
-// Various preprocessor macros containing config information.
 #include "rosa/config/rosa_config.h"
 
+#include <iostream>
+
 // This OS-specific block defines one of the following:
 // - ROSA_LINUX
 // - ROSA_WINDOWS
 // It also defines ROSA_POSIX for POSIX-compatible systems.
 #if defined(__linux__)
 #define ROSA_LINUX
 #elif defined(WIN32) || defined(_WIN32)
 #define ROSA_WINDOWS
 #else
 #error Platform and/or compiler not supported
 #endif
 #if defined(ROSA_LINUX)
 #define ROSA_POSIX
 #endif
 
 // Defining filenames in a project-relative way based on absolute paths.
 #include "rosa/config/project_path.hpp"
 #define __FILENAME__ (__FILE__ + project_relative_path_index(__FILE__))
 
 // Convenience macros.
 #define ROSA_VOID_STMT static_cast<void>(0)
 
 #define ROSA_IGNORE_UNUSED(x) static_cast<void>(x)
 
 #define ROSA_CRITICAL(error)                                                   \
   do {                                                                         \
     std::cerr << "[FATAL] " << __func__ << "@" << __FILENAME__ << ":"          \
               << __LINE__ << ": critical error: '" << (error) << "'"           \
               << std::endl;                                                    \
     ::abort();                                                                 \
   } while (false)
 
 #define ROSA_RAISE_ERROR(msg) throw std::runtime_error(msg)
 
 #endif // ROSA_CONFIG_CONFIG_H
 
diff --git a/include/rosa/config/version.h b/include/rosa/config/version.h
index af16211..d3aa020 100644
--- a/include/rosa/config/version.h
+++ b/include/rosa/config/version.h
@@ -1,35 +1,34 @@
 /*******************************************************************************
  *
  * File:     version.h
  *
  * Contents: Version information about the build of the library.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #ifndef ROSA_CONFIG_VERSION_H
 #define ROSA_CONFIG_VERSION_H
 
-#include <string>
-
-// Various preprocessor macros containing the information.
 #include "rosa/config/rosa_config.h"
 
+#include <string>
+
 namespace rosa {
 
 // Returns a string containing the name of the library followed by its version.
 std::string library_string(void);
 
 // Returns a string containing the version number of the library.
 std::string version(void);
 
 // Returns a multi-line string containing verbose information on the library.
 std::string verbose_version(void);
 
 } // End namespace rosa
 
 #endif // ROSA_CONFIG_VERSION_H
 
diff --git a/include/rosa/core/Invoker.hpp b/include/rosa/core/Invoker.hpp
index b344ebe..2b031b2 100644
--- a/include/rosa/core/Invoker.hpp
+++ b/include/rosa/core/Invoker.hpp
@@ -1,158 +1,160 @@
 /*******************************************************************************
  *
  * File:     Invoker.hpp
  *
  * Contents: Definition of Invoker interface and its implementation.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #ifndef ROSA_CORE_INVOKER_HPP
 #define ROSA_CORE_INVOKER_HPP
 
 #include "rosa/core/MessageMatcher.hpp"
+
 #include "rosa/support/log.h"
+
 #include <functional>
 #include <memory>
 
 namespace rosa {
 
 // Wraps a function and provides a simple interface to invoke the stored
 // function by passing actual arguments as a Message.
 // NOTE: Invoker instances are supposed to be owned by Message handlers, and
 // not being used directly from user code.
 class Invoker {
 protected:
   // Protected ctor, only subclasses can instantiate.
   Invoker(void) noexcept;
 
 public:
   // Dtor.
   virtual ~Invoker(void);
 
   // Enumeration of possible results of an invocation.
   enum class Result { NoMatch, Invoked };
 
   // Type alias for a smart-pointer for Invoker.
   using invoker_t = std::unique_ptr<const Invoker>;
 
   // Type alias for Result.
   using result_t = Result;
 
   // Tells if Msg can be used to invoke F.
   virtual bool match(const Message &Msg) const noexcept = 0;
 
   // Invokes F with Msg if Msg can be used to invoke F.
   virtual result_t operator()(const Message &Msg) const noexcept = 0;
 
   // Instantiates an implementation of Invoker with the given function.
   // NOTE: As there is no empty Message, no Invoker wraps a function without an
   // argument.
   template <typename T, typename... Ts>
   static invoker_t wrap(std::function<void(T, Ts...) noexcept> &&F) noexcept;
 
   // Convenience template alias for casting callable stuff to function objects
   // for wrapping.
   // FIXME: Should make it possible to avoid using an explicit conversion for
   // the arguments of wrap.
   template <typename... Ts> using F = std::function<void(Ts...) noexcept>;
 };
 
 // Nested namespace with Invoker implementation and helper templates, consider
 // it private.
 namespace {
 
 // Implementation of the Invoker interface, for functions with different
 // signature.
 // NOTE: As there is no empty Message, no Invoker wraps a function without an
 // argument.
 template <typename Fun> class InvokerImpl;
 
 // Empty struct just to store a sequence of numbers in compile time as template
 // arguments.
 template <size_t...> struct Seq {};
 
 // Sequence generator, the general case when counting down by extending the
 // sequence.
 template <size_t N, size_t... S> struct GenSeq : GenSeq<N - 1, N - 1, S...> {};
 
 // Sequence generator, the terminal case when storing the generated sequence
 // into Seq.
 template <size_t... S> struct GenSeq<0, S...> { using Type = Seq<S...>; };
 
 // Specialization of InvokerImpl template for std::function.
 // NOTE: No std::function<void(void) noexcept>.
 template <typename T, typename... Ts>
 class InvokerImpl<std::function<void(T, Ts...) noexcept>> final
     : public Invoker {
 
   // Type alias for the stored function.
   using function_t = std::function<void(T, Ts...) noexcept>;
 
   // Type alias for correctly typed argument-tuples as obtained from Messages.
   using args_t = std::tuple<const T &, const Ts &...>;
 
   // Alias for MessageMatcher for the arguments of the stored function.
   using Matcher = MsgMatcher<T, Ts...>;
 
   // The wrapped function.
   const function_t F;
 
   // Helper function invoking F by unpacking Args with the help of actual
   // template arguments.
   // PRE: sizeof...(S) == std::tuple_size<args_t>::value
   template <size_t... S>
   inline void invokeFunction(Seq<S...>, const args_t &Args) const noexcept;
 
 public:
   // Ctor.
   InvokerImpl(function_t &&F) noexcept : F(F) {
     ASSERT(bool(F)); // Sanity check.
   }
 
   // Dtor.
   ~InvokerImpl(void) = default;
 
   // Tells if Msg can be used to invoke F.
   bool match(const Message &Msg) const noexcept override {
     return Matcher::doesStronglyMatch(Msg);
   };
 
   // Invokes F with Msg if Msg can be used to invoke F.
   result_t operator()(const Message &Msg) const noexcept override {
     if (match(Msg)) {
       LOG_TRACE("Invoking with matching arguments");
       invokeFunction(typename GenSeq<sizeof...(Ts) + 1>::Type(),
                      Matcher::extractedValues(Msg));
       return result_t::Invoked;
     } else {
       LOG_TRACE("Tried to invoke with non-matching arguments");
       return result_t::NoMatch;
     }
   }
 };
 
 template <typename T, typename... Ts>
 template <size_t... S>
 void InvokerImpl<std::function<void(T, Ts...) noexcept>>::invokeFunction(
     Seq<S...>, const args_t &Args) const noexcept {
   ASSERT(sizeof...(S) == std::tuple_size<args_t>::value); // Sanity check.
   F(std::get<S>(Args)...);
 }
 
 } // End namespace
 
 template <typename T, typename... Ts>
 Invoker::invoker_t
 Invoker::wrap(std::function<void(T, Ts...) noexcept> &&F) noexcept {
   return std::unique_ptr<Invoker>(
       new InvokerImpl<std::function<void(T, Ts...) noexcept>>(std::move(F)));
 }
 
 } // End namespace rosa
 
 #endif // ROSA_CORE_INVOKER_HPP
 
diff --git a/include/rosa/core/Message.hpp b/include/rosa/core/Message.hpp
index d02586c..c874a45 100644
--- a/include/rosa/core/Message.hpp
+++ b/include/rosa/core/Message.hpp
@@ -1,306 +1,307 @@
 /*******************************************************************************
  *
  * File:     Message.hpp
  *
  * Contents: Declaration of Message base-class.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #ifndef ROSA_CORE_MESSAGE_HPP
 #define ROSA_CORE_MESSAGE_HPP
 
 #include "rosa/support/log.h"
 #include "rosa/support/type_token.hpp"
+
 #include <memory>
 #include <vector>
 
 namespace rosa {
 
 // Message interface. The interface provides means to check the type of the
 // stored values, but actual data is to be managed by derived implementations.
 // Messages are immutable data objects, obtaining their data upon creation and
 // providing only constant references for the stored values.
 // NOTE: Any reference obtained from a Message instance remains valid only as
 // long as the owning Message object is not destroyed.
 class Message {
 protected:
   // Ctor.
   // NOTE: No implementation for empty list.
   template <typename Type, typename... Ts>
   Message(const Type &, const Ts &...) noexcept;
 
   // No copy and move.
   Message(const Message &) = delete;
   Message(Message &&) = delete;
   Message &operator=(const Message &) = delete;
   Message &operator=(Message &&) = delete;
 
 public:
   // Type alias for a smart pointer for Message.
   using message_t = std::unique_ptr<Message>;
 
   // Factory function to locally create a Message instance from constant
   // references.
   template <typename Type, typename... Types>
   static message_t create(const Type &T, const Types &... Ts) noexcept;
 
   // Factory function to locally create a Message instance from movable
   // references.
   template <typename Type, typename... Types>
   static message_t create(Type &&T, Types &&... Ts) noexcept;
 
   // A valid, non-empty token representing the types of the values stored in
   // the Message.
   const Token T;
 
   // The number of types encoded in T, that is the number of values stored in
   // Message.
   const size_t Size;
 
   // Virtual dtor.
   virtual ~Message(void);
 
   // Tells if the value in position Pos is of type Type.
   // NOTE: Token encodes atoms as AtomValue and not directly AtomConstants.
   // PRE: Pos < Size
   template <typename Type> bool isTypeAt(const size_t Pos) const noexcept;
 
   // Gives a constant reference of the value of type Type in position Pos.
   // PRE: Pos < Size && isTypeAt(Pos)
   template <typename Type>
   const Type &getValueAt(const size_t Pos) const noexcept;
 
 protected:
   // Provides an untyped pointer for the value in position Pos.
   // PRE: Pos < Size
   virtual const void *getPointerTo(const size_t Pos) const noexcept = 0;
 };
 
 // Nested namespace with an implementation for Message, consider it private.
 namespace {
 
 // Template class for an implementation of Message, definition below.
 template <typename... Types> class LocalMessage;
 
 // Initializes Arena with values from const references of Types.
 // NOTE: Arena needs to be a valid pointer to a memory area big enough for
 // values of Types.
 template <typename... Types>
 inline void createMessageElements(void *const Arena,
                                   const Types &... Ts) noexcept;
 
 // NOTE: This terminal case is used for both constant references and movable
 // references.
 template <size_t Pos>
 inline void createMessageElement(void *const,
                                  const std::vector<size_t> &Offsets) {
   ASSERT(Pos == Offsets.size());
 }
 
 template <size_t Pos, AtomValue V, typename... Types>
 inline void
 createMessageElement(void *const Arena, const std::vector<size_t> &Offsets,
                      const AtomConstant<V> &, const Types &... Ts) noexcept {
   ASSERT(Arena != nullptr && Pos < Offsets.size());
   *static_cast<AtomValue *>(
       static_cast<void *>(static_cast<uint8_t *>(Arena) + Offsets[Pos])) = V;
   createMessageElement<Pos + 1>(Arena, Offsets, Ts...);
 }
 
 template <size_t Pos, typename Type, typename... Types>
 inline void createMessageElement(void *const Arena,
                                  const std::vector<size_t> &Offsets,
                                  const Type &T, const Types &... Ts) noexcept {
   ASSERT(Arena != nullptr && Pos < Offsets.size());
   new (static_cast<Type *>(static_cast<void *>(static_cast<uint8_t *>(Arena) +
                                                Offsets[Pos]))) Type(T);
   createMessageElement<Pos + 1>(Arena, Offsets, Ts...);
 }
 
 template <typename Type, typename... Types>
 inline void createMessageElements(void *const Arena, const Type &T,
                                   const Types &... Ts) noexcept {
   ASSERT(Arena != nullptr);
   createMessageElement<0>(Arena, LocalMessage<Type, Types...>::Offsets, T,
                           Ts...);
 }
 
 // Initializes Arena with values from movable references of Types.
 // NOTE: Arena needs to be a valid pointer to a memory area big enough for
 // values of Types.
 template <typename... Types>
 inline void createMessageElements(void *const Arena, Types &&... Ts) noexcept;
 
 template <size_t Pos, AtomValue V, typename... Types>
 inline void createMessageElement(void *const Arena,
                                  const std::vector<size_t> &Offsets,
                                  AtomConstant<V> &&, Types &&... Ts) noexcept {
   ASSERT(Arena != nullptr && Pos < Offsets.size());
   *static_cast<AtomValue *>(
       static_cast<void *>(static_cast<uint8_t *>(Arena) + Offsets[Pos])) = V;
   createMessageElement<Pos + 1>(Arena, Offsets, std::move(Ts)...);
 }
 
 template <size_t Pos, typename Type, typename... Types>
 inline void createMessageElement(void *const Arena,
                                  const std::vector<size_t> &Offsets, Type &&T,
                                  Types &&... Ts) noexcept {
   ASSERT(Arena != nullptr && Pos < Offsets.size());
   new (static_cast<Type *>(static_cast<void *>(
       static_cast<uint8_t *>(Arena) + Offsets[Pos]))) Type(std::move(T));
   createMessageElement<Pos + 1>(Arena, Offsets, std::move(Ts)...);
 }
 
 template <typename Type, typename... Types>
 inline void createMessageElements(void *const Arena, Type &&T,
                                   Types &&... Ts) noexcept {
   ASSERT(Arena != nullptr);
   createMessageElement<0>(Arena, LocalMessage<Type, Types...>::Offsets,
                           std::move(T), std::move(Ts)...);
 }
 
 // Destroyes values of Types stored in Arena.
 // NOTE: Arena needs to be a valid pointer to a memory area where values of
 // Types are stored.
 template <typename Type, typename... Types>
 inline void destroyMessageElements(void *const Arena) noexcept;
 
 template <size_t Pos>
 inline void destroyMessageElement(void *const,
                                   const std::vector<size_t> &Offsets) noexcept {
   ASSERT(Pos == Offsets.size());
 }
 
 template <size_t Pos, typename Type, typename... Types>
 inline void destroyMessageElement(void *const Arena,
                                   const std::vector<size_t> &Offsets) noexcept {
   ASSERT(Arena != nullptr && Pos < Offsets.size());
   static_cast<Type *>(
       static_cast<void *>(static_cast<uint8_t *>(Arena) + Offsets[Pos]))
       ->~Type();
   destroyMessageElement<Pos + 1, Types...>(Arena, Offsets);
 }
 
 template <typename Type, typename... Types>
 inline void destroyMessageElements(void *const Arena) noexcept {
   destroyMessageElement<0, Type, Types...>(
       Arena, LocalMessage<Type, Types...>::Offsets);
 }
 
 // Implementation of the template LocalMessage. Provides facilities for storing
 // values as a Message.
 template <typename Type, typename... Types>
 class LocalMessage<Type, Types...> : public Message {
 public:
   // Type Token for the stored values.
   // NOTE: Only for compile-time checks, static member is not defined.
   static constexpr Token ST =
       TypeToken<typename std::decay<Type>::type,
                 typename std::decay<Types>::type...>::Value;
 
   // Offsets required to access values in Arena.
   static const std::vector<size_t> Offsets;
 
 private:
   // A BLOB storing all the values one after the other.
   void *const Arena;
 
   // Generates offset for accessing values in Arena.
   static std::vector<size_t> getOffsets(void) noexcept {
     Token T = ST;                            // Need a mutable copy.
     size_t I = 0;                            // Start indexing from position 0.
     std::vector<size_t> O(lengthOfToken(T)); // Allocate vector of proper size.
     O[0] = 0;                                // First offset is always 0.
     while (!emptyToken(T)) {
       ASSERT(I < O.size());
       // Calculate next offset based on the previous one.
       O[I + 1] = O[I] + sizeOfHeadOfToken(T);
       dropHeadOfToken(T), ++I;
     }
     ASSERT(I == O.size());
     return O;
   }
 
 public:
   // Ctor for constant references.
   LocalMessage(const Type &T, const Types &... Ts) noexcept
       : Message(T, Ts...),
         Arena(::operator new(sizeOfValuesOfToken(ST))) {
     ASSERT(this->T == ST && Size == Offsets.size() &&
            Arena != nullptr); // Sanity check.
     createMessageElements(Arena, T, Ts...);
   }
 
   // Ctor for movable referecens.
   LocalMessage(Type &&T, Types &&... Ts) noexcept
       : Message(T, Ts...),
         Arena(::operator new(sizeOfValuesOfToken(ST))) {
     ASSERT(this->T == ST && Size == Offsets.size() &&
            Arena != nullptr); // Sanity check.
     createMessageElements(Arena, std::move(T), std::move(Ts)...);
   }
 
   // Dtor.
   ~LocalMessage(void) {
     destroyMessageElements<Type, Types...>(Arena);
     ::operator delete(Arena);
   }
 
   // Provides an untyped pointer for the constant value at Pos.
   const void *getPointerTo(const size_t Pos) const noexcept override {
     ASSERT(Pos < Offsets.size());
     return static_cast<uint8_t *>(Arena) + Offsets[Pos];
   }
 };
 
 // Implementation of the static member field Offsets.
 template <typename Type, typename... Types>
 const std::vector<size_t> LocalMessage<Type, Types...>::Offsets =
     LocalMessage<Type, Types...>::getOffsets();
 
 } // End namespace
 
 template <typename Type, typename... Ts>
 Message::Message(const Type &, const Ts &...) noexcept
     : T(TypeToken<typename std::decay<Type>::type,
                   typename std::decay<Ts>::type...>::Value),
       Size(lengthOfToken(T)) {
   ASSERT(validToken(T) &&
          lengthOfToken(T) == (1 + sizeof...(Ts))); // Sanity check.
   LOG_TRACE("Creating Message with Token(" + to_string(T) + ")");
 }
 
 template <typename Type, typename... Types>
 Message::message_t Message::create(const Type &T,
                                    const Types &... Ts) noexcept {
   return message_t(new LocalMessage<Type, Types...>(T, Ts...));
 }
 
 template <typename Type, typename... Types>
 Message::message_t Message::create(Type &&T, Types &&... Ts) noexcept {
   return message_t(
       new LocalMessage<Type, Types...>(std::move(T), std::move(Ts)...));
 }
 
 template <typename Type>
 bool Message::isTypeAt(const size_t Pos) const noexcept {
   ASSERT(Pos < Size);
   Token T_ = T; // NOLINT
   dropNOfToken(T_, Pos);
   return isHeadOfTokenTheSameType<Type>(T_);
 }
 
 template <typename Type>
 const Type &Message::getValueAt(const size_t Pos) const noexcept {
   ASSERT(Pos < Size && isTypeAt<Type>(Pos));
   return *static_cast<const Type *>(getPointerTo(Pos));
 }
 
 } // End namespace rosa
 
 #endif // ROSA_CORE_MESSAGE_HPP
 
diff --git a/include/rosa/core/MessageHandler.hpp b/include/rosa/core/MessageHandler.hpp
index c2bb605..2d93c99 100644
--- a/include/rosa/core/MessageHandler.hpp
+++ b/include/rosa/core/MessageHandler.hpp
@@ -1,113 +1,115 @@
 /*******************************************************************************
  *
  * File:     MessageHandler.hpp
  *
  * Contents: Definition of MessageHandler interface.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #ifndef ROSA_CORE_MESSAGEHANDLER_HPP
 #define ROSA_CORE_MESSAGEHANDLER_HPP
 
 #include "rosa/core/Invoker.hpp"
+
 #include "rosa/support/log.h"
+
 #include <vector>
 
 namespace rosa {
 
 // Handles Message instances. A MessageHandler stores Invokers and tries to
 // apply Messages to them in the order of definition. The first matching
 // Invoker is invoked with the Message, after which handling of Message is
 // completed.
 //
 // For example, consider the following snippet:
 //
 // MessageHandler {
 //   Invoker::F<uint8_t>([](uint8_t) { /* ... */ }),
 //   Invoker::F<uint8_t>([](uint8_t) { /* Never invoked */ })
 // };
 //
 // Applying a Message with TypeList<uint8_t> invokes the first function, and
 // the second function would never be invoked because any matching Message had
 // already been handled by the first one.
 class MessageHandler {
 
   // Using invoker_t from Invoker.
   using invoker_t = Invoker::invoker_t;
 
   // Type alias for a vector storing Invokers.
   using invokers_t = std::vector<invoker_t>;
 
   // Stores the Invokers of this MessageHandler.
   const invokers_t Invokers;
 
   // Creates a container with Invokers from the given functions.
   template <typename Fun, typename... Funs>
   static inline invokers_t createInvokers(Fun &&F, Funs &&... Fs) noexcept;
 
   // Wraps F into an Invoker and stores it into I at position Pos.
   // PRE: Pos < I.size()
   template <typename Fun, typename... Funs>
   static inline void wrapFun(invokers_t &I, const size_t Pos, Fun &&F,
                              Funs &&... Fs) noexcept;
 
   // Terminal case for function wrapper.
   // PRE: Pos == I.size();
   static inline void wrapFun(invokers_t &I, const size_t Pos) noexcept;
 
 public:
   // Ctor, stores the given functions into the new MessageHandler instance.
   template<typename Fun, typename... Funs>
   MessageHandler(Fun &&F, Funs &&... Fs) noexcept;
 
   virtual ~MessageHandler(void);
 
   // Tells if there is any Invoker that can handle Msg.
   bool canHandle(const Message &Msg) const noexcept;
 
   // Applies Msg to the first Invoker which can handle Msg, and tells if there
   // was any.
   // NOTE: This operator finds the first applicable Invoker and invokes it with
   // Msg, while the member function canHandle only checks if there is any
   // Invoker that can be invoked with Msg.
   bool operator()(const Message &Msg) const noexcept;
 };
 
 template <typename Fun, typename... Funs>
 MessageHandler::MessageHandler(Fun &&F, Funs &&... Fs) noexcept
     : Invokers(createInvokers(std::move(F), std::move(Fs)...)) {
   LOG_TRACE("MessageHandler is created");
 }
 
 template <typename Fun, typename... Funs>
 MessageHandler::invokers_t
 MessageHandler::createInvokers(Fun &&F, Funs &&... Fs) noexcept {
   // Create a container with the required size and get all the functions
   // wrapped.
   invokers_t I(1 + sizeof...(Funs));
   wrapFun(I, 0, std::move(F), std::move(Fs)...);
   return I;
 }
 
 template <typename Fun, typename... Funs>
 void MessageHandler::wrapFun(invokers_t &I, const size_t Pos, Fun &&F,
                              Funs &&... Fs) noexcept {
   ASSERT(Pos < I.size()); // Sanity check.
   // Wrap the current function and continue with the rest.
   I[Pos] = Invoker::wrap(std::move(F));
   wrapFun(I, Pos + 1, std::move(Fs)...);
 }
 
 void MessageHandler::wrapFun(invokers_t &I, const size_t Pos) noexcept {
   ASSERT(Pos == I.size()); // Sanity check.
   // Nothing to do here.
 }
 
 } // End namespace rosa
 
 #endif // ROSA_CORE_MESSAGEHANDLER_HPP
 
diff --git a/include/rosa/core/MessageMatcher.hpp b/include/rosa/core/MessageMatcher.hpp
index c636f3a..b3d6b2a 100644
--- a/include/rosa/core/MessageMatcher.hpp
+++ b/include/rosa/core/MessageMatcher.hpp
@@ -1,167 +1,168 @@
 /*******************************************************************************
  *
  * File:     MessageMatcher.hpp
  *
  * Contents: Implementation of MessageMatcher.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #ifndef ROSA_CORE_MESSAGEMATCHER_HPP
 #define ROSA_CORE_MESSAGEMATCHER_HPP
 
 #include "rosa/core/Message.hpp"
+
 #include <tuple>
 
 namespace rosa {
 
 // Template class with static functions type-checking a Message instance and
 // extracting stored values from Message instsances into std::tuple instances
 // with matching type arguments.
 template <typename List> struct MessageMatcher;
 
 // Definition of MessageMatcher for non-empty lists of types, like Message
 // itself.
 template <typename Type, typename... Ts>
 struct MessageMatcher<TypeList<Type, Ts...>> {
 
   // Type Token associated with the give TypeList.
   static constexpr Token T = TypeToken<Type, Ts...>::Value;
 
   // Tells if stored values in Msg are matching types given as
   // TypeList<T, Ts...>, considering exact AtomConstants instead of AtomValues.
   static inline bool doesStronglyMatch(const Message &Msg) noexcept;
 
   // Gives a std::tuple with references to values stored in a type-matching Msg.
   // PRE: doesStronglyMatch(Msg)
   static inline std::tuple<const Type &, const Ts &...>
   extractedValues(const Message &Msg) noexcept;
 };
 
 // Convenience template alias turning a list of types into a TypeList for
 // MessageMatcher.
 template <typename Type, typename...Ts>
 using MsgMatcher = MessageMatcher<TypeList<Type, Ts...>>;
 
 // Nested namespace with implementation for features of MessageMatcher,
 // consider it private.
 namespace {
 
 // Helper struct implementing type-checking and value extraction for
 // MessageMatcher.
 template <typename List> struct MessageMatcherImpl;
 
 // Specialization handling the empty list of types.
 template <> struct MessageMatcherImpl<EmptyTypeList> {
   static inline bool doesStronglyMatchFrom(const Message &Msg,
                                            const size_t Pos) noexcept {
     // Matching EmptyTypeList only if reached the end of the stored types.
     return Pos == Msg.Size;
   }
 
   static inline std::tuple<> extractedValuesFrom(const Message &Msg,
                                                  const size_t Pos) noexcept {
     // It is valid to extract an empty list only if we reached the end of
     // stored values.
     ASSERT(doesStronglyMatchFrom(Msg, Pos));
     return std::tie();
   }
 };
 
 // Specialization handling an AtomValue in the head.
 template <AtomValue V, typename... Ts>
 struct MessageMatcherImpl<TypeList<AtomConstant<V>, Ts...>> {
 
   static inline bool doesHeadStronglyMatchAt(const Message &Msg,
                                              const size_t Pos) noexcept {
     // Matching an AtomConstant in the head if there is a type stored at Pos,
     // the stored type is AtomValue, and the corresponding value matches the
     // AtomValue V.
     return Pos < Msg.Size && Msg.isTypeAt<AtomValue>(Pos) &&
            Msg.getValueAt<AtomValue>(Pos) == V;
   }
 
   static inline bool doesStronglyMatchFrom(const Message &Msg,
                                            const size_t Pos) noexcept {
     // Matching a non-empty list if the head is matching and the rest of the
     // list is matching.
     return doesHeadStronglyMatchAt(Msg, Pos) &&
            MessageMatcherImpl<TypeList<Ts...>>::doesStronglyMatchFrom(Msg,
                                                                       Pos + 1);
   }
 
   static inline std::tuple<const AtomConstant<V> &, const Ts &...>
   extractedValuesFrom(const Message &Msg, const size_t Pos) noexcept {
     // Extracting for a non-empty list with a matching AtomConstant in the head
     // by getting the encoded AtomConstant and concatenating it with values
     // extracted for the rest of the list.
     ASSERT(doesHeadStronglyMatchAt(Msg, Pos));
     return std::tuple_cat(
         std::tie(AtomConstant<V>::Value),
         MessageMatcherImpl<TypeList<Ts...>>::extractedValuesFrom(Msg, Pos + 1));
   }
 
 };
 
 // Specialization handling an regular builtin type (not an AtomConstant) in the
 // head.
 template <typename T, typename... Ts>
 struct MessageMatcherImpl<TypeList<T, Ts...>> {
 
   static inline bool doesHeadStronglyMatchAt(const Message &Msg,
                                              const size_t Pos) noexcept {
     // Matching the head if there is a type stored at Pos, and the stored type
     // is T.
     return Pos < Msg.Size && Msg.isTypeAt<T>(Pos);
   }
 
   static inline bool doesStronglyMatchFrom(const Message &Msg,
                                            const size_t Pos) noexcept {
     // Matching a non-empty list if the head is matching and the rest of the
     // list is matching.
     return doesHeadStronglyMatchAt(Msg, Pos) &&
            MessageMatcherImpl<TypeList<Ts...>>::doesStronglyMatchFrom(Msg,
                                                                       Pos + 1);
   }
 
   static inline std::tuple<const T &, const Ts &...>
   extractedValuesFrom(const Message &Msg, const size_t Pos) noexcept {
     // Extracting for a non-empty list with a matching head by getting the
     // value for the head and concatenating it with values extracted for the
     // rest of the list.
     ASSERT(doesHeadStronglyMatchAt(Msg, Pos));
     return std::tuple_cat(
         std::tie(Msg.getValueAt<T>(Pos)),
         MessageMatcherImpl<TypeList<Ts...>>::extractedValuesFrom(Msg, Pos + 1));
   }
 };
 
 } // End namespace
 
 template <typename Type, typename... Ts>
 bool MessageMatcher<TypeList<Type, Ts...>>::doesStronglyMatch(
     const Message &Msg) noexcept {
   // NOTE: Fail quick on the size and T, then match against list with squashed
   // integers as Tokens are generated.
   return (1 + sizeof...(Ts)) == Msg.Size && T == Msg.T &&
          MessageMatcherImpl<typename SquashedTypeList<
              TypeList<Type, Ts...>>::Type>::doesStronglyMatchFrom(Msg, 0);
 }
 
 template <typename Type, typename... Ts>
 std::tuple<const Type &, const Ts &...>
 MessageMatcher<TypeList<Type, Ts...>>::extractedValues(
     const Message &Msg) noexcept {
   ASSERT(doesStronglyMatch(Msg));
   // NOTE: Match against list with squashed integers as Tokens are generated.
   return MessageMatcherImpl<typename SquashedTypeList<
       TypeList<Type, Ts...>>::Type>::extractedValuesFrom(Msg, 0);
 }
 
 } // End namespace rosa
 
 #endif // ROSA_CORE_MESSAGEMATCHER_HPP
 
diff --git a/include/rosa/core/System.hpp b/include/rosa/core/System.hpp
index 0025531..3ea3fab 100644
--- a/include/rosa/core/System.hpp
+++ b/include/rosa/core/System.hpp
@@ -1,133 +1,135 @@
 /*******************************************************************************
  *
  * File:     System.hpp
  *
  * Contents: Declaration of System base-class.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #ifndef ROSA_CORE_SYSTEM_HPP
 #define ROSA_CORE_SYSTEM_HPP
 
 #include "rosa/config/config.h"
+
 #include "rosa/support/debug.hpp"
 #include "rosa/support/log.h"
+
 #include <atomic>
 #include <memory>
 #include <string>
 
 namespace rosa {
 
 // Forward declarations.
 class Unit;
 
 // Base-class for actual agent-systems, the class provides facitlities to keep
 // track of Units of the system.
 // NOTE: This class and any subclasses are supposed to provide thread-safe
 // interfaces.
 class System {
 public:
   // Signature of creator functions for Units.
   template <typename T>
   using UnitCreator = std::function<T *(const size_t, System &)noexcept>;
 
   // Returns an object implementing the interface defined by the class.
   static std::unique_ptr<System> createSystem(const std::string &Name) noexcept;
 
 protected:
   // Protected ctor, only subclasses can instantiate.
   System(const std::string &Name) noexcept;
 
   // No copy and move.
   System(const System&) = delete;
   System(System&&) = delete;
   System &operator=(const System&) = delete;
   System &operator=(System&&) = delete;
 
 public:
   // Dtor. Only a cleared System can be destroyed.
   // PRE: SystemCleaned
   virtual ~System(void);
 
 protected:
 
   // Sets SystemCleaned flag. Can be called only once and the System must not
   // have any live Units.
   // PRE: !SystemCleaned && empty()
   // POST: SystemCleaned
   void markCleaned(void) noexcept;
 
   // Creates a Unit instance with the given UnitCreator, using the given Name
   // if any, then registers the new Unit instance by calling the virtual
   // member function registerUnit.
   // NOTE: This function handles the member field CountUnits.
   // STATIC PRE: std::is_base_of<Unit, T>::value
   // PRE: !SystemCleaned
   template <typename T>
   T &createUnit(UnitCreator<T> C) noexcept;
 
   // Registers the given Unit instance to the System.
   // PRE: !isUnitRegistered(U)
   // POST: isUnitRegistered(U)
   virtual void registerUnit(Unit &U) noexcept = 0;
 
   // Unregisters and destroys the given Unit.
   // PRE: isUnitRegistered(U)
   // POST: !isUnitRegistered(U) && 'U is destroyed'
   virtual void destroyUnit(Unit &U) noexcept = 0;
 
   // Returns if the given Unit is registered in the System.
   virtual bool isUnitRegistered(const Unit &U) const noexcept = 0;
 
 public:
   // The textual name of the System.
   const std::string Name;
 
 private:
   // Number of Units constructed in the system.
   // NOTE: Should never be decremented!
   std::atomic<size_t> CountUnits;
 
   // Indicates that the System has been cleaned and is ready for destruction.
   // The field is initialized as 'false' and can be set by the member function
   // markCleaned.
   // Subclasses must set the flag upon destroying the System instance, which
   // indicates to the destructor of the base-class that all the managed
   // resources has been properly released.
   std::atomic<bool> SystemCleaned;
 
 public:
   // Returns the number of Units constructed in the System so far,
   // including those being already destroyed.
   size_t numberOfConstructedUnits(void) const noexcept;
 
   // Returns the number of live Units, that have been constructed and not
   // destroyed yet.
   virtual size_t numberOfLiveUnits(void) const noexcept = 0;
 
   // Returns if the System has no live Units.
   virtual bool empty(void) const noexcept = 0;
 };
 
 template <typename T>
 T &System::createUnit(UnitCreator<T> C) noexcept {
   STATIC_ASSERT((std::is_base_of<Unit, T>::value), "not a Unit");
   if (SystemCleaned) {
     ROSA_CRITICAL("Trying to create a Unit in an already cleaned System (" +
                   Name + ")");
   }
   const uint64_t Id = ++CountUnits;
   T *U = C(Id, *this);
   registerUnit(*U);
   LOG_TRACE("Unit created and registered (" + U->FullName + ")");
   return *U;
 }
 
 } // End namespace rosa
 
 #endif // ROSA_CORE_SYSTEM_HPP
 
diff --git a/include/rosa/core/Unit.h b/include/rosa/core/Unit.h
index cecb663..1541398 100644
--- a/include/rosa/core/Unit.h
+++ b/include/rosa/core/Unit.h
@@ -1,85 +1,86 @@
 /*******************************************************************************
  *
  * File:     Unit.h
  *
  * Contents: Declaration of Unit base-class.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #ifndef ROSA_CORE_UNIT_H
 #define ROSA_CORE_UNIT_H
 
 #include "rosa/support/atom.hpp"
+
 #include <ostream>
 #include <string>
 
 namespace rosa {
 
 // Forward declarations.
 class System;
 
 // Base class for every entity in the system that has to be identified and
 // traced.
 // NOTE: Life-cycle of Unit instances is supposed to be managed by a System, do
 // not create and destroy a Unit directly.
 class Unit {
 public:
 
   // Identifies the kind of the Unit.
   // NOTE: Kind is dependent on the owning System.
   const AtomValue Kind;
 
   // System-assigned unique identifier of the Unit instance,
   // based on the static member field CountUnits.
   const size_t Id;
 
   // Textual identifier of the Unit instance. Defaults to a text referring to
   // the Id value of the Unit, unless otherwise defined via a constructor
   // argument. The Name of a Unit is not necessarily unique in the system.
   const std::string Name;
 
 protected:
   // The owning System.
   System &S;
 
 public:
   // Full qualified name of the Unit instance.
   const std::string FullName;
 
 public:
   // Ctor.
   // PRE: !Name.empty()
   Unit(const AtomValue Kind, const size_t Id, const std::string &Name,
        System &S) noexcept;
 
   // No copy and move.
   Unit(const Unit &) = delete;
   Unit(Unit &&) = delete;
   Unit &operator=(const Unit &) = delete;
   Unit &operator=(Unit &&) = delete;
 
   // Dtor.
   virtual ~Unit(void);
 
   // Dumping the object into a string for tracing purposes,
   // subclasses are supposed to override this function.
   virtual std::string dump(void) const noexcept;
 
 protected:
   // Returns a reference to the owning System.
   // NOTE: Subclasses may override the function to return a reference of a
   // special System subtype.
   virtual System &system() const noexcept;
 };
 
 // Helper function dumping the given Unit instance to the given output stream.
 std::ostream &operator<<(std::ostream &OS, const Unit &U);
 
 } // End namespace rosa
 
 #endif // ROSA_CORE_UNIT_H
 
diff --git a/include/rosa/support/debug.hpp b/include/rosa/support/debug.hpp
index dcbed4a..48048fe 100644
--- a/include/rosa/support/debug.hpp
+++ b/include/rosa/support/debug.hpp
@@ -1,89 +1,91 @@
 /*******************************************************************************
  *
  * File:     debug.hpp
  *
  * Contents: Facility for debugging
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #ifndef ROSA_SUPPORT_DEBUG_HPP
 #define ROSA_SUPPORT_DEBUG_HPP
 
 #include "rosa/config/config.h"
+
 #include "rosa/support/type_helper.hpp"
 #include "rosa/support/terminal_colors.h"
+
 #include <array>
 #include <ostream>
 
 namespace rosa {
 
 // Returns an output stream to use for debugging.
 std::ostream &dbgs(void);
 
 // Prints an array to the ostream.
 template <typename T, size_t size>
 std::ostream &operator<<(std::ostream &os, const std::array<T, size> &arr) {
   os << '[';
   for (unsigned I = 0; I < size; ++I) {
     if (I) {
       os << ',';
     }
     os << (PRINTABLE(T)) arr[I];
   }
   os << ']';
   return os;
 }
 
 } // End namespace rosa
 
 #ifndef ROSA_ENABLE_ASSERTIONS
 #define ASSERT(stmt) ROSA_IGNORE_UNUSED(stmt)
 #elif defined(ROSA_WINDOWS)
 #define ASSERT(stmt)                                                           \
   if (static_cast<bool>(stmt) == false) {                                      \
     rosa::dbgs() << rosa::terminal::Color::Default << __FILENAME__ << ":"      \
                  << __LINE__ << ": requirement failed: '" << #stmt << "'"      \
                  << std::endl;                                                 \
     ::abort();                                                                 \
   }                                                                            \
   ROSA_VOID_STMT
 #else // defined(ROSA_LINUX)
 #include <execinfo.h>
 #define ASSERT(stmt)                                                           \
   if (static_cast<bool>(stmt) == false) {                                      \
     rosa::dbgs() << rosa::terminal::Color::Default << __FILENAME__ << ":"      \
                  << __LINE__ << ": requirement failed: '" << #stmt << "'"      \
                  << std::endl;                                                 \
     void *array[20];                                                           \
     auto bt_size = ::backtrace(array, 20);                                     \
     ::backtrace_symbols_fd(array, bt_size, 2);                                 \
     ::abort();                                                                 \
   }                                                                            \
   ROSA_VOID_STMT
 #endif // defined(ROSA_ENABLE_ASSERTIONS)
 
 #ifndef NDEBUG
 #define DEBUG(X)                                                               \
   do {                                                                         \
     X;                                                                         \
   } while (false)
 #define DEBUGVAR(V)                                                            \
   do {                                                                         \
     rosa::dbgs() << rosa::terminal::Color::Default << #V << " ("               \
                  << __FILENAME__ << ":" << __LINE__ << "): " << (V)            \
                  << std::endl;                                                 \
   } while (false)
 #else // defined(NDEBUG)
 #define DEBUG(X) ROSA_IGNORE_UNUSED(X)
 #define DEBUGVAR(X) ROSA_IGNORE_UNUSED(X)
 #endif // defined(NDEBUG)
 
 // Static assertions are always emitted to the code.
 #define STATIC_ASSERT(COND, DIAG) static_assert((COND), DIAG)
 
 #endif // ROSA_SUPPORT_DEBUG_HPP
 
diff --git a/include/rosa/support/log.h b/include/rosa/support/log.h
index 60345a6..351d106 100644
--- a/include/rosa/support/log.h
+++ b/include/rosa/support/log.h
@@ -1,159 +1,161 @@
 /*******************************************************************************
  *
  * File:     log.h
  *
  * Contents: Facility for logging
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #ifndef ROSA_SUPPORT_LOG_H
 #define ROSA_SUPPORT_LOG_H
 
 #include "rosa/config/config.h"
+
 #include "rosa/support/terminal_colors.h"
+
 #include <iostream>
 #include <string>
 
 // NOTE: One call for the various logging macros below is supposed to be used
 // for registering one log entry. That goes natural with the non-stream
 // implementations, which accept one string as argument. A more flexible way
 // for printing log entries, for example colorizing text, is to use macros
 // providing a log stream. It is important to note, however, that the stream
 // obtained from one macro evaluation fits for printing one log entry, without
 // nested/overlapping log entry emissions and the entry being closed with a
 // newline. Should this simple recommendation not being followed, the result
 // becomes hard to read due to missing line breaks and overlapping entries.
 // FIXME: Thread-safety is another issue, which need to be addressed for proper
 // logging.
 
 /* ****************************************************************************
  *                                Log Levels                                  *
  * ****************************************************************************/
 
 namespace rosa {
 
 // Type-safe definition of log levels, use this in code.
 // NOTE: Keep values in sync with the corresponding preprocessor definitions
 // below.
 enum class LogLevel {
   Error,
   Warning,
   Info,
   Debug,
   Trace,
   // Number of log levels:
   NumLogLevels
 };
 
 // Converts a LogLevel to its string representation.
 // PRE: logLevel != LogLevel::NumLogLevels
 std::string logLevelToString(const LogLevel logLevel);
 
 // Prints colorized tag for the given LogLevel.
 // PRE: logLevel != LogLevel::NumLogLevels
 std::ostream &operator<<(std::ostream &os, const LogLevel logLevel);
 
 } // End namespace rosa
 
 // Valid log levels, only for preprocessor definitions below.
 // NOTE: Keep in sync with the values of enum class rosa::LogLevel.
 #define ROSA_LOG_LEVEL_ERROR 0
 #define ROSA_LOG_LEVEL_WARNING 1
 #define ROSA_LOG_LEVEL_INFO 2
 #define ROSA_LOG_LEVEL_DEBUG 3
 #define ROSA_LOG_LEVEL_TRACE 4
 
 /* ****************************************************************************
  *                           Logger Implementation                            *
  * ****************************************************************************/
 
 // Stream to print logs to.
 // FIXME: Make it configurable, e.g. printing into a file.
 #define ROSA_LOG_OSTREAM std::clog
 
 // Simple logging implementation printing a string message.
 #define ROSA_LOG_IMPL(level, output)                                           \
   do {                                                                         \
     ROSA_LOG_OSTREAM << (level) << " " << __func__ << "@" << __FILENAME__      \
                      << ":" << __LINE__ << ": " << (output) << std::endl;      \
   } while (false)
 
 // Simple logging implementation providing a stream to print to.
 #define ROSA_LOG_STREAM_IMPL(level)                                            \
   ([](void) -> std::ostream & {                                                \
     return ROSA_LOG_OSTREAM << (level) << " " << __func__ << "@"               \
                             << __FILENAME__ << ":" << __LINE__ << ": ";        \
   }())
 
 namespace rosa {
 // Dummy ostream printing to nowhere.
 extern std::ostream LogSink;
 } // End namespace rosa
 
 // A stream ignoring all its input.
 #define ROSA_LOG_STREAM_IGNORE rosa::LogSink
 
 /* ****************************************************************************
  *                            Logging Interface                               *
  * ****************************************************************************/
 
 // Define logging macros if logging is enabled.
 #ifdef ROSA_LOG_LEVEL
 
 #define LOG_ERROR_STREAM ROSA_LOG_STREAM_IMPL(rosa::LogLevel::Error)
 #define LOG_ERROR(output) ROSA_LOG_IMPL(rosa::LogLevel::Error, output)
 
 #if ROSA_LOG_LEVEL >= ROSA_LOG_LEVEL_WARNING
 #define LOG_WARNING_STREAM ROSA_LOG_STREAM_IMPL(rosa::LogLevel::Warning)
 #define LOG_WARNING(output) ROSA_LOG_IMPL(rosa::LogLevel::Warning, output)
 #endif
 
 #if ROSA_LOG_LEVEL >= ROSA_LOG_LEVEL_INFO
 #define LOG_INFO_STREAM ROSA_LOG_STREAM_IMPL(rosa::LogLevel::Info)
 #define LOG_INFO(output) ROSA_LOG_IMPL(rosa::LogLevel::Info, output)
 #endif
 
 #if ROSA_LOG_LEVEL >= ROSA_LOG_LEVEL_DEBUG
 #define LOG_DEBUG_STREAM ROSA_LOG_STREAM_IMPL(rosa::LogLevel::Debug)
 #define LOG_DEBUG(output) ROSA_LOG_IMPL(rosa::LogLevel::Debug, output)
 #endif
 
 #if ROSA_LOG_LEVEL >= ROSA_LOG_LEVEL_TRACE
 #define LOG_TRACE_STREAM ROSA_LOG_STREAM_IMPL(rosa::LogLevel::Trace)
 #define LOG_TRACE(output) ROSA_LOG_IMPL(rosa::LogLevel::Trace, output)
 #endif
 
 #endif // defined ROSA_LOG_LEVEL
 
 // Define all disabled logging features as void.
 #ifndef LOG_ERROR
 #define LOG_ERROR_STREAM ROSA_LOG_STREAM_IGNORE
 #define LOG_ERROR(output) ROSA_IGNORE_UNUSED(output)
 #endif
 
 #ifndef LOG_WARNING
 #define LOG_WARNING_STREAM ROSA_LOG_STREAM_IGNORE
 #define LOG_WARNING(output) ROSA_IGNORE_UNUSED(output)
 #endif
 
 #ifndef LOG_INFO
 #define LOG_INFO_STREAM ROSA_LOG_STREAM_IGNORE
 #define LOG_INFO(output) ROSA_IGNORE_UNUSED(output)
 #endif
 
 #ifndef LOG_DEBUG
 #define LOG_DEBUG_STREAM ROSA_LOG_STREAM_IGNORE
 #define LOG_DEBUG(output) ROSA_IGNORE_UNUSED(output)
 #endif
 
 #ifndef LOG_TRACE
 #define LOG_TRACE_STREAM ROSA_LOG_STREAM_IGNORE
 #define LOG_TRACE(output) ROSA_IGNORE_UNUSED(output)
 #endif
 
 #endif // ROSA_SUPPORT_LOG_H
 
diff --git a/include/rosa/support/type_list.hpp b/include/rosa/support/type_list.hpp
index 1afba61..d4b18d2 100644
--- a/include/rosa/support/type_list.hpp
+++ b/include/rosa/support/type_list.hpp
@@ -1,199 +1,200 @@
 /*******************************************************************************
  *
  * File:     type_list.hpp
  *
  * Contents: Facilities for types representing lists of types.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  * This implementation is partially based on the type_list implementation of
  * CAF.
  * TODO: Check license.
  *
  ******************************************************************************/
 
 #ifndef ROSA_SUPPORT_TYPE_LIST_HPP
 #define ROSA_SUPPORT_TYPE_LIST_HPP
 
 #include "rosa/support/debug.hpp"
 #include "rosa/support/types.hpp"
+
 #include <type_traits>
 
 namespace rosa {
 
 // A list of types.
 template <typename... Ts> struct TypeList {
   constexpr TypeList() {
     // nop
   }
 };
 
 // Denotes the empty list.
 using EmptyTypeList = TypeList<>;
 
 // Gets element at index Pos of List.
 template <size_t Pos, typename... Ts> struct TypeListAtImpl;
 
 template <size_t Pos, typename T, typename... Ts>
 struct TypeListAtImpl<Pos, T, Ts...> {
   using Type = typename TypeListAtImpl<Pos - 1, Ts...>::Type;
 };
 
 template <typename T, typename... Ts> struct TypeListAtImpl<0, T, Ts...> {
   using Type = T;
 };
 
 template <size_t Pos> struct TypeListAtImpl<Pos> { using Type = none_t; };
 
 template <typename List, size_t Pos> struct TypeListAt;
 
 template <size_t Pos, typename... Ts> struct TypeListAt<TypeList<Ts...>, Pos> {
   using Type = typename TypeListAtImpl<Pos, Ts...>::Type;
 };
 
 // Finds the first element of type What beginning at index Pos.
 template <size_t Pos, typename X, typename... Ts> struct TypeListIndexOfImpl;
 
 template <size_t Pos, typename X> struct TypeListIndexOfImpl<Pos, X> {
   static constexpr int Value = -1;
 };
 
 template <size_t Pos, typename X, typename... Ts>
 struct TypeListIndexOfImpl<Pos, X, X, Ts...> {
   static constexpr int Value = Pos;
 };
 
 template <size_t Pos, typename X, typename T, typename... Ts>
 struct TypeListIndexOfImpl<Pos, X, T, Ts...> {
   static constexpr int Value = TypeListIndexOfImpl<Pos + 1, X, Ts...>::Value;
 };
 
 template <typename List, typename T> struct TypeListIndexOf;
 
 template <typename... Ts, typename T>
 struct TypeListIndexOf<TypeList<Ts...>, T> {
   static constexpr int Value = TypeListIndexOfImpl<0, T, Ts...>::Value;
 };
 
 // Gets the first element of List.
 template <typename List> struct TypeListHead;
 
 template <> struct TypeListHead<EmptyTypeList> { using Type = none_t; };
 
 template <typename T, typename... Ts>
 struct TypeListHead<TypeList<T, Ts...>> {
   using Type = T;
 };
 
 // Gets the tail of List.
 template <typename List> struct TypeListTail;
 
 template <> struct TypeListTail<TypeList<>> { using Type = EmptyTypeList; };
 
 template <typename T, typename... Ts>
 struct TypeListTail<TypeList<T, Ts...>> {
   using Type = TypeList<Ts...>;
 };
 
 // Extends a TypeList with a type, in the front or in the back depending on the
 // order of the template arguments.
 template <typename List, typename T>
 struct TypeListPush;
 
 template <typename... Ts, typename T>
 struct TypeListPush<TypeList<Ts...>, T> {
   using Type = TypeList<Ts...,T>;
 };
 
 template <typename T, typename... Ts>
 struct TypeListPush<T, TypeList<Ts...>> {
   using Type = TypeList<T, Ts...>;
 };
 
 // Drops the first N element of List.
 template <size_t N, typename List> struct TypeListDrop;
 
 template <size_t N> struct TypeListDrop<N, EmptyTypeList> {
   using Type = EmptyTypeList;
 };
 
 template <size_t N, typename T, typename... Ts>
 struct TypeListDrop<N, TypeList<T, Ts...>> {
   using Type = typename std::conditional<
       N == 0, TypeList<Ts...>,
       typename TypeListDrop<N - 1, TypeList<Ts...>>::Type>::type;
 };
 
 // Gets the number of template parameters of List.
 template <typename List>
 struct TypeListSize;
 
 template <typename... Ts> struct TypeListSize<TypeList<Ts...>> {
   static constexpr size_t Value = sizeof...(Ts);
 };
 
 template <typename... Ts> constexpr size_t TypeListSize<TypeList<Ts...>>::Value;
 
 // Tests whether a list is empty.
 template <typename List> struct TypeListEmpty {
   static constexpr bool Value = std::is_same<EmptyTypeList, List>::value;
 };
 
 // Tells if List contains type T.
 template <typename List, typename T> struct TypeListContains;
 
 template <typename... Ts, typename T>
 struct TypeListContains<TypeList<Ts...>, T> {
   static constexpr bool Value =
       std::conditional<TypeListIndexOf<TypeList<Ts...>, T>::Value == -1,
                        std::false_type, std::true_type>::type::value;
 };
 
 // Tells if ListA is a subset of ListB
 template <typename ListA, typename ListB, bool Fwd = true>
 struct TypeListSubsetOf;
 
 template <typename List>
 struct TypeListSubsetOf<EmptyTypeList, List, true> {
   static constexpr bool Value = true;
 };
 
 template <typename ListA, typename ListB>
 struct TypeListSubsetOf<ListA, ListB, false> {
   static constexpr bool Value = false;
 };
 
 template <typename T, typename... Ts, typename List>
 struct TypeListSubsetOf<TypeList<T, Ts...>, List>
     : TypeListSubsetOf<TypeList<Ts...>, List,
                        TypeListContains<List, T>::Value> {};
 
 // Finds the first element satisfying Pred
 
 template <template <typename> class Pred, typename... Ts>
 struct TypeListFindImpl;
 
 template <template <typename> class Pred> struct TypeListFindImpl<Pred> {
   using Type = none_t;
 };
 
 template <template <typename> class Pred, typename T, typename... Ts>
 struct TypeListFindImpl<Pred, T, Ts...> {
   using Type = typename std::conditional<
       Pred<T>::Value, T, typename TypeListFindImpl<Pred, Ts...>::Type>::type;
 };
 
 template <typename List, template <typename> class Pred>
 struct TypeListFind;
 
 template <typename... Ts, template <typename> class Pred>
 struct TypeListFind<TypeList<Ts...>, Pred> {
   using Type = typename TypeListFindImpl<Pred, Ts...>::Type;
 };
 
 } // End namespace rosa
 
 #endif // ROSA_SUPPORT_TYPE_LIST_HPP
 
diff --git a/include/rosa/support/type_numbers.hpp b/include/rosa/support/type_numbers.hpp
index 01b65bf..9b06092 100644
--- a/include/rosa/support/type_numbers.hpp
+++ b/include/rosa/support/type_numbers.hpp
@@ -1,168 +1,169 @@
 /******************************************************************************
  *
  * File:     type_numbers.hpp
  *
  * Contents: Facilities for registering supported types and representing them
  *           with numbers.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  * This implementation is partially based on the type_number implementation of
  * CAF.
  * TODO: Check license.
  *
  ******************************************************************************/
 
 #ifndef ROSA_SUPPORT_TYPE_NUMBERS_HPP
 #define ROSA_SUPPORT_TYPE_NUMBERS_HPP
 
 #include "rosa/support/atom.hpp"
 #include "rosa/support/math.hpp"
 #include "rosa/support/squashed_int.hpp"
 #include "rosa/support/type_helper.hpp"
 #include "rosa/support/types.hpp"
+
 #include <array>
 #include <string>
 
 namespace rosa {
 
 // Compile-time list of all built-in types.
 // NOTE: Appending new types to the end of this list maintains backward
 // compatibility in the sense that old builtin types have the same type number
 // associated to them in both the old and new versions. But changing any of
 // the already present types in the list breaks that backward compatibility.
 // Should compatibility be broken, step TypeNumberVersion below!
 // NOTE: Keep this list in sync with the definition of NumberedTypeNames.
 using BuiltinTypes = TypeList<AtomValue,   // atom
                               int16_t,     // i16
                               int32_t,     // i32
                               int64_t,     // i64
                               int8_t,      // i8
                               long double, // ldouble
                               std::string, // str
                               uint16_t,    // u16
                               uint32_t,    // u32
                               uint64_t,    // u64
                               uint8_t,     // u8
                               unit_t,      // unit
                               bool,        // bool
                               double,      // double
                               float        // float
                               >;
 
 // Indicates the version number of BuiltinTypes. Software with the same version
 // number are supposed to have backward compatible type numbering.
 // NOTE: See note above on backward compatiblity of BultinTypes.
 constexpr size_t TypeNumberVersion = 0;
 
 // The number of built-in types.
 static constexpr size_t NumberOfBuiltinTypes =
     TypeListSize<BuiltinTypes>::Value;
 
 // Anonymous namespace for helper facilities, consider it private.
 namespace {
 
 // Tells if T is not UnitType.
 template <typename T> struct IsNotUnitType {
   static constexpr bool Value = !std::is_same<T, UnitType>::value;
 };
 
 } // End namespace
 
 // Integer type to store type numbers.
 // NOTE: The narrowest unsigned integer type that is wide enough to represent
 // NumberOfBuiltinTypes different values.
 using type_nr_t =
     typename TypeListFind<typename TypeListDrop<log2(NumberOfBuiltinTypes) / 8,
                                                 IntegerTypesBySize>::Type,
                           IsNotUnitType>::Type::Second;
 
 // Turn type_nr_t into a strongly typed enumeration, so TypeNumbers can be used
 // in a type-safe way.
 enum class TypeNumber : type_nr_t {};
 
 // A type to cast type numbers into in order to output them to streams as
 // numbers and not ASCII-codes.
 // NOTE: Use it for safety, necessary for printing uint8_t values.
 using printable_tn_t = PRINTABLE(type_nr_t);
 
 // Helper preprocessor macro to cast type numbers into printable_tn_t.
 #define PRINTABLE_TN(N) static_cast<printable_tn_t>(N)
 
 // Converts a TypeNumber into string.
 inline std::string to_string(const TypeNumber TN) {
   return std::to_string(static_cast<type_nr_t>(TN));
 }
 
 // Computes the type number for T.
 // NOTE: TypeNumber is the index of T in BuiltinTypes starting from 1,
 // index 0 indicates a non-builtin type.
 template <typename T, bool IsIntegral = std::is_integral<T>::value>
 struct TypeNumberOf {
   static constexpr TypeNumber Value =
       static_cast<TypeNumber>(TypeListIndexOf<BuiltinTypes, T>::Value + 1);
 };
 
 template <typename T> struct TypeNumberOf<T, true> {
   using Type = squashed_int_t<T>;
 
   static constexpr TypeNumber Value =
       static_cast<TypeNumber>(TypeListIndexOf<BuiltinTypes, Type>::Value + 1);
 };
 
 template <> struct TypeNumberOf<bool, true> {
   static constexpr TypeNumber Value =
       static_cast<TypeNumber>(TypeListIndexOf<BuiltinTypes, bool>::Value + 1);
 };
 
 template <AtomValue V> struct TypeNumberOf<AtomConstant<V>, false> {
   static constexpr TypeNumber Value = TypeNumberOf<AtomValue>::Value;
 };
 
 // List of all type names, indexed via TypeNumber.
 // NOTE: Keep this definition in sync with BuiltinTypes.
 constexpr std::array<const char *, NumberOfBuiltinTypes> NumberedTypeNames {{
   "atom",
   "i16",
   "i32",
   "i64",
   "i8",
   "ldouble",
   "str",
   "u16",
   "u32",
   "u64",
   "u8",
   "unit",
   "bool",
   "double",
   "float"
 }};
 
 // Tells if the given TypeNumber is valid in the software.
 // NOTE: A type number generated by an incompatible version may be valid but
 // supposed to denote a type different than that in the current software.
 constexpr bool validTypeNumber(const TypeNumber TN) {
   // FIXME: Duplication of static_cast into a const variable would be
   // possible in C++14.
   return 0 < static_cast<type_nr_t>(TN) &&
          static_cast<type_nr_t>(TN) <= NumberOfBuiltinTypes;
 }
 
 // Computes the corresponding builtin type with some information from a type
 // number.
 // PRE: validTypeNumber(TN)
 template <TypeNumber TN> struct TypeForNumber {
   STATIC_ASSERT(validTypeNumber(TN), "not a valid type number");
   static constexpr type_nr_t TNI = static_cast<type_nr_t>(TN);
   using Type = typename TypeListAt<BuiltinTypes, TNI - 1>::Type;
   static constexpr size_t Size = sizeof(Type);
   static constexpr const char *Name = NumberedTypeNames[TNI - 1];
 };
 
 } // End namespace rosa
 
 #endif // ROSA_SUPPORT_TYPE_NUMBERS_HPP
 
diff --git a/include/rosa/support/types.hpp b/include/rosa/support/types.hpp
index 2aa6a0e..83d612e 100644
--- a/include/rosa/support/types.hpp
+++ b/include/rosa/support/types.hpp
@@ -1,313 +1,314 @@
 /*******************************************************************************
  *
  * File:     types.hpp
  *
  * Contents: Implementation of some basic convenience types.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  * This implementation is partially based on the implementation of
  * corresponding parts of CAF.
  * TODO: Check license.
  *
  ******************************************************************************/
 
 #ifndef ROSA_SUPPORT_TYPES_HPP
 #define ROSA_SUPPORT_TYPES_HPP
 
 #include "rosa/support/debug.hpp"
+
 #include <string>
 
 namespace rosa {
 
 /* ************************************************************************** *
  *                                   Unit                                     *
  * ************************************************************************** */
 
 // Unit is analogous to void, but can be safely returned, stored, etc.
 // to enable higher-order abstraction without cluttering code with
 // exceptions for void (which can't be stored, for example).
 struct UnitType {
   constexpr UnitType() noexcept {
     // nop
   }
 
   constexpr UnitType(const UnitType &) noexcept {
     // nop
   }
 
   template <class T> explicit constexpr UnitType(T &&) noexcept {
     // nop
   }
 
   template <class... Ts>
   constexpr UnitType operator()(Ts &&...) const noexcept {
     return {};
   }
 };
 
 using unit_t = UnitType;
 
 static constexpr unit_t unit = unit_t{}; // NOLINT
 
 inline std::string to_string(const unit_t &) { return "unit"; }
 
 template <typename T> struct LiftVoid { using Type = T; };
 
 template <> struct LiftVoid<void> { using Type = unit_t; };
 
 template <typename T> struct UnliftVoid { using Type = T; };
 
 template <> struct UnliftVoid<unit_t> { using Type = void; };
 
 /* ************************************************************************** *
  *                                   None                                     *
  * ************************************************************************** */
 
 // Represents "nothing", e.g., for clearing an Optional by assigning none.
 struct NoneType {
   constexpr NoneType() {
     // nop
   }
   constexpr explicit operator bool() const { return false; }
 };
 
 using none_t = NoneType;
 
 static constexpr none_t none = none_t{}; // NOLINT
 
 inline std::string to_string(const none_t &) { return "none"; }
 
 /* ************************************************************************** *
  *                                 Optional                                   *
  * ************************************************************************** */
 
 // A C++17 compatible optional implementation.
 template <class T> class Optional {
 public:
   using Type = T;
 
   // Creates an instance without value.
   Optional(const none_t & = none) : Valid(false) {
     // nop
   }
 
   // Creates an valid instance from value.
   template <class U, class E = typename std::enable_if<
                          std::is_convertible<U, T>::value>::type>
   Optional(U X) : Valid(false) {
     cr(std::move(X));
   }
 
   Optional(const Optional &Other) : Valid(false) {
     if (Other.Valid) {
       cr(Other.Value);
     }
   }
 
   Optional(Optional &&Other) noexcept(
       std::is_nothrow_move_constructible<T>::value)
       : Valid(false) {
     if (Other.Valid) {
       cr(std::move(Other.Value));
     }
   }
 
   ~Optional() { destroy(); }
 
   Optional &operator=(const Optional &Other) {
     if (Valid) {
       if (Other.Valid) {
         Value = Other.Value;
       } else {
         destroy();
       }
     } else if (Other.Valid) {
       cr(Other.Value);
     }
     return *this;
   }
 
   Optional &operator=(Optional &&Other) noexcept(
       std::is_nothrow_destructible<T>::value
           &&std::is_nothrow_move_assignable<T>::value) {
     if (Valid) {
       if (Other.Valid) {
         Value = std::move(Other.Value);
       } else {
         destroy();
       }
     } else if (Other.Valid) {
       cr(std::move(Other.Value));
     }
     return *this;
   }
 
   // Checks whether this object contains a value.
   explicit operator bool() const { return Valid; }
 
   // Checks whether this object does not contain a value.
   bool operator!() const { return !Valid; }
 
   // Returns the value.
   // PRE: Valid
   T &operator*() {
     ASSERT(Valid);
     return Value;
   }
 
   // Returns the value.
   // PRE: Valid
   const T &operator*() const {
     ASSERT(Valid);
     return Value;
   }
 
   // Returns the value.
   // PRE: Valid
   const T *operator->() const {
     ASSERT(Valid);
     return &Value;
   }
 
   // Returns the value.
   // PRE: Valid
   T *operator->() {
     ASSERT(Valid);
     return &Value;
   }
 
   // Returns the value.
   // PRE: Valid
   T &value() {
     ASSERT(Valid);
     return Value;
   }
 
   // Returns the value.
   // PRE: Valid
   const T &value() const {
     ASSERT(Valid);
     return Value;
   }
 
   // Returns the value if Valid, otherwise returns DefaultValue.
   const T &valueOr(const T &DefaultValue) const {
     return Valid ? Value() : DefaultValue;
   }
 
 private:
   void destroy() {
     if (Valid) {
       Value.~T();
       Valid = false;
     }
   }
 
   template <class V> void cr(V &&X) {
     ASSERT(!Valid);
     Valid = true;
     new (&Value) T(std::forward<V>(X));
   }
 
   bool Valid;
   union {
     T Value;
   };
 };
 
 // Template specialization to allow Optional to hold a reference
 // rather than an actual value with minimal overhead.
 template <typename T> class Optional<T &> {
 public:
   using Type = T;
 
   Optional(const none_t & = none) : Value(nullptr) {
     // nop
   }
 
   Optional(T &X) : Value(&X) {
     // nop
   }
 
   Optional(T *X) : Value(X) {
     // nop
   }
 
   Optional(const Optional &Other) = default;
 
   Optional &operator=(const Optional &Other) = default;
 
   explicit operator bool() const { return Value != nullptr; }
 
   bool operator!() const { return !Value; }
 
   T &operator*() {
     ASSERT(Value);
     return *Value;
   }
 
   const T &operator*() const {
     ASSERT(Value);
     return *Value;
   }
 
   T *operator->() {
     ASSERT(Value);
     return Value;
   }
 
   const T *operator->() const {
     ASSERT(Value);
     return Value;
   }
 
   T &value() {
     ASSERT(Value);
     return *Value;
   }
 
   const T &value() const {
     ASSERT(Value);
     return *Value;
   }
 
   const T &valueOr(const T &DefaultValue) const {
     return Value ? Value() : DefaultValue;
   }
 
 private:
   T *Value;
 };
 
 // Template specialization to allow Optional to implement a flag for void.
 template <> class Optional<void> {
 public:
   using Type = unit_t;
 
   Optional(none_t = none) : Value(false) {
     // nop
   }
 
   Optional(unit_t) : Value(true) {
     // nop
   }
 
   Optional(const Optional &Other) = default;
 
   Optional &operator=(const Optional &Other) = default;
 
   explicit operator bool() const { return Value; }
 
   bool operator!() const { return !Value; }
 
 private:
   bool Value;
 };
 
 } // End namespace rosa
 
 #endif // ROSA_SUPPORT_TYPES_HPP
 
diff --git a/lib/config/version.cpp b/lib/config/version.cpp
index 069f145..f8f3eb5 100644
--- a/lib/config/version.cpp
+++ b/lib/config/version.cpp
@@ -1,41 +1,42 @@
 /*******************************************************************************
  *
  * File:     version.cpp
  *
  * Contents: Implementation for version.h.
  *
  * Copyright 2016
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #include "rosa/config/version.h"
+
 #include <sstream>
 
 namespace rosa {
 
 std::string library_string(void) {
   return PACKAGE_STRING;
 }
 
 std::string version(void) {
   return PACKAGE_VERSION;
 }
 
 std::string verbose_version(void) {
   std::stringstream ss;
   ss << PACKAGE_STRING << std::endl
      << "Built by " << CMAKE_GENERATOR
      << " with " << CMAKE_CXX_COMPILER_ID
      << ' ' << CMAKE_CXX_COMPILER_VERSION << std::endl
      << "on a(n) " << CMAKE_SYSTEM << " system." << std::endl
      << "Build date: " << BUILD_DATE << std::endl
      << "Package name: " << PACKAGE_NAME << std::endl
      << "Package version: " << PACKAGE_VERSION << std::endl
      << "Report issues: " << PACKAGE_BUGREPORT << std::endl;
   return ss.str();
 }
 
 } // End namespace rosa
 
diff --git a/lib/core/MessageHandler.cpp b/lib/core/MessageHandler.cpp
index f6c8348..c107f95 100644
--- a/lib/core/MessageHandler.cpp
+++ b/lib/core/MessageHandler.cpp
@@ -1,35 +1,36 @@
 /*******************************************************************************
  *
  * File:     MessageHandler.cpp
  *
  * Contents: Implementation of non-template part of MessageHandler.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #include "rosa/core/MessageHandler.hpp"
+
 #include <algorithm>
 
 namespace rosa {
 
 MessageHandler::~MessageHandler(void) {
   LOG_TRACE("Destroying MessageHandler");
 }
 
 bool MessageHandler::canHandle(const Message &Msg) const noexcept {
   return std::any_of(Invokers.begin(), Invokers.end(),
                      [&Msg](const invoker_t &I) { return I->match(Msg); });
 }
 
 bool MessageHandler::operator()(const Message &Msg) const noexcept {
   return std::any_of(Invokers.begin(), Invokers.end(),
                      [&Msg](const invoker_t &I) {
                        return (*I)(Msg) == Invoker::result_t::Invoked;
                      });
 }
 
 } // End namespace rosa
 
diff --git a/lib/core/System.cpp b/lib/core/System.cpp
index 77ace25..626835e 100644
--- a/lib/core/System.cpp
+++ b/lib/core/System.cpp
@@ -1,52 +1,54 @@
 /*******************************************************************************
  *
  * File:     System.cpp
  *
  * Contents: Implementation of System base-class.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
+#include "rosa/core/System.hpp"
+
 #include "SystemImpl.hpp"
+
 #include "rosa/core/Unit.h"
-#include "rosa/core/System.hpp"
 
 namespace rosa {
 
 std::unique_ptr<System> System::createSystem(const std::string &Name) noexcept {
   return std::unique_ptr<System>(new SystemImpl(Name));
 }
 
 System::System(const std::string &Name) noexcept : Name(Name),
                                                    CountUnits(0),
                                                    SystemCleaned(false) {
   LOG_TRACE("Creating System (" + Name + ")");
 }
 
 System::~System(void) {
   LOG_TRACE("Destroying System (" + Name + ")");
   if (!SystemCleaned) {
     ROSA_CRITICAL("Trying to destroy a uncleaned System (" + Name + ")");
   }
 }
 
 void System::markCleaned(void) noexcept {
   if (SystemCleaned) {
     ROSA_CRITICAL("System (" + Name + ") has been already mark cleaned");
   } else if (!empty()) {
     ROSA_CRITICAL("Trying to mark a non-empty System (" + Name + ")");
   } else {
     SystemCleaned = true;
     LOG_TRACE("System (" + Name + ") is marked clean");
   }
 }
 
 size_t System::numberOfConstructedUnits(void) const noexcept {
   return CountUnits;
 }
 
 } // End namespace rosa
 
diff --git a/lib/core/SystemImpl.cpp b/lib/core/SystemImpl.cpp
index 97f83d4..cca2317 100644
--- a/lib/core/SystemImpl.cpp
+++ b/lib/core/SystemImpl.cpp
@@ -1,68 +1,71 @@
 /*******************************************************************************
  *
  * File:     SystemImpl.cpp
  *
  * Contents: Definition of the SystemImpl class
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #include "SystemImpl.hpp"
+
 #include "rosa/core/Unit.h"
+
 #include "rosa/config/config.h"
+
 #include "rosa/support/debug.hpp"
 #include "rosa/support/log.h"
 
 namespace rosa {
 
 SystemImpl::SystemImpl(const std::string &Name) noexcept : System(Name) {}
 
 SystemImpl::~SystemImpl(void) {
   if (!empty()) {
     ROSA_CRITICAL("Trying to destroy a non-empty System (" + Name + ")");
   } else {
     markCleaned();
   }
 }
 
 void SystemImpl::registerUnit(Unit &U) noexcept {
   // Obtain exclusive access and instert the Unit.
   std::lock_guard<std::mutex> L(RegisterMutex);
   auto R = Units.insert(&U);
   if (!R.second) {
     ROSA_CRITICAL("Could not register Unit");
   }
 }
 
 void SystemImpl::destroyUnit(Unit &U) noexcept {
   ASSERT(isUnitRegistered(U));
   LOG_TRACE("Destroying Unit (" + U.FullName + ")");
   // Scope protected container access.
   {
     // Obtain exclusive access and remove the Unit.
     std::lock_guard<std::mutex> L(RegisterMutex);
     auto R = Units.erase(&U);
     // NOTE: This case is catched by assertion when that is enabled.
     if (!R) {
       ROSA_CRITICAL("Trying to remove unregistered Unit");
     }
   }
   delete &U;
 }
 
 bool SystemImpl::isUnitRegistered(const Unit &U) const noexcept {
   // NOTE: Casting away constness is safe here.
   return Units.find(const_cast<Unit *>(&U)) != Units.cend();
 }
 
 size_t SystemImpl::numberOfLiveUnits(void) const noexcept {
   return Units.size();
 }
 
 bool SystemImpl::empty(void) const noexcept { return Units.empty(); }
 
 } // End namespace rosa
 
diff --git a/lib/core/SystemImpl.hpp b/lib/core/SystemImpl.hpp
index 0365336..2fb4ce3 100644
--- a/lib/core/SystemImpl.hpp
+++ b/lib/core/SystemImpl.hpp
@@ -1,61 +1,62 @@
 /*******************************************************************************
  *
  * File:     SystemImpl.hpp
  *
  * Contents: Declaration of a basic implementation of the System interface.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #ifndef ROSA_LIB_CORE_SYSTEMIMPL_HPP // NOLINT
 #define ROSA_LIB_CORE_SYSTEMIMPL_HPP
 
 #include "rosa/core/System.hpp"
+
 #include <mutex>
 #include <unordered_set>
 
 namespace rosa {
 
 class SystemImpl : public System {
 public:
   SystemImpl(const std::string &Name) noexcept;
 
   ~SystemImpl(void);
 
 private:
   // Container for keeping reference of registered Units.
   std::unordered_set<Unit *> Units;
 
   // Used to provide mutual exclusion when modifying Units.
   std::mutex RegisterMutex;
 
 protected:
   // Registers the given Unit instance to the System.
   // PRE: !isUnitRegistered(U)
   // POST: isUnitRegistered(U)
   void registerUnit(Unit &U) noexcept override;
 
   // Unregisters and destroys the given Unit.
   // PRE: isUnitRegistered(U)
   // POST: !isUnitRegistered(U) && 'U is destroyed'
   void destroyUnit(Unit &U) noexcept override;
 
   // Returns if the given Unit is registered in the System.
   bool isUnitRegistered(const Unit &U) const noexcept override;
 
 public:
   // Returns the number of live Units, that have been constructed and not
   // destroyed yet.
   size_t numberOfLiveUnits(void) const noexcept override;
 
   // Returns if the System has no live Units.
   bool empty(void) const noexcept override;
 };
 
 } // End namespace rosa
 
 #endif // ROSA_LIB_CORE_SYSTEMIMPL_HPP
 
diff --git a/lib/core/Unit.cpp b/lib/core/Unit.cpp
index d11b36e..5968020 100644
--- a/lib/core/Unit.cpp
+++ b/lib/core/Unit.cpp
@@ -1,53 +1,54 @@
 /*******************************************************************************
  *
  * File:     Unit.cpp
  *
  * Contents: Implementation of Unit base-class.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 
 #include "rosa/core/Unit.h"
 
 #include "rosa/core/System.hpp"
+
 #include "rosa/support/debug.hpp"
 #include "rosa/support/log.h"
 
 namespace rosa {
 
 // Ctor. Initializing member fields.
 Unit::Unit(const AtomValue Kind, const size_t Id, const std::string &Name,
            System &S) noexcept : Kind(Kind),
                                  Id(Id),
                                  Name(Name),
                                  S(S),
                                  FullName(Name + "@" + S.Name) {
   ASSERT(!Name.empty());
   LOG_TRACE("Constructing Unit (" + FullName + " of kind '" + to_string(Kind) +
             "')");
 }
 
 // Dtor.
 Unit::~Unit(void) { LOG_TRACE("Destroying Unit (" + FullName + ")"); }
 
 // Default dump function, emitting the Name of the Unit.
 std::string Unit::dump(void) const noexcept {
   LOG_TRACE("Dumping Unit (" + FullName + ")");
   return "[Unit] " + FullName;
 }
 
 System &Unit::system(void) const noexcept {
   return S;
 }
 
 std::ostream &operator<<(std::ostream &OS, const Unit &U) {
   OS << U.dump();
   return OS;
 }
 
 } // End namespace rosa
 
diff --git a/lib/support/atom.cpp b/lib/support/atom.cpp
index 968aacc..c32c9cc 100644
--- a/lib/support/atom.cpp
+++ b/lib/support/atom.cpp
@@ -1,50 +1,51 @@
 /*******************************************************************************
  *
  * File:     atom.cpp
  *
  * Contents: Implementation of non-static part of atom facilities.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  * This implementation is based on the atom implementation of CAF.
  * TODO: Check license.
  *
  ******************************************************************************/
 
 #include "rosa/support/atom.hpp"
+
 #include <cstring>
 
 namespace rosa {
 
 std::string to_string(const AtomValue &What) {
   auto X = static_cast<atom_t>(What);
   std::string S;
   S.reserve(MaxAtomLength + 1);
   // Don't read characters before we found the leading 0xF.
   // First four bits set?
   bool ReadChars = ((X & 0xF000000000000000) >> 60) == 0xF;
   uint64_t Mask = 0x0FC0000000000000;
   for (int BitShift = 54; BitShift >= 0; BitShift -= 6, Mask >>= 6) {
     if (ReadChars) {
       S += AtomDecodingTable[(X & Mask) >> BitShift];
     } else if (((X & Mask) >> BitShift) == 0xF) {
       ReadChars = true;
     }
   }
   return S;
 }
 
 AtomValue atom_from_string(const std::string &S) {
   if (S.size() > MaxAtomLength) {
     return atom("");
   }
   char AtomBuf[MaxAtomLength + 1];
   std::memcpy(AtomBuf, S.c_str(), S.size());
   AtomBuf[S.size()] = '\0';
   return atom(AtomBuf);
 }
 
 } // End namespace rosa
 
diff --git a/lib/support/debug.cpp b/lib/support/debug.cpp
index b1ee0e1..4e2fe1b 100644
--- a/lib/support/debug.cpp
+++ b/lib/support/debug.cpp
@@ -1,24 +1,25 @@
 /*******************************************************************************
  *
  * File:     debug.cpp
  *
  * Contents: Implementation for debug.hpp.
  *
  * Copyright 2016
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #include "rosa/support/debug.hpp"
+
 #include <iostream>
 
 namespace rosa {
 
 std::ostream &dbgs(void) {
   // Always return the standard error stream.
   return std::cerr;
 }
 
 } // End namespace rosa
 
diff --git a/lib/support/log.cpp b/lib/support/log.cpp
index 52743f0..f7f0033 100644
--- a/lib/support/log.cpp
+++ b/lib/support/log.cpp
@@ -1,52 +1,54 @@
 /*******************************************************************************
  *
  * File:     log.cpp
  *
  * Contents: Facility for logging
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
-#include "rosa/support/debug.hpp"
 #include "rosa/support/log.h"
+
+#include "rosa/support/debug.hpp"
 #include "rosa/support/terminal_colors.h"
+
 #include <array>
 
 namespace rosa {
 
 // Textual representation of LogLevels.
 // NOTE: Do not index with LogLevel::NumLogLevels!
 constexpr std::array<const char *, static_cast<size_t>(LogLevel::NumLogLevels)>
     LogLevelStrings{{"ERROR", "WARNING", "INFO", "DEBUG", "TRACE"}};
 
 // Terminal colors associated to LogLevels.
 // NOTE: Do not index with LogLevel::NumLogLevels!
 constexpr std::array<terminal::Color,
                      static_cast<size_t>(LogLevel::NumLogLevels)>
     LogLevelColors{{
         terminal::Color::Red,     // LogLevel::Error
         terminal::Color::Yellow,  // LogLevel::Warning
         terminal::Color::Green,   // LogLevel::Info
         terminal::Color::Blue,    // LogLevel::Debug
         terminal::Color::Default, // LogLevel::Trace
     }};
 
 std::string logLevelToString(const LogLevel logLevel) {
   ASSERT(logLevel != LogLevel::NumLogLevels);
   return LogLevelStrings[static_cast<size_t>(logLevel)];
 }
 
 std::ostream &operator<<(std::ostream &os, const LogLevel logLevel) {
   ASSERT(logLevel != LogLevel::NumLogLevels);
   os << LogLevelColors[static_cast<size_t>(logLevel)] << "["
      << logLevelToString(logLevel) << "]" << terminal::Color::Default;
   return os;
 }
 
 std::ostream LogSink(nullptr);
 
 } // End namespace rosa
 
diff --git a/lib/support/terminal_colors.cpp b/lib/support/terminal_colors.cpp
index c4b3e4d..4f8ca4c 100644
--- a/lib/support/terminal_colors.cpp
+++ b/lib/support/terminal_colors.cpp
@@ -1,73 +1,76 @@
 /*******************************************************************************
  *
  * File:     terminal_colors.cpp
  *
  * Contents: Facility for printing colorized text to terminals supporting it.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #include "rosa/support/terminal_colors.h"
-#include "rosa/support/debug.hpp"
+
 #include "rosa/config/config.h"
+
+#include "rosa/support/debug.hpp"
+
 #include <array>
 
 #ifdef ROSA_POSIX
 #include <unistd.h>
 #endif // defined(ROSA_POSIX)
 
 namespace rosa {
 namespace terminal {
 
 // ANSI color codes for POSIX terminals.
 // NOTE: Use std::array for runtime efficiency, though static casting is
 // necessary for indexing.
 // NOTE: Do not index with Color::NumColors!
 constexpr std::array<const char *, static_cast<size_t>(Color::NumColors)>
     ANSIColorCodes{{
         "0",  // Default - Attribute reset
         "30", // Black
         "31", // Red
         "32", // Green
         "33", // Yelow
         "34", // Blue
         "35", // Magenta
         "36", // Cyan
         "37", // Lightgrey
         "90", // Darkgrey
         "91", // Lightred
         "92", // Lightgreen
         "93", // Lightyellow
         "94", // Lightblue
         "95", // Lightmagenta
         "96", // Lightcyan
         "97"  // White
     }};
 
 std::ostream &operator<<(std::ostream &os, const Color color) {
   ASSERT(color != Color::NumColors);
   // Handle color only when printing to terminal and it supports colors.
 #ifdef ROSA_POSIX
   // Identify terminal by checking if the stream is buffered as one of the
   // standard outputs, and the corresponding C standard output stream is
   // pointing to a terminal.
   // NOTE: This implementation may be tricked so that it does not print color
   // to terminal, but should never print color codes to a non-terminal output.
   if ((os.rdbuf() == std::cout.rdbuf() && isatty(fileno(stdin))) ||
       ((os.rdbuf() == std::cerr.rdbuf() || os.rdbuf() == std::clog.rdbuf()) &&
        isatty(fileno(stderr)))) {
     os << "\033[" << ANSIColorCodes[static_cast<size_t>(color)] << "m";
   }
 #elif defined(ROSA_WINDOWS)
   // FIXME: Windows terminals support ANSI color codes from Windows 10
   // Threshold 2, custom stuff is required for earlier versions.
 #endif // defined(ROSA_POSIX) || defined(ROSA_WINDOWS)
   return os;
 }
 
 } // End namespace terminal
 } // End namespace rosa