diff --git a/examples/messaging/messaging.cpp b/examples/messaging/messaging.cpp
index 92cc1b3..b4033cb 100644
--- a/examples/messaging/messaging.cpp
+++ b/examples/messaging/messaging.cpp
@@ -1,136 +1,169 @@
 /*******************************************************************************
  *
  * File:     messaging.cpp
  *
  * Contents: An example showcasing features related to Messages.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #include "rosa/config/version.h"
-#include "rosa/core/Invoker.hpp"
+#include "rosa/core/MessageHandler.hpp"
 #include "rosa/support/log.h"
 #include "rosa/support/terminal_colors.h"
 #include <iostream>
 
 using namespace rosa;
 using namespace rosa::terminal;
 
 // A simple implementation of the Message interface with two hardcoded types.
 class MyMessage : public Message {
   const uint8_t U8;   // First value
   const uint16_t U16; // Second value
 public:
   MyMessage(const uint8_t U8, const uint16_t U16)
       : Message(U8, U16), U8(U8), U16(U16) {}
 
   const void *getPointerTo(const size_t Pos) const noexcept override {
     switch (Pos) {
     default:
       ROSA_CRITICAL("wrong position");
     case 0:
       return &U8;
     case 1:
       return &U16;
     }
   }
 };
 
+// Another implementation of the Message interface with an AtomValue.
 class MyAtomMessage : public Message {
   const AtomValue A; // First value
 public:
   template <AtomValue V>
   MyAtomMessage(AtomConstant<V> C) : Message(C), A(V) {}
 
   const void *getPointerTo(const size_t Pos) const noexcept override {
     switch (Pos) {
     default:
       ROSA_CRITICAL("wrong position");
     case 0:
       return &A;
     }
   }
 };
 
 int main(void) {
   LOG_INFO_STREAM << library_string() << " -- " << Color::Red
                   << "messaging" << Color::Default << std::endl;
 
-  auto &Log = LOG_TRACE_STREAM << std::endl;
+  auto &Log = LOG_INFO_STREAM << std::endl;
 
+  // Message interface.
   MyMessage Msg(1, 2);
   Log << "Checking on 'MyMessage(1, 2)' that is of 'Message with "
          "TypeList<<uint8_t, uint16_t>>':"
       << std::endl
       << "  Size: " << Msg.Size << std::endl
       << "  Pos 0 is uint8_t: " << Msg.isTypeAt<uint8_t>(0) << std::endl
       << "  Pos 1 is uint16_t: " << Msg.isTypeAt<uint16_t>(1) << std::endl
       << "  Pos 2 is uint32_t: " << Msg.isTypeAt<uint32_t>(1) << std::endl
       << "  Value at pos 0: " << PRINTABLE(uint8_t)(Msg.getValueAt<uint8_t>(0))
       << std::endl
       << "  Value at pos 1: " << Msg.getValueAt<uint16_t>(1) << std::endl
       << std::endl;
 
+  // MessageMatcher.
   using MyMatcher = MsgMatcher<uint8_t, uint16_t>;
   Log << "Matching against 'TypeList<uint8_t, uint16_t>':" << std::endl
       << "  matching: " << MyMatcher::doesStronglyMatch(Msg) << std::endl;
   auto Vs = MyMatcher::extractedValues(Msg);
   Log << "  value: '(" << PRINTABLE(uint8_t)(std::get<0>(Vs)) << ", "
       << std::get<1>(Vs) << ")'" << std::endl
       << std::endl;
 
   using MyWrongMatcher = MsgMatcher<uint8_t, uint8_t>;
   Log << "Matching against 'TypeList<uint8_t, uint8_t>':" << std::endl
       << "  matching: " << MyWrongMatcher::doesStronglyMatch(Msg) << std::endl
       << std::endl;
 
   using MyAtom = AtomConstant<atom("atom")>;
   const MyAtom &A = MyAtom::Value;
   using MyNAtom = AtomConstant<atom("noatom")>;
   MyAtomMessage AMsg(A);
   Log << "Checking on 'MyAtomMessage(AtomConstant<atom(\"atom\")>::Value)' "
          "that is of 'Message with TypeList<AtomConstant<atom(\"atom\")>>':"
       << std::endl
       << "  Size: " << AMsg.Size << std::endl
       << "  Pos 0 is 'AtomValue': " << AMsg.isTypeAt<AtomValue>(0) << std::endl
       << "  Pos 0 is 'AtomConstant<atom(\"noatom\")>': "
       << AMsg.isTypeAt<MyNAtom>(0) << std::endl
       << std::endl;
 
   using MyAtomMatcher = MsgMatcher<MyAtom>;
   Log << "Matching against 'TypeList<AtomConstant<atom(\"atom\")>>':"
       << std::endl
       << "  matching: " << MyAtomMatcher::doesStronglyMatch(AMsg) << std::endl
       << "  value: '("
       << to_string(std::get<0>(MyAtomMatcher::extractedValues(AMsg))) << ")'"
       << std::endl
       << std::endl;
 
   using MyWrongAtomMatcher = MsgMatcher<MyNAtom>;
   Log << "Matching against 'TypeList<AtomConstant<atom(\"noatom\")>>':"
       << std::endl
       << "  matching: " << MyWrongAtomMatcher::doesStronglyMatch(AMsg)
       << std::endl
       << std::endl;
 
+  // Invoker.
   auto IP = Invoker::wrap(Invoker::F<MyAtom>([&Log](MyAtom) noexcept->void {
-    Log << "** Lambda-function called via Invoker." << std::endl;
+    Log << "** Handling 'Message with TypeList<MyAtom>'." << std::endl;
   }));
   auto &I = *IP; // Get a reference from the pointer.
   Log << "Invoking a function of signature 'void(MyAtom) noexcept':"
       << std::endl
       << "  with 'Message with TypeList<uint8_t, uint16_t>'" << std::endl
       << "    does Message match Invoker: " << I.match(Msg) << std::endl
       << "    invoking..." << std::endl;
   I(Msg);
   Log << "  with 'Message with TypeList<MyAtom>'..." << std::endl
       << "    does Message match Invoker: " << I.match(AMsg) << std::endl
       << "    invoking..." << std::endl;
   I(AMsg);
+  Log << std::endl;
+
+  // MessageHandler.
+  MessageHandler Handler{
+      Invoker::F<uint8_t, uint16_t>([&](uint8_t, uint16_t) {
+        LOG_TRACE("** Handling 'Message with TypeList<uint8_t, uint16_t>'");
+      }),
+      Invoker::F<MyAtom>([&](MyAtom) {
+        LOG_TRACE("** Handling 'Message with TypeList<MyAtom>'");
+      })};
+  MyAtomMessage ANMsg(MyNAtom::Value);
+  Log << "Handling Messages with 'MessageHandler "
+         "{ Invoker::F<uint8_t, uint16_t>, Invoker::F<MyAtom> }':"
+      << std::endl
+      << "  'Message with TypeList<uint8_t, uint16_t>'" << std::endl
+      << "    can handle: " << Handler.canHandle(Msg) << std::endl
+      << "    handling..." << std::endl;
+  Handler(Msg);
+  Log << "  'Message with TypeList<MyAtom>'" << std::endl
+      << "    can handle: " << Handler.canHandle(AMsg) << std::endl
+      << "    handling..." << std::endl;
+  Handler(AMsg);
+  Log << "  'Message with TypeList<MyNAtom>'" << std::endl
+      << "    can handle: " << Handler.canHandle(ANMsg) << std::endl
+      << "    handling..." << std::endl;
+  Handler(ANMsg);
+  Log << std::endl;
+
+  Log << "Terminating, destroying automatic variables." << std::endl;
 
   return 0;
 }
 
diff --git a/include/rosa/core/Invoker.hpp b/include/rosa/core/Invoker.hpp
index 82ba840..b344ebe 100644
--- a/include/rosa/core/Invoker.hpp
+++ b/include/rosa/core/Invoker.hpp
@@ -1,156 +1,158 @@
 /*******************************************************************************
  *
  * 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/MessageHandler.hpp b/include/rosa/core/MessageHandler.hpp
new file mode 100644
index 0000000..c2bb605
--- /dev/null
+++ b/include/rosa/core/MessageHandler.hpp
@@ -0,0 +1,113 @@
+/*******************************************************************************
+ *
+ * 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/lib/core/CMakeLists.txt b/lib/core/CMakeLists.txt
index 5e40be0..55fc488 100644
--- a/lib/core/CMakeLists.txt
+++ b/lib/core/CMakeLists.txt
@@ -1,10 +1,11 @@
 add_library(ROSACore
   Unit.cpp
   System.cpp
   SystemImpl.cpp
   Message.cpp
   Invoker.cpp
+  MessageHandler.cpp
   )
 
 ROSA_add_library_dependencies(ROSACore ROSASupport)
 
diff --git a/lib/core/MessageHandler.cpp b/lib/core/MessageHandler.cpp
new file mode 100644
index 0000000..f6c8348
--- /dev/null
+++ b/lib/core/MessageHandler.cpp
@@ -0,0 +1,35 @@
+/*******************************************************************************
+ *
+ * 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
+