diff --git a/.gitignore b/.gitignore
index ded20f8a..4e1f38f5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,9 +9,12 @@ test/keil/Debug
 test/keil/Release
 test/keil/Objects
 test/keil/Listings
+test/cmake-windows/unittest++/src
+test/cmake/unittest++/src
 examples/ArmTimerCallbacks/Listings
 examples/ArmTimerCallbacks/Objects
 examples/ArmTimerCallbacks/DebugConfig
+build-test-Desktop_x86_windows_msvc2017_pe_32bit-Debug/unittest++/src
 
 #################
 ## Eclipse
diff --git a/include/etl/file_error_numbers.txt b/include/etl/file_error_numbers.txt
index 3961913e..89cfc5e1 100644
--- a/include/etl/file_error_numbers.txt
+++ b/include/etl/file_error_numbers.txt
@@ -52,3 +52,4 @@
 52 bitset
 53 indirect_vector
 54 queue_spsc_locked
+55 message_packet
diff --git a/include/etl/generate.bat b/include/etl/generate.bat
index c121da9f..1aed11dd 100644
--- a/include/etl/generate.bat
+++ b/include/etl/generate.bat
@@ -4,4 +4,5 @@ python -m cogapp -d -e -olargest.h -DNTypes=16 largest_generator.h
 python -m cogapp -d -e -osmallest.h -DNTypes=16 smallest_generator.h
 python -m cogapp -d -e -otype_traits.h -DIsOneOf=17 type_traits_generator.h
 python -m cogapp -d -e -otype_lookup.h -DNTypes=16 type_lookup_generator.h
-python -m cogapp -d -e -otype_select.h -DNTypes=16 type_select_generator.h
\ No newline at end of file
+python -m cogapp -d -e -otype_select.h -DNTypes=16 type_select_generator.h
+python -m cogapp -d -e -omessage_packet.h -DHandlers=16 message_packet_generator.h 
\ No newline at end of file
diff --git a/include/etl/generate_message_packet.bat b/include/etl/generate_message_packet.bat
new file mode 100644
index 00000000..bb9b4fca
--- /dev/null
+++ b/include/etl/generate_message_packet.bat
@@ -0,0 +1 @@
+python -m cogapp -d -e -omessage_packet.h -DHandlers=16 message_packet_generator.h 
diff --git a/include/etl/message_packet.h b/include/etl/message_packet.h
new file mode 100644
index 00000000..611d2cc5
--- /dev/null
+++ b/include/etl/message_packet.h
@@ -0,0 +1,1614 @@
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2020 jwellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+#if 0
+#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+#endif
+
+//***************************************************************************
+// THIS FILE HAS BEEN AUTO GENERATED. DO NOT EDIT THIS FILE.
+//***************************************************************************
+
+//***************************************************************************
+// To generate to header file, run this at the command line.
+// Note: You will need Python and COG installed.
+//
+// python -m cogapp -d -e -omessage_packet.h -DHandlers=<n> message_packet_generator.h
+// Where <n> is the number of messages to support.
+//
+// e.g.
+// To generate handlers for up to 16 messages...
+// python -m cogapp -d -e -omessage_packet.h -DHandlers=16 message_packet_generator.h
+//
+// See generate.bat
+//***************************************************************************
+
+#ifndef ETL_MESSAGE_PACKET_INCLUDED
+#define ETL_MESSAGE_PACKET_INCLUDED
+
+#include "message.h"
+#include "error_handler.h"
+#include "static_assert.h"
+#include "largest.h"
+#include "alignment.h"
+
+#include <stdint.h>
+
+#undef ETL_FILE
+#define ETL_FILE "55"
+
+namespace etl
+{
+  //***************************************************************************
+  // The definition for all 16 message types.
+  //***************************************************************************
+  template <typename T1, typename T2 = void, typename T3 = void, typename T4 = void, 
+            typename T5 = void, typename T6 = void, typename T7 = void, typename T8 = void, 
+            typename T9 = void, typename T10 = void, typename T11 = void, typename T12 = void, 
+            typename T13 = void, typename T14 = void, typename T15 = void, typename T16 = void>
+  class message_packet
+  {
+  public:
+
+    //********************************************
+    explicit message_packet(const etl::imessage& msg)
+    {
+      const size_t id = msg.message_id;
+
+      void* p = data;
+
+      switch (id)
+      {
+        case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
+        case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
+        case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
+        case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
+        case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
+        case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
+        case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
+        case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
+        case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
+        case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
+        case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
+        case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
+        case T13::ID: ::new (p) T13(static_cast<const T13&>(msg)); break;
+        case T14::ID: ::new (p) T14(static_cast<const T14&>(msg)); break;
+        case T15::ID: ::new (p) T15(static_cast<const T15&>(msg)); break;
+        case T16::ID: ::new (p) T16(static_cast<const T16&>(msg)); break;
+        default: default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
+      }
+    }
+
+    //**********************************************
+    template <typename T>
+    explicit message_packet(const T& msg)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value), "Unsupported type for this message packet");
+
+      void* p = data;
+      ::new (p) T(static_cast<const T&>(msg));
+    }
+
+    //********************************************
+    ~message_packet()
+    {
+      etl::imessage* pmsg = static_cast<etl::imessage*>(data);
+
+  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
+      pmsg->~imessage();
+  #else
+      size_t id = pmsg->message_id;
+
+      switch (id)
+      {
+        case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
+        case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
+        case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
+        case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
+        case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
+        case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
+        case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
+        case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
+        case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
+        case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
+        case T11::ID: static_cast<T11*>(pmsg)->~T11(); break;
+        case T12::ID: static_cast<T12*>(pmsg)->~T12(); break;
+        case T13::ID: static_cast<T13*>(pmsg)->~T13(); break;
+        case T14::ID: static_cast<T14*>(pmsg)->~T14(); break;
+        case T15::ID: static_cast<T15*>(pmsg)->~T15(); break;
+        case T16::ID: static_cast<T16*>(pmsg)->~T16(); break;
+        default: assert(false); break;
+      }
+  #endif
+    }
+
+    //********************************************
+    etl::imessage& get() ETL_NOEXCEPT
+    {
+      return *static_cast<etl::imessage*>(data);
+    }
+
+    //********************************************
+    const etl::imessage& get() const ETL_NOEXCEPT
+    {
+      return *static_cast<const etl::imessage*>(data);
+    }
+
+    enum
+    {
+      SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::size,
+      ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::alignment
+    };
+
+  private:
+
+    typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
+
+    message_packet(const message_packet&) ETL_DELETE;
+    message_packet& operator =(const message_packet&) ETL_DELETE;
+  #if ETL_CPP11_SUPPORTED
+    message_packet(message_packet&&) ETL_DELETE;
+    message_packet& operator =(message_packet&&) ETL_DELETE;
+  #endif
+  };
+
+  //***************************************************************************
+  // Specialisation for 15 message types.
+  //***************************************************************************
+  template <typename T1, typename T2, typename T3, typename T4, 
+            typename T5, typename T6, typename T7, typename T8, 
+            typename T9, typename T10, typename T11, typename T12, 
+            typename T13, typename T14, typename T15>
+  class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, void>
+  {
+  public:
+
+    //********************************************
+    explicit message_packet(const etl::imessage& msg)
+    {
+      const size_t id = msg.message_id;
+
+      void* p = data;
+
+      switch (id)
+      {
+        case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
+        case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
+        case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
+        case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
+        case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
+        case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
+        case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
+        case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
+        case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
+        case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
+        case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
+        case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
+        case T13::ID: ::new (p) T13(static_cast<const T13&>(msg)); break;
+        case T14::ID: ::new (p) T14(static_cast<const T14&>(msg)); break;
+        case T15::ID: ::new (p) T15(static_cast<const T15&>(msg)); break;
+        default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
+      }
+    }
+
+    //**********************************************
+    template <typename T>
+    explicit message_packet(const T& msg)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value), "Unsupported type for this message packet");
+
+      void* p = data;
+      ::new (p) T(static_cast<const T&>(msg));
+    }
+
+    //********************************************
+    ~message_packet()
+    {
+      etl::imessage* pmsg = static_cast<etl::imessage*>(data);
+
+  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
+      pmsg->~imessage();
+  #else
+      size_t id = pmsg->message_id;
+
+      switch (id)
+      {
+        case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
+        case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
+        case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
+        case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
+        case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
+        case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
+        case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
+        case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
+        case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
+        case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
+        case T11::ID: static_cast<T11*>(pmsg)->~T11(); break;
+        case T12::ID: static_cast<T12*>(pmsg)->~T12(); break;
+        case T13::ID: static_cast<T13*>(pmsg)->~T13(); break;
+        case T14::ID: static_cast<T14*>(pmsg)->~T14(); break;
+        case T15::ID: static_cast<T15*>(pmsg)->~T15(); break;
+        default: assert(false); break;
+      }
+  #endif
+    }
+
+    //********************************************
+    etl::imessage& get() ETL_NOEXCEPT
+    {
+      return *static_cast<etl::imessage*>(data);
+    }
+
+    //********************************************
+    const etl::imessage& get() const ETL_NOEXCEPT
+    {
+      return *static_cast<const etl::imessage*>(data);
+    }
+
+    enum
+    {
+      SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::size,
+      ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::alignment
+    };
+
+  private:
+
+    typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
+
+    message_packet(const message_packet&) ETL_DELETE;
+    message_packet& operator =(const message_packet&) ETL_DELETE;
+  #if ETL_CPP11_SUPPORTED
+    message_packet(message_packet&&) ETL_DELETE;
+    message_packet& operator =(message_packet&&) ETL_DELETE;
+  #endif
+  };
+
+  //***************************************************************************
+  // Specialisation for 14 message types.
+  //***************************************************************************
+  template <typename T1, typename T2, typename T3, typename T4, 
+            typename T5, typename T6, typename T7, typename T8, 
+            typename T9, typename T10, typename T11, typename T12, 
+            typename T13, typename T14>
+  class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, void, void>
+  {
+  public:
+
+    //********************************************
+    explicit message_packet(const etl::imessage& msg)
+    {
+      const size_t id = msg.message_id;
+
+      void* p = data;
+
+      switch (id)
+      {
+        case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
+        case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
+        case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
+        case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
+        case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
+        case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
+        case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
+        case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
+        case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
+        case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
+        case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
+        case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
+        case T13::ID: ::new (p) T13(static_cast<const T13&>(msg)); break;
+        case T14::ID: ::new (p) T14(static_cast<const T14&>(msg)); break;
+        default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
+      }
+    }
+
+    //**********************************************
+    template <typename T>
+    explicit message_packet(const T& msg)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value), "Unsupported type for this message packet");
+
+      void* p = data;
+      ::new (p) T(static_cast<const T&>(msg));
+    }
+
+    //********************************************
+    ~message_packet()
+    {
+      etl::imessage* pmsg = static_cast<etl::imessage*>(data);
+
+  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
+      pmsg->~imessage();
+  #else
+      size_t id = pmsg->message_id;
+
+      switch (id)
+      {
+        case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
+        case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
+        case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
+        case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
+        case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
+        case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
+        case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
+        case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
+        case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
+        case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
+        case T11::ID: static_cast<T11*>(pmsg)->~T11(); break;
+        case T12::ID: static_cast<T12*>(pmsg)->~T12(); break;
+        case T13::ID: static_cast<T13*>(pmsg)->~T13(); break;
+        case T14::ID: static_cast<T14*>(pmsg)->~T14(); break;
+        default: assert(false); break;
+      }
+  #endif
+    }
+
+    //********************************************
+    etl::imessage& get() ETL_NOEXCEPT
+    {
+      return *static_cast<etl::imessage*>(data);
+    }
+
+    //********************************************
+    const etl::imessage& get() const ETL_NOEXCEPT
+    {
+      return *static_cast<const etl::imessage*>(data);
+    }
+
+    enum
+    {
+      SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::size,
+      ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::alignment
+    };
+
+  private:
+
+    typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
+
+    message_packet(const message_packet&) ETL_DELETE;
+    message_packet& operator =(const message_packet&) ETL_DELETE;
+  #if ETL_CPP11_SUPPORTED
+    message_packet(message_packet&&) ETL_DELETE;
+    message_packet& operator =(message_packet&&) ETL_DELETE;
+  #endif
+  };
+
+  //***************************************************************************
+  // Specialisation for 13 message types.
+  //***************************************************************************
+  template <typename T1, typename T2, typename T3, typename T4, 
+            typename T5, typename T6, typename T7, typename T8, 
+            typename T9, typename T10, typename T11, typename T12, 
+            typename T13>
+  class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, void, void, void>
+  {
+  public:
+
+    //********************************************
+    explicit message_packet(const etl::imessage& msg)
+    {
+      const size_t id = msg.message_id;
+
+      void* p = data;
+
+      switch (id)
+      {
+        case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
+        case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
+        case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
+        case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
+        case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
+        case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
+        case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
+        case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
+        case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
+        case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
+        case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
+        case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
+        case T13::ID: ::new (p) T13(static_cast<const T13&>(msg)); break;
+        default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
+      }
+    }
+
+    //**********************************************
+    template <typename T>
+    explicit message_packet(const T& msg)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value), "Unsupported type for this message packet");
+
+      void* p = data;
+      ::new (p) T(static_cast<const T&>(msg));
+    }
+
+    //********************************************
+    ~message_packet()
+    {
+      etl::imessage* pmsg = static_cast<etl::imessage*>(data);
+
+  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
+      pmsg->~imessage();
+  #else
+      size_t id = pmsg->message_id;
+
+      switch (id)
+      {
+        case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
+        case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
+        case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
+        case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
+        case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
+        case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
+        case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
+        case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
+        case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
+        case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
+        case T11::ID: static_cast<T11*>(pmsg)->~T11(); break;
+        case T12::ID: static_cast<T12*>(pmsg)->~T12(); break;
+        case T13::ID: static_cast<T13*>(pmsg)->~T13(); break;
+        default: assert(false); break;
+      }
+  #endif
+    }
+
+    //********************************************
+    etl::imessage& get() ETL_NOEXCEPT
+    {
+      return *static_cast<etl::imessage*>(data);
+    }
+
+    //********************************************
+    const etl::imessage& get() const ETL_NOEXCEPT
+    {
+      return *static_cast<const etl::imessage*>(data);
+    }
+
+    enum
+    {
+      SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::size,
+      ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::alignment
+    };
+
+  private:
+
+    typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
+
+    message_packet(const message_packet&) ETL_DELETE;
+    message_packet& operator =(const message_packet&) ETL_DELETE;
+  #if ETL_CPP11_SUPPORTED
+    message_packet(message_packet&&) ETL_DELETE;
+    message_packet& operator =(message_packet&&) ETL_DELETE;
+  #endif
+  };
+
+  //***************************************************************************
+  // Specialisation for 12 message types.
+  //***************************************************************************
+  template <typename T1, typename T2, typename T3, typename T4, 
+            typename T5, typename T6, typename T7, typename T8, 
+            typename T9, typename T10, typename T11, typename T12>
+  class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, void, void, void, void>
+  {
+  public:
+
+    //********************************************
+    explicit message_packet(const etl::imessage& msg)
+    {
+      const size_t id = msg.message_id;
+
+      void* p = data;
+
+      switch (id)
+      {
+        case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
+        case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
+        case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
+        case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
+        case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
+        case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
+        case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
+        case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
+        case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
+        case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
+        case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
+        case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
+        default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
+      }
+    }
+
+    //**********************************************
+    template <typename T>
+    explicit message_packet(const T& msg)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value), "Unsupported type for this message packet");
+
+      void* p = data;
+      ::new (p) T(static_cast<const T&>(msg));
+    }
+
+    //********************************************
+    ~message_packet()
+    {
+      etl::imessage* pmsg = static_cast<etl::imessage*>(data);
+
+  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
+      pmsg->~imessage();
+  #else
+      size_t id = pmsg->message_id;
+
+      switch (id)
+      {
+        case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
+        case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
+        case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
+        case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
+        case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
+        case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
+        case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
+        case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
+        case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
+        case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
+        case T11::ID: static_cast<T11*>(pmsg)->~T11(); break;
+        case T12::ID: static_cast<T12*>(pmsg)->~T12(); break;
+        default: assert(false); break;
+      }
+  #endif
+    }
+
+    //********************************************
+    etl::imessage& get() ETL_NOEXCEPT
+    {
+      return *static_cast<etl::imessage*>(data);
+    }
+
+    //********************************************
+    const etl::imessage& get() const ETL_NOEXCEPT
+    {
+      return *static_cast<const etl::imessage*>(data);
+    }
+
+    enum
+    {
+      SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::size,
+      ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::alignment
+    };
+
+  private:
+
+    typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
+
+    message_packet(const message_packet&) ETL_DELETE;
+    message_packet& operator =(const message_packet&) ETL_DELETE;
+  #if ETL_CPP11_SUPPORTED
+    message_packet(message_packet&&) ETL_DELETE;
+    message_packet& operator =(message_packet&&) ETL_DELETE;
+  #endif
+  };
+
+  //***************************************************************************
+  // Specialisation for 11 message types.
+  //***************************************************************************
+  template <typename T1, typename T2, typename T3, typename T4, 
+            typename T5, typename T6, typename T7, typename T8, 
+            typename T9, typename T10, typename T11>
+  class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, void, void, void, void, void>
+  {
+  public:
+
+    //********************************************
+    explicit message_packet(const etl::imessage& msg)
+    {
+      const size_t id = msg.message_id;
+
+      void* p = data;
+
+      switch (id)
+      {
+        case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
+        case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
+        case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
+        case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
+        case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
+        case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
+        case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
+        case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
+        case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
+        case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
+        case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
+        default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
+      }
+    }
+
+    //**********************************************
+    template <typename T>
+    explicit message_packet(const T& msg)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value), "Unsupported type for this message packet");
+
+      void* p = data;
+      ::new (p) T(static_cast<const T&>(msg));
+    }
+
+    //********************************************
+    ~message_packet()
+    {
+      etl::imessage* pmsg = static_cast<etl::imessage*>(data);
+
+  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
+      pmsg->~imessage();
+  #else
+      size_t id = pmsg->message_id;
+
+      switch (id)
+      {
+        case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
+        case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
+        case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
+        case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
+        case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
+        case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
+        case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
+        case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
+        case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
+        case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
+        case T11::ID: static_cast<T11*>(pmsg)->~T11(); break;
+        default: assert(false); break;
+      }
+  #endif
+    }
+
+    //********************************************
+    etl::imessage& get() ETL_NOEXCEPT
+    {
+      return *static_cast<etl::imessage*>(data);
+    }
+
+    //********************************************
+    const etl::imessage& get() const ETL_NOEXCEPT
+    {
+      return *static_cast<const etl::imessage*>(data);
+    }
+
+    enum
+    {
+      SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::size,
+      ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::alignment
+    };
+
+  private:
+
+    typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
+
+    message_packet(const message_packet&) ETL_DELETE;
+    message_packet& operator =(const message_packet&) ETL_DELETE;
+  #if ETL_CPP11_SUPPORTED
+    message_packet(message_packet&&) ETL_DELETE;
+    message_packet& operator =(message_packet&&) ETL_DELETE;
+  #endif
+  };
+
+  //***************************************************************************
+  // Specialisation for 10 message types.
+  //***************************************************************************
+  template <typename T1, typename T2, typename T3, typename T4, 
+            typename T5, typename T6, typename T7, typename T8, 
+            typename T9, typename T10>
+  class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, void, void, void, void, void, void>
+  {
+  public:
+
+    //********************************************
+    explicit message_packet(const etl::imessage& msg)
+    {
+      const size_t id = msg.message_id;
+
+      void* p = data;
+
+      switch (id)
+      {
+        case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
+        case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
+        case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
+        case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
+        case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
+        case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
+        case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
+        case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
+        case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
+        case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
+        default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
+      }
+    }
+
+    //**********************************************
+    template <typename T>
+    explicit message_packet(const T& msg)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value), "Unsupported type for this message packet");
+
+      void* p = data;
+      ::new (p) T(static_cast<const T&>(msg));
+    }
+
+    //********************************************
+    ~message_packet()
+    {
+      etl::imessage* pmsg = static_cast<etl::imessage*>(data);
+
+  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
+      pmsg->~imessage();
+  #else
+      size_t id = pmsg->message_id;
+
+      switch (id)
+      {
+        case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
+        case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
+        case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
+        case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
+        case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
+        case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
+        case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
+        case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
+        case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
+        case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
+        default: assert(false); break;
+      }
+  #endif
+    }
+
+    //********************************************
+    etl::imessage& get() ETL_NOEXCEPT
+    {
+      return *static_cast<etl::imessage*>(data);
+    }
+
+    //********************************************
+    const etl::imessage& get() const ETL_NOEXCEPT
+    {
+      return *static_cast<const etl::imessage*>(data);
+    }
+
+    enum
+    {
+      SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::size,
+      ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::alignment
+    };
+
+  private:
+
+    typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
+
+    message_packet(const message_packet&) ETL_DELETE;
+    message_packet& operator =(const message_packet&) ETL_DELETE;
+  #if ETL_CPP11_SUPPORTED
+    message_packet(message_packet&&) ETL_DELETE;
+    message_packet& operator =(message_packet&&) ETL_DELETE;
+  #endif
+  };
+
+  //***************************************************************************
+  // Specialisation for 9 message types.
+  //***************************************************************************
+  template <typename T1, typename T2, typename T3, typename T4, 
+            typename T5, typename T6, typename T7, typename T8, 
+            typename T9>
+  class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, void, void, void, void, void, void, void>
+  {
+  public:
+
+    //********************************************
+    explicit message_packet(const etl::imessage& msg)
+    {
+      const size_t id = msg.message_id;
+
+      void* p = data;
+
+      switch (id)
+      {
+        case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
+        case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
+        case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
+        case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
+        case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
+        case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
+        case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
+        case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
+        case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
+        default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
+      }
+    }
+
+    //**********************************************
+    template <typename T>
+    explicit message_packet(const T& msg)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7, T8, T9>::value), "Unsupported type for this message packet");
+
+      void* p = data;
+      ::new (p) T(static_cast<const T&>(msg));
+    }
+
+    //********************************************
+    ~message_packet()
+    {
+      etl::imessage* pmsg = static_cast<etl::imessage*>(data);
+
+  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
+      pmsg->~imessage();
+  #else
+      size_t id = pmsg->message_id;
+
+      switch (id)
+      {
+        case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
+        case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
+        case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
+        case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
+        case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
+        case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
+        case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
+        case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
+        case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
+        default: assert(false); break;
+      }
+  #endif
+    }
+
+    //********************************************
+    etl::imessage& get() ETL_NOEXCEPT
+    {
+      return *static_cast<etl::imessage*>(data);
+    }
+
+    //********************************************
+    const etl::imessage& get() const ETL_NOEXCEPT
+    {
+      return *static_cast<const etl::imessage*>(data);
+    }
+
+    enum
+    {
+      SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9>::size,
+      ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9>::alignment
+    };
+
+  private:
+
+    typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
+
+    message_packet(const message_packet&) ETL_DELETE;
+    message_packet& operator =(const message_packet&) ETL_DELETE;
+  #if ETL_CPP11_SUPPORTED
+    message_packet(message_packet&&) ETL_DELETE;
+    message_packet& operator =(message_packet&&) ETL_DELETE;
+  #endif
+  };
+
+  //***************************************************************************
+  // Specialisation for 8 message types.
+  //***************************************************************************
+  template <typename T1, typename T2, typename T3, typename T4, 
+            typename T5, typename T6, typename T7, typename T8>
+  class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, void, void, void, void, void, void, void, void>
+  {
+  public:
+
+    //********************************************
+    explicit message_packet(const etl::imessage& msg)
+    {
+      const size_t id = msg.message_id;
+
+      void* p = data;
+
+      switch (id)
+      {
+        case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
+        case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
+        case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
+        case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
+        case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
+        case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
+        case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
+        case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
+        default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
+      }
+    }
+
+    //**********************************************
+    template <typename T>
+    explicit message_packet(const T& msg)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7, T8>::value), "Unsupported type for this message packet");
+
+      void* p = data;
+      ::new (p) T(static_cast<const T&>(msg));
+    }
+
+    //********************************************
+    ~message_packet()
+    {
+      etl::imessage* pmsg = static_cast<etl::imessage*>(data);
+
+  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
+      pmsg->~imessage();
+  #else
+      size_t id = pmsg->message_id;
+
+      switch (id)
+      {
+        case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
+        case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
+        case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
+        case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
+        case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
+        case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
+        case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
+        case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
+        default: assert(false); break;
+      }
+  #endif
+    }
+
+    //********************************************
+    etl::imessage& get() ETL_NOEXCEPT
+    {
+      return *static_cast<etl::imessage*>(data);
+    }
+
+    //********************************************
+    const etl::imessage& get() const ETL_NOEXCEPT
+    {
+      return *static_cast<const etl::imessage*>(data);
+    }
+
+    enum
+    {
+      SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8>::size,
+      ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8>::alignment
+    };
+
+  private:
+
+    typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
+
+    message_packet(const message_packet&) ETL_DELETE;
+    message_packet& operator =(const message_packet&) ETL_DELETE;
+  #if ETL_CPP11_SUPPORTED
+    message_packet(message_packet&&) ETL_DELETE;
+    message_packet& operator =(message_packet&&) ETL_DELETE;
+  #endif
+  };
+
+  //***************************************************************************
+  // Specialisation for 7 message types.
+  //***************************************************************************
+  template <typename T1, typename T2, typename T3, typename T4, 
+            typename T5, typename T6, typename T7>
+  class message_packet<T1, T2, T3, T4, T5, T6, T7, void, void, void, void, void, void, void, void, void>
+  {
+  public:
+
+    //********************************************
+    explicit message_packet(const etl::imessage& msg)
+    {
+      const size_t id = msg.message_id;
+
+      void* p = data;
+
+      switch (id)
+      {
+        case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
+        case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
+        case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
+        case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
+        case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
+        case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
+        case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
+        default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
+      }
+    }
+
+    //**********************************************
+    template <typename T>
+    explicit message_packet(const T& msg)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7>::value), "Unsupported type for this message packet");
+
+      void* p = data;
+      ::new (p) T(static_cast<const T&>(msg));
+    }
+
+    //********************************************
+    ~message_packet()
+    {
+      etl::imessage* pmsg = static_cast<etl::imessage*>(data);
+
+  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
+      pmsg->~imessage();
+  #else
+      size_t id = pmsg->message_id;
+
+      switch (id)
+      {
+        case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
+        case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
+        case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
+        case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
+        case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
+        case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
+        case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
+        default: assert(false); break;
+      }
+  #endif
+    }
+
+    //********************************************
+    etl::imessage& get() ETL_NOEXCEPT
+    {
+      return *static_cast<etl::imessage*>(data);
+    }
+
+    //********************************************
+    const etl::imessage& get() const ETL_NOEXCEPT
+    {
+      return *static_cast<const etl::imessage*>(data);
+    }
+
+    enum
+    {
+      SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7>::size,
+      ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7>::alignment
+    };
+
+  private:
+
+    typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
+
+    message_packet(const message_packet&) ETL_DELETE;
+    message_packet& operator =(const message_packet&) ETL_DELETE;
+  #if ETL_CPP11_SUPPORTED
+    message_packet(message_packet&&) ETL_DELETE;
+    message_packet& operator =(message_packet&&) ETL_DELETE;
+  #endif
+  };
+
+  //***************************************************************************
+  // Specialisation for 6 message types.
+  //***************************************************************************
+  template <typename T1, typename T2, typename T3, typename T4, 
+            typename T5, typename T6>
+  class message_packet<T1, T2, T3, T4, T5, T6, void, void, void, void, void, void, void, void, void, void>
+  {
+  public:
+
+    //********************************************
+    explicit message_packet(const etl::imessage& msg)
+    {
+      const size_t id = msg.message_id;
+
+      void* p = data;
+
+      switch (id)
+      {
+        case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
+        case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
+        case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
+        case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
+        case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
+        case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
+        default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
+      }
+    }
+
+    //**********************************************
+    template <typename T>
+    explicit message_packet(const T& msg)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6>::value), "Unsupported type for this message packet");
+
+      void* p = data;
+      ::new (p) T(static_cast<const T&>(msg));
+    }
+
+    //********************************************
+    ~message_packet()
+    {
+      etl::imessage* pmsg = static_cast<etl::imessage*>(data);
+
+  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
+      pmsg->~imessage();
+  #else
+      size_t id = pmsg->message_id;
+
+      switch (id)
+      {
+        case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
+        case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
+        case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
+        case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
+        case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
+        case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
+        default: assert(false); break;
+      }
+  #endif
+    }
+
+    //********************************************
+    etl::imessage& get() ETL_NOEXCEPT
+    {
+      return *static_cast<etl::imessage*>(data);
+    }
+
+    //********************************************
+    const etl::imessage& get() const ETL_NOEXCEPT
+    {
+      return *static_cast<const etl::imessage*>(data);
+    }
+
+    enum
+    {
+      SIZE      = etl::largest<T1, T2, T3, T4, T5, T6>::size,
+      ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6>::alignment
+    };
+
+  private:
+
+    typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
+
+    message_packet(const message_packet&) ETL_DELETE;
+    message_packet& operator =(const message_packet&) ETL_DELETE;
+  #if ETL_CPP11_SUPPORTED
+    message_packet(message_packet&&) ETL_DELETE;
+    message_packet& operator =(message_packet&&) ETL_DELETE;
+  #endif
+  };
+
+  //***************************************************************************
+  // Specialisation for 5 message types.
+  //***************************************************************************
+  template <typename T1, typename T2, typename T3, typename T4, 
+            typename T5>
+  class message_packet<T1, T2, T3, T4, T5, void, void, void, void, void, void, void, void, void, void, void>
+  {
+  public:
+
+    //********************************************
+    explicit message_packet(const etl::imessage& msg)
+    {
+      const size_t id = msg.message_id;
+
+      void* p = data;
+
+      switch (id)
+      {
+        case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
+        case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
+        case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
+        case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
+        case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
+        default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
+      }
+    }
+
+    //**********************************************
+    template <typename T>
+    explicit message_packet(const T& msg)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5>::value), "Unsupported type for this message packet");
+
+      void* p = data;
+      ::new (p) T(static_cast<const T&>(msg));
+    }
+
+    //********************************************
+    ~message_packet()
+    {
+      etl::imessage* pmsg = static_cast<etl::imessage*>(data);
+
+  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
+      pmsg->~imessage();
+  #else
+      size_t id = pmsg->message_id;
+
+      switch (id)
+      {
+        case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
+        case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
+        case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
+        case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
+        case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
+        default: assert(false); break;
+      }
+  #endif
+    }
+
+    //********************************************
+    etl::imessage& get() ETL_NOEXCEPT
+    {
+      return *static_cast<etl::imessage*>(data);
+    }
+
+    //********************************************
+    const etl::imessage& get() const ETL_NOEXCEPT
+    {
+      return *static_cast<const etl::imessage*>(data);
+    }
+
+    enum
+    {
+      SIZE      = etl::largest<T1, T2, T3, T4, T5>::size,
+      ALIGNMENT = etl::largest<T1, T2, T3, T4, T5>::alignment
+    };
+
+  private:
+
+    typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
+
+    message_packet(const message_packet&) ETL_DELETE;
+    message_packet& operator =(const message_packet&) ETL_DELETE;
+  #if ETL_CPP11_SUPPORTED
+    message_packet(message_packet&&) ETL_DELETE;
+    message_packet& operator =(message_packet&&) ETL_DELETE;
+  #endif
+  };
+
+  //***************************************************************************
+  // Specialisation for 4 message types.
+  //***************************************************************************
+  template <typename T1, typename T2, typename T3, typename T4>
+  class message_packet<T1, T2, T3, T4, void, void, void, void, void, void, void, void, void, void, void, void>
+  {
+  public:
+
+    //********************************************
+    explicit message_packet(const etl::imessage& msg)
+    {
+      const size_t id = msg.message_id;
+
+      void* p = data;
+
+      switch (id)
+      {
+        case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
+        case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
+        case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
+        case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
+        default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
+      }
+    }
+
+    //**********************************************
+    template <typename T>
+    explicit message_packet(const T& msg)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4>::value), "Unsupported type for this message packet");
+
+      void* p = data;
+      ::new (p) T(static_cast<const T&>(msg));
+    }
+
+    //********************************************
+    ~message_packet()
+    {
+      etl::imessage* pmsg = static_cast<etl::imessage*>(data);
+
+  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
+      pmsg->~imessage();
+  #else
+      size_t id = pmsg->message_id;
+
+      switch (id)
+      {
+        case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
+        case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
+        case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
+        case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
+        default: assert(false); break;
+      }
+  #endif
+    }
+
+    //********************************************
+    etl::imessage& get() ETL_NOEXCEPT
+    {
+      return *static_cast<etl::imessage*>(data);
+    }
+
+    //********************************************
+    const etl::imessage& get() const ETL_NOEXCEPT
+    {
+      return *static_cast<const etl::imessage*>(data);
+    }
+
+    enum
+    {
+      SIZE      = etl::largest<T1, T2, T3, T4>::size,
+      ALIGNMENT = etl::largest<T1, T2, T3, T4>::alignment
+    };
+
+  private:
+
+    typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
+
+    message_packet(const message_packet&) ETL_DELETE;
+    message_packet& operator =(const message_packet&) ETL_DELETE;
+  #if ETL_CPP11_SUPPORTED
+    message_packet(message_packet&&) ETL_DELETE;
+    message_packet& operator =(message_packet&&) ETL_DELETE;
+  #endif
+  };
+
+  //***************************************************************************
+  // Specialisation for 3 message types.
+  //***************************************************************************
+  template <typename T1, typename T2, typename T3>
+  class message_packet<T1, T2, T3, void, void, void, void, void, void, void, void, void, void, void, void, void>
+  {
+  public:
+
+    //********************************************
+    explicit message_packet(const etl::imessage& msg)
+    {
+      const size_t id = msg.message_id;
+
+      void* p = data;
+
+      switch (id)
+      {
+        case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
+        case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
+        case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
+        default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
+      }
+    }
+
+    //**********************************************
+    template <typename T>
+    explicit message_packet(const T& msg)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3>::value), "Unsupported type for this message packet");
+
+      void* p = data;
+      ::new (p) T(static_cast<const T&>(msg));
+    }
+
+    //********************************************
+    ~message_packet()
+    {
+      etl::imessage* pmsg = static_cast<etl::imessage*>(data);
+
+  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
+      pmsg->~imessage();
+  #else
+      size_t id = pmsg->message_id;
+
+      switch (id)
+      {
+        case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
+        case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
+        case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
+        default: assert(false); break;
+      }
+  #endif
+    }
+
+    //********************************************
+    etl::imessage& get() ETL_NOEXCEPT
+    {
+      return *static_cast<etl::imessage*>(data);
+    }
+
+    //********************************************
+    const etl::imessage& get() const ETL_NOEXCEPT
+    {
+      return *static_cast<const etl::imessage*>(data);
+    }
+
+    enum
+    {
+      SIZE      = etl::largest<T1, T2, T3>::size,
+      ALIGNMENT = etl::largest<T1, T2, T3>::alignment
+    };
+
+  private:
+
+    typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
+
+    message_packet(const message_packet&) ETL_DELETE;
+    message_packet& operator =(const message_packet&) ETL_DELETE;
+  #if ETL_CPP11_SUPPORTED
+    message_packet(message_packet&&) ETL_DELETE;
+    message_packet& operator =(message_packet&&) ETL_DELETE;
+  #endif
+  };
+
+  //***************************************************************************
+  // Specialisation for 2 message types.
+  //***************************************************************************
+  template <typename T1, typename T2>
+  class message_packet<T1, T2, void, void, void, void, void, void, void, void, void, void, void, void, void, void>
+  {
+  public:
+
+    //********************************************
+    explicit message_packet(const etl::imessage& msg)
+    {
+      const size_t id = msg.message_id;
+
+      void* p = data;
+
+      switch (id)
+      {
+        case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
+        case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
+        default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
+      }
+    }
+
+    //**********************************************
+    template <typename T>
+    explicit message_packet(const T& msg)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2>::value), "Unsupported type for this message packet");
+
+      void* p = data;
+      ::new (p) T(static_cast<const T&>(msg));
+    }
+
+    //********************************************
+    ~message_packet()
+    {
+      etl::imessage* pmsg = static_cast<etl::imessage*>(data);
+
+  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
+      pmsg->~imessage();
+  #else
+      size_t id = pmsg->message_id;
+
+      switch (id)
+      {
+        case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
+        case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
+        default: assert(false); break;
+      }
+  #endif
+    }
+
+    //********************************************
+    etl::imessage& get() ETL_NOEXCEPT
+    {
+      return *static_cast<etl::imessage*>(data);
+    }
+
+    //********************************************
+    const etl::imessage& get() const ETL_NOEXCEPT
+    {
+      return *static_cast<const etl::imessage*>(data);
+    }
+
+    enum
+    {
+      SIZE      = etl::largest<T1, T2>::size,
+      ALIGNMENT = etl::largest<T1, T2>::alignment
+    };
+
+  private:
+
+    typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
+
+    message_packet(const message_packet&) ETL_DELETE;
+    message_packet& operator =(const message_packet&) ETL_DELETE;
+  #if ETL_CPP11_SUPPORTED
+    message_packet(message_packet&&) ETL_DELETE;
+    message_packet& operator =(message_packet&&) ETL_DELETE;
+  #endif
+  };
+
+  //***************************************************************************
+  // Specialisation for 1 message type.
+  //***************************************************************************
+  template <typename T1>
+  class message_packet<T1, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void>
+  {
+  public:
+
+    //********************************************
+    explicit message_packet(const etl::imessage& msg)
+    {
+      const size_t id = msg.message_id;
+
+      void* p = data;
+
+      switch (id)
+      {
+        case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
+        default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
+      }
+    }
+
+    //**********************************************
+    template <typename T>
+    explicit message_packet(const T& msg)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, T1>::value), "Unsupported type for this message packet");
+
+      void* p = data;
+      ::new (p) T(static_cast<const T&>(msg));
+    }
+
+    //********************************************
+    ~message_packet()
+    {
+      etl::imessage* pmsg = static_cast<etl::imessage*>(data);
+
+  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
+      pmsg->~imessage();
+  #else
+      size_t id = pmsg->message_id;
+
+      switch (id)
+      {
+        case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
+        default: assert(false); break;
+      }
+  #endif
+    }
+
+    //********************************************
+    etl::imessage& get() ETL_NOEXCEPT
+    {
+      return *static_cast<etl::imessage*>(data);
+    }
+
+    //********************************************
+    const etl::imessage& get() const ETL_NOEXCEPT
+    {
+      return *static_cast<const etl::imessage*>(data);
+    }
+
+    enum
+    {
+      SIZE      = etl::largest<T1>::size,
+      ALIGNMENT = etl::largest<T1>::alignment
+    };
+
+  private:
+
+    typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
+
+    message_packet(const message_packet&) ETL_DELETE;
+    message_packet& operator =(const message_packet&) ETL_DELETE;
+  #if ETL_CPP11_SUPPORTED
+    message_packet(message_packet&&) ETL_DELETE;
+    message_packet& operator =(message_packet&&) ETL_DELETE;
+  #endif
+  };
+}
+
+#undef ETL_FILE
+
+#endif
diff --git a/include/etl/message_packet_generator.h b/include/etl/message_packet_generator.h
new file mode 100644
index 00000000..2f88e038
--- /dev/null
+++ b/include/etl/message_packet_generator.h
@@ -0,0 +1,309 @@
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2020 jwellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+/*[[[cog
+import cog
+cog.outl("#if 0")
+]]]*/
+/*[[[end]]]*/
+#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+/*[[[cog
+import cog
+cog.outl("#endif")
+]]]*/
+/*[[[end]]]*/
+
+/*[[[cog
+import cog
+cog.outl("//***************************************************************************")
+cog.outl("// THIS FILE HAS BEEN AUTO GENERATED. DO NOT EDIT THIS FILE.")
+cog.outl("//***************************************************************************")
+]]]*/
+/*[[[end]]]*/
+
+//***************************************************************************
+// To generate to header file, run this at the command line.
+// Note: You will need Python and COG installed.
+//
+// python -m cogapp -d -e -omessage_packet.h -DHandlers=<n> message_packet_generator.h
+// Where <n> is the number of messages to support.
+//
+// e.g.
+// To generate handlers for up to 16 messages...
+// python -m cogapp -d -e -omessage_packet.h -DHandlers=16 message_packet_generator.h
+//
+// See generate.bat
+//***************************************************************************
+
+#ifndef ETL_MESSAGE_PACKET_INCLUDED
+#define ETL_MESSAGE_PACKET_INCLUDED
+
+#include "message.h"
+#include "error_handler.h"
+#include "static_assert.h"
+#include "largest.h"
+#include "alignment.h"
+
+#include <stdint.h>
+
+#undef ETL_FILE
+#define ETL_FILE "55"
+
+namespace etl
+{
+  /*[[[cog
+    import cog
+    ################################################
+    # The first definition for all of the messages.
+    ################################################
+    cog.outl("//***************************************************************************")
+    cog.outl("// The definition for all %s message types." % Handlers)
+    cog.outl("//***************************************************************************")
+    cog.out("template <")
+    cog.out("typename T1, ")
+    for n in range(2, int(Handlers)):
+        cog.out("typename T%s = void, " % n)
+        if n % 4 == 0:
+            cog.outl("")
+            cog.out("          ")
+    cog.outl("typename T%s = void>" % int(Handlers))
+    cog.outl("class message_packet")
+    cog.outl("{")
+    cog.outl("public:")
+    cog.outl("")
+    cog.outl("  //********************************************")
+    cog.outl("  explicit message_packet(const etl::imessage& msg)")
+    cog.outl("  {")
+    cog.outl("    const size_t id = msg.message_id;")
+    cog.outl("")
+    cog.outl("    void* p = data;")
+    cog.outl("")
+    cog.outl("    switch (id)")
+    cog.outl("    {")
+    for n in range(1, int(Handlers) + 1):
+        cog.out("      case T%d::ID:" %n)
+        cog.out(" ::new (p) T%d(static_cast<const T%d&>(msg));" % (n, n))
+        cog.outl(" break;")
+    cog.outl("      default: default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;")
+    cog.outl("    }")
+    cog.outl("  }")
+    cog.outl("")
+    cog.outl("  //**********************************************")
+    cog.outl("  template <typename T>")
+    cog.outl("  explicit message_packet(const T& msg)")
+    cog.outl("  {")
+    cog.out("    ETL_STATIC_ASSERT((etl::is_one_of<T, ")
+    for n in range(1, int(Handlers)):
+        cog.out("T%d, " % n)
+    cog.outl("T%s>::value), \"Unsupported type for this message packet\");" % int(Handlers))
+    cog.outl("")
+    cog.outl("    void* p = data;")
+    cog.outl("    ::new (p) T(static_cast<const T&>(msg));")
+    cog.outl("  }")
+    cog.outl("")
+    cog.outl("  //********************************************")
+    cog.outl("  ~message_packet()")
+    cog.outl("  {")
+    cog.outl("    etl::imessage* pmsg = static_cast<etl::imessage*>(data);")
+    cog.outl("")
+    cog.outl("#if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)")
+    cog.outl("    pmsg->~imessage();")
+    cog.outl("#else")
+    cog.outl("    size_t id = pmsg->message_id;")
+    cog.outl("")
+    cog.outl("    switch (id)")
+    cog.outl("    {")
+    for n in range(1, int(Handlers) + 1):
+        cog.outl("      case T%s::ID: static_cast<T%s*>(pmsg)->~T%s(); break;" % (n, n, n))
+    cog.outl("      default: assert(false); break;")
+    cog.outl("    }")
+    cog.outl("#endif")
+    cog.outl("  }")
+    cog.outl("")
+    cog.outl("  //********************************************")
+    cog.outl("  etl::imessage& get() ETL_NOEXCEPT")
+    cog.outl("  {")
+    cog.outl("    return *static_cast<etl::imessage*>(data);")
+    cog.outl("  }")
+    cog.outl("")
+    cog.outl("  //********************************************")
+    cog.outl("  const etl::imessage& get() const ETL_NOEXCEPT")
+    cog.outl("  {")
+    cog.outl("    return *static_cast<const etl::imessage*>(data);")
+    cog.outl("  }")
+    cog.outl("")
+    cog.outl("  enum")
+    cog.outl("  {")
+    cog.out("    SIZE      = etl::largest<")
+    for n in range(1, int(Handlers)):
+        cog.out("T%d, " % n)
+    cog.outl("T%s>::size," % int(Handlers))
+    cog.out("    ALIGNMENT = etl::largest<")
+    for n in range(1, int(Handlers)):
+        cog.out("T%d, " % n)
+    cog.outl("T%s>::alignment" % int(Handlers))
+    cog.outl("  };")
+    cog.outl("")
+    cog.outl("private:")
+    cog.outl("")
+    cog.outl("  typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;")
+    cog.outl("")
+    cog.outl("  message_packet(const message_packet&) ETL_DELETE;")
+    cog.outl("  message_packet& operator =(const message_packet&) ETL_DELETE;")
+    cog.outl("#if ETL_CPP11_SUPPORTED")
+    cog.outl("  message_packet(message_packet&&) ETL_DELETE;")
+    cog.outl("  message_packet& operator =(message_packet&&) ETL_DELETE;")
+    cog.outl("#endif")
+    cog.outl("};")
+
+    ####################################
+    # All of the other specialisations.
+    ####################################
+    for n in range(int(Handlers) - 1, 0, -1):
+        cog.outl("")
+        cog.outl("//***************************************************************************")
+        if n == 1:
+            cog.outl("// Specialisation for %d message type." % n)
+        else:
+            cog.outl("// Specialisation for %d message types." % n)
+        cog.outl("//***************************************************************************")
+        cog.out("template <")
+        for t in range(1, n):
+            cog.out("typename T%s, " % t)
+            if t % 4 == 0:
+                cog.outl("")
+                cog.out("          ")
+        cog.outl("typename T%s>" % n)
+        cog.out("class message_packet<")
+        for t in range(1, n + 1):
+            cog.out("T%d, " % t)
+            if t % 16 == 0:
+                cog.outl("")
+                cog.out("               ")
+        for t in range(n + 1, int(Handlers)):
+            cog.out("void, ")
+            if t % 16 == 0:
+                cog.outl("")
+                cog.out("               ")
+        cog.outl("void>")
+        cog.outl("{")
+        cog.outl("public:")
+        cog.outl("")
+        cog.outl("  //********************************************")
+        cog.outl("  explicit message_packet(const etl::imessage& msg)")
+        cog.outl("  {")
+        cog.outl("    const size_t id = msg.message_id;")
+        cog.outl("")
+        cog.outl("    void* p = data;")
+        cog.outl("")
+        cog.outl("    switch (id)")
+        cog.outl("    {")
+        for t in range(1, n + 1):
+            cog.out("      case T%d::ID:" %t)
+            cog.out(" ::new (p) T%d(static_cast<const T%d&>(msg));" % (t, t))
+            cog.outl(" break;")
+        cog.outl("      default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;")
+        cog.outl("    }")
+        cog.outl("  }")
+        cog.outl("")
+
+        cog.outl("  //**********************************************")
+        cog.outl("  template <typename T>")
+        cog.outl("  explicit message_packet(const T& msg)")
+        cog.outl("  {")
+        cog.out("    ETL_STATIC_ASSERT((etl::is_one_of<T, ")
+        for t in range(1, n):
+            cog.out("T%d, " % t)
+        cog.outl("T%s>::value), \"Unsupported type for this message packet\");" % n)
+        cog.outl("")
+        cog.outl("    void* p = data;")
+        cog.outl("    ::new (p) T(static_cast<const T&>(msg));")
+        cog.outl("  }")
+        cog.outl("")
+
+        cog.outl("  //********************************************")
+        cog.outl("  ~message_packet()")
+        cog.outl("  {")
+        cog.outl("    etl::imessage* pmsg = static_cast<etl::imessage*>(data);")
+        cog.outl("")
+        cog.outl("#if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)")
+        cog.outl("    pmsg->~imessage();")
+        cog.outl("#else")
+        cog.outl("    size_t id = pmsg->message_id;")
+        cog.outl("")
+        cog.outl("    switch (id)")
+        cog.outl("    {")
+        for t in range(1, n + 1):
+            cog.outl("      case T%s::ID: static_cast<T%s*>(pmsg)->~T%s(); break;" % (t, t, t))
+        cog.outl("      default: assert(false); break;")
+        cog.outl("    }")
+        cog.outl("#endif")
+        cog.outl("  }")
+        cog.outl("")
+        cog.outl("  //********************************************")
+        cog.outl("  etl::imessage& get() ETL_NOEXCEPT")
+        cog.outl("  {")
+        cog.outl("    return *static_cast<etl::imessage*>(data);")
+        cog.outl("  }")
+        cog.outl("")
+        cog.outl("  //********************************************")
+        cog.outl("  const etl::imessage& get() const ETL_NOEXCEPT")
+        cog.outl("  {")
+        cog.outl("    return *static_cast<const etl::imessage*>(data);")
+        cog.outl("  }")
+        cog.outl("")
+        cog.outl("  enum")
+        cog.outl("  {")
+        cog.out("    SIZE      = etl::largest<")
+        for t in range(1, n):
+            cog.out("T%d, " % t)
+        cog.outl("T%s>::size," % n)
+        cog.out("    ALIGNMENT = etl::largest<")
+        for t in range(1, n):
+            cog.out("T%d, " % t)
+        cog.outl("T%s>::alignment" % n)
+        cog.outl("  };")
+        cog.outl("")
+        cog.outl("private:")
+        cog.outl("")
+        cog.outl("  typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;")
+        cog.outl("")
+        cog.outl("  message_packet(const message_packet&) ETL_DELETE;")
+        cog.outl("  message_packet& operator =(const message_packet&) ETL_DELETE;")
+        cog.outl("#if ETL_CPP11_SUPPORTED")
+        cog.outl("  message_packet(message_packet&&) ETL_DELETE;")
+        cog.outl("  message_packet& operator =(message_packet&&) ETL_DELETE;")
+        cog.outl("#endif")
+        cog.outl("};")
+  ]]]*/
+  /*[[[end]]]*/
+}
+
+#undef ETL_FILE
+
+#endif
diff --git a/include/etl/message_router.h b/include/etl/message_router.h
index 26a68b45..fcfaa0e1 100644
--- a/include/etl/message_router.h
+++ b/include/etl/message_router.h
@@ -56,6 +56,7 @@ SOFTWARE.
 
 #include "platform.h"
 #include "message.h"
+#include "message_packet.h"
 #include "message_types.h"
 #include "alignment.h"
 #include "error_handler.h"
@@ -250,105 +251,7 @@ namespace etl
   {
   public:
 
-    //**********************************************
-    class message_packet
-    {
-    public:
-
-      //********************************************
-      explicit message_packet(const etl::imessage& msg)
-      {
-        const size_t id = msg.message_id;
-
-        void* p = data;
-
-        switch (id)
-        {
-          case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
-          case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
-          case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
-          case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
-          case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
-          case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
-          case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
-          case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
-          case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
-          case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
-          case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
-          case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
-          case T13::ID: ::new (p) T13(static_cast<const T13&>(msg)); break;
-          case T14::ID: ::new (p) T14(static_cast<const T14&>(msg)); break;
-          case T15::ID: ::new (p) T15(static_cast<const T15&>(msg)); break;
-          case T16::ID: ::new (p) T16(static_cast<const T16&>(msg)); break;
-          default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
-        }
-      }
-
-      //********************************************
-      template <typename T>
-      explicit message_packet(const T& msg)
-      {
-        ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value), "Unsupported type for this message packet");
-
-        void* p = data;
-        ::new (p) T(static_cast<const T&>(msg));
-      }
-
-      //********************************************
-      ~message_packet()
-      {
-        etl::imessage* pmsg = static_cast<etl::imessage*>(data);
-
-  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
-        pmsg->~imessage();
-  #else
-        size_t id = pmsg->message_id;
-
-        switch (id)
-        {
-          case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
-          case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
-          case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
-          case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
-          case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
-          case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
-          case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
-          case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
-          case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
-          case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
-          case T11::ID: static_cast<T11*>(pmsg)->~T11(); break;
-          case T12::ID: static_cast<T12*>(pmsg)->~T12(); break;
-          case T13::ID: static_cast<T13*>(pmsg)->~T13(); break;
-          case T14::ID: static_cast<T14*>(pmsg)->~T14(); break;
-          case T15::ID: static_cast<T15*>(pmsg)->~T15(); break;
-          case T16::ID: static_cast<T16*>(pmsg)->~T16(); break;
-          default: assert(false); break;
-        }
-  #endif
-      }
-
-      //********************************************
-      etl::imessage& get()
-      {
-        return *static_cast<etl::imessage*>(data);
-      }
-
-      //********************************************
-      const etl::imessage& get() const
-      {
-        return *static_cast<const etl::imessage*>(data);
-      }
-
-      enum
-      {
-        SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::size,
-        ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::alignment
-      };
-
-    private:
-
-      typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    };
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,  T16> message_packet;
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -452,103 +355,7 @@ namespace etl
   {
   public:
 
-    //**********************************************
-    class message_packet
-    {
-    public:
-
-      //********************************************
-      explicit message_packet(const etl::imessage& msg)
-      {
-        const size_t id = msg.message_id;
-
-        void* p = data;
-
-        switch (id)
-        {
-          case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
-          case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
-          case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
-          case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
-          case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
-          case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
-          case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
-          case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
-          case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
-          case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
-          case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
-          case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
-          case T13::ID: ::new (p) T13(static_cast<const T13&>(msg)); break;
-          case T14::ID: ::new (p) T14(static_cast<const T14&>(msg)); break;
-          case T15::ID: ::new (p) T15(static_cast<const T15&>(msg)); break;
-          default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
-        }
-      }
-
-      //********************************************
-      template <typename T>
-      explicit message_packet(const T& msg)
-      {
-        ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value), "Unsupported type for this message packet");
-
-        void* p = data;
-        ::new (p) T(static_cast<const T&>(msg));
-      }
-
-      //********************************************
-      ~message_packet()
-      {
-        etl::imessage* pmsg = static_cast<etl::imessage*>(data);
-
-  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
-        pmsg->~imessage();
-  #else
-        size_t id = pmsg->message_id;
-
-        switch (id)
-        {
-          case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
-          case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
-          case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
-          case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
-          case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
-          case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
-          case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
-          case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
-          case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
-          case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
-          case T11::ID: static_cast<T11*>(pmsg)->~T11(); break;
-          case T12::ID: static_cast<T12*>(pmsg)->~T12(); break;
-          case T13::ID: static_cast<T13*>(pmsg)->~T13(); break;
-          case T14::ID: static_cast<T14*>(pmsg)->~T14(); break;
-          case T15::ID: static_cast<T15*>(pmsg)->~T15(); break;
-          default: assert(false); break;
-        }
-  #endif
-      }
-
-      //********************************************
-      etl::imessage& get()
-      {
-        return *static_cast<etl::imessage*>(data);
-      }
-
-      //********************************************
-      const etl::imessage& get() const
-      {
-        return *static_cast<const etl::imessage*>(data);
-      }
-
-      enum
-      {
-        SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::size,
-        ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::alignment
-      };
-
-    private:
-
-      typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    };
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,  T15> message_packet;
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -651,101 +458,7 @@ namespace etl
   {
   public:
 
-    //**********************************************
-    class message_packet
-    {
-    public:
-
-      //********************************************
-      explicit message_packet(const etl::imessage& msg)
-      {
-        const size_t id = msg.message_id;
-
-        void* p = data;
-
-        switch (id)
-        {
-          case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
-          case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
-          case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
-          case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
-          case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
-          case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
-          case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
-          case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
-          case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
-          case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
-          case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
-          case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
-          case T13::ID: ::new (p) T13(static_cast<const T13&>(msg)); break;
-          case T14::ID: ::new (p) T14(static_cast<const T14&>(msg)); break;
-          default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
-        }
-      }
-
-      //********************************************
-      template <typename T>
-      explicit message_packet(const T& msg)
-      {
-        ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value), "Unsupported type for this message packet");
-
-        void* p = data;
-        ::new (p) T(static_cast<const T&>(msg));
-      }
-
-      //********************************************
-      ~message_packet()
-      {
-        etl::imessage* pmsg = static_cast<etl::imessage*>(data);
-
-  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
-        pmsg->~imessage();
-  #else
-        size_t id = pmsg->message_id;
-
-        switch (id)
-        {
-          case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
-          case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
-          case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
-          case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
-          case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
-          case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
-          case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
-          case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
-          case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
-          case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
-          case T11::ID: static_cast<T11*>(pmsg)->~T11(); break;
-          case T12::ID: static_cast<T12*>(pmsg)->~T12(); break;
-          case T13::ID: static_cast<T13*>(pmsg)->~T13(); break;
-          case T14::ID: static_cast<T14*>(pmsg)->~T14(); break;
-          default: assert(false); break;
-        }
-  #endif
-      }
-
-      //********************************************
-      etl::imessage& get()
-      {
-        return *static_cast<etl::imessage*>(data);
-      }
-
-      //********************************************
-      const etl::imessage& get() const
-      {
-        return *static_cast<const etl::imessage*>(data);
-      }
-
-      enum
-      {
-        SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::size,
-        ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::alignment
-      };
-
-    private:
-
-      typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    };
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,  T14> message_packet;
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -847,99 +560,7 @@ namespace etl
   {
   public:
 
-    //**********************************************
-    class message_packet
-    {
-    public:
-
-      //********************************************
-      explicit message_packet(const etl::imessage& msg)
-      {
-        const size_t id = msg.message_id;
-
-        void* p = data;
-
-        switch (id)
-        {
-          case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
-          case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
-          case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
-          case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
-          case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
-          case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
-          case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
-          case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
-          case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
-          case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
-          case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
-          case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
-          case T13::ID: ::new (p) T13(static_cast<const T13&>(msg)); break;
-          default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
-        }
-      }
-
-      //********************************************
-      template <typename T>
-      explicit message_packet(const T& msg)
-      {
-        ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value), "Unsupported type for this message packet");
-
-        void* p = data;
-        ::new (p) T(static_cast<const T&>(msg));
-      }
-
-      //********************************************
-      ~message_packet()
-      {
-        etl::imessage* pmsg = static_cast<etl::imessage*>(data);
-
-  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
-        pmsg->~imessage();
-  #else
-        size_t id = pmsg->message_id;
-
-        switch (id)
-        {
-          case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
-          case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
-          case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
-          case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
-          case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
-          case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
-          case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
-          case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
-          case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
-          case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
-          case T11::ID: static_cast<T11*>(pmsg)->~T11(); break;
-          case T12::ID: static_cast<T12*>(pmsg)->~T12(); break;
-          case T13::ID: static_cast<T13*>(pmsg)->~T13(); break;
-          default: assert(false); break;
-        }
-  #endif
-      }
-
-      //********************************************
-      etl::imessage& get()
-      {
-        return *static_cast<etl::imessage*>(data);
-      }
-
-      //********************************************
-      const etl::imessage& get() const
-      {
-        return *static_cast<const etl::imessage*>(data);
-      }
-
-      enum
-      {
-        SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::size,
-        ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::alignment
-      };
-
-    private:
-
-      typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    };
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,  T13> message_packet;
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -1039,97 +660,7 @@ namespace etl
   {
   public:
 
-    //**********************************************
-    class message_packet
-    {
-    public:
-
-      //********************************************
-      explicit message_packet(const etl::imessage& msg)
-      {
-        const size_t id = msg.message_id;
-
-        void* p = data;
-
-        switch (id)
-        {
-          case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
-          case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
-          case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
-          case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
-          case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
-          case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
-          case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
-          case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
-          case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
-          case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
-          case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
-          case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
-          default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
-        }
-      }
-
-      //********************************************
-      template <typename T>
-      explicit message_packet(const T& msg)
-      {
-        ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value), "Unsupported type for this message packet");
-
-        void* p = data;
-        ::new (p) T(static_cast<const T&>(msg));
-      }
-
-      //********************************************
-      ~message_packet()
-      {
-        etl::imessage* pmsg = static_cast<etl::imessage*>(data);
-
-  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
-        pmsg->~imessage();
-  #else
-        size_t id = pmsg->message_id;
-
-        switch (id)
-        {
-          case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
-          case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
-          case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
-          case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
-          case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
-          case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
-          case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
-          case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
-          case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
-          case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
-          case T11::ID: static_cast<T11*>(pmsg)->~T11(); break;
-          case T12::ID: static_cast<T12*>(pmsg)->~T12(); break;
-          default: assert(false); break;
-        }
-  #endif
-      }
-
-      //********************************************
-      etl::imessage& get()
-      {
-        return *static_cast<etl::imessage*>(data);
-      }
-
-      //********************************************
-      const etl::imessage& get() const
-      {
-        return *static_cast<const etl::imessage*>(data);
-      }
-
-      enum
-      {
-        SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::size,
-        ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::alignment
-      };
-
-    private:
-
-      typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    };
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,  T12> message_packet;
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -1228,95 +759,7 @@ namespace etl
   {
   public:
 
-    //**********************************************
-    class message_packet
-    {
-    public:
-
-      //********************************************
-      explicit message_packet(const etl::imessage& msg)
-      {
-        const size_t id = msg.message_id;
-
-        void* p = data;
-
-        switch (id)
-        {
-          case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
-          case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
-          case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
-          case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
-          case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
-          case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
-          case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
-          case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
-          case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
-          case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
-          case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
-          default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
-        }
-      }
-
-      //********************************************
-      template <typename T>
-      explicit message_packet(const T& msg)
-      {
-        ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value), "Unsupported type for this message packet");
-
-        void* p = data;
-        ::new (p) T(static_cast<const T&>(msg));
-      }
-
-      //********************************************
-      ~message_packet()
-      {
-        etl::imessage* pmsg = static_cast<etl::imessage*>(data);
-
-  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
-        pmsg->~imessage();
-  #else
-        size_t id = pmsg->message_id;
-
-        switch (id)
-        {
-          case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
-          case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
-          case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
-          case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
-          case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
-          case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
-          case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
-          case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
-          case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
-          case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
-          case T11::ID: static_cast<T11*>(pmsg)->~T11(); break;
-          default: assert(false); break;
-        }
-  #endif
-      }
-
-      //********************************************
-      etl::imessage& get()
-      {
-        return *static_cast<etl::imessage*>(data);
-      }
-
-      //********************************************
-      const etl::imessage& get() const
-      {
-        return *static_cast<const etl::imessage*>(data);
-      }
-
-      enum
-      {
-        SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::size,
-        ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::alignment
-      };
-
-    private:
-
-      typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    };
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,  T11> message_packet;
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -1414,93 +857,7 @@ namespace etl
   {
   public:
 
-    //**********************************************
-    class message_packet
-    {
-    public:
-
-      //********************************************
-      explicit message_packet(const etl::imessage& msg)
-      {
-        const size_t id = msg.message_id;
-
-        void* p = data;
-
-        switch (id)
-        {
-          case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
-          case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
-          case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
-          case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
-          case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
-          case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
-          case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
-          case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
-          case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
-          case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
-          default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
-        }
-      }
-
-      //********************************************
-      template <typename T>
-      explicit message_packet(const T& msg)
-      {
-        ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value), "Unsupported type for this message packet");
-
-        void* p = data;
-        ::new (p) T(static_cast<const T&>(msg));
-      }
-
-      //********************************************
-      ~message_packet()
-      {
-        etl::imessage* pmsg = static_cast<etl::imessage*>(data);
-
-  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
-        pmsg->~imessage();
-  #else
-        size_t id = pmsg->message_id;
-
-        switch (id)
-        {
-          case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
-          case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
-          case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
-          case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
-          case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
-          case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
-          case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
-          case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
-          case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
-          case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
-          default: assert(false); break;
-        }
-  #endif
-      }
-
-      //********************************************
-      etl::imessage& get()
-      {
-        return *static_cast<etl::imessage*>(data);
-      }
-
-      //********************************************
-      const etl::imessage& get() const
-      {
-        return *static_cast<const etl::imessage*>(data);
-      }
-
-      enum
-      {
-        SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::size,
-        ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::alignment
-      };
-
-    private:
-
-      typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    };
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9,  T10> message_packet;
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -1597,91 +954,7 @@ namespace etl
   {
   public:
 
-    //**********************************************
-    class message_packet
-    {
-    public:
-
-      //********************************************
-      explicit message_packet(const etl::imessage& msg)
-      {
-        const size_t id = msg.message_id;
-
-        void* p = data;
-
-        switch (id)
-        {
-          case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
-          case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
-          case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
-          case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
-          case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
-          case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
-          case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
-          case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
-          case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
-          default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
-        }
-      }
-
-      //********************************************
-      template <typename T>
-      explicit message_packet(const T& msg)
-      {
-        ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7, T8, T9>::value), "Unsupported type for this message packet");
-
-        void* p = data;
-        ::new (p) T(static_cast<const T&>(msg));
-      }
-
-      //********************************************
-      ~message_packet()
-      {
-        etl::imessage* pmsg = static_cast<etl::imessage*>(data);
-
-  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
-        pmsg->~imessage();
-  #else
-        size_t id = pmsg->message_id;
-
-        switch (id)
-        {
-          case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
-          case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
-          case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
-          case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
-          case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
-          case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
-          case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
-          case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
-          case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
-          default: assert(false); break;
-        }
-  #endif
-      }
-
-      //********************************************
-      etl::imessage& get()
-      {
-        return *static_cast<etl::imessage*>(data);
-      }
-
-      //********************************************
-      const etl::imessage& get() const
-      {
-        return *static_cast<const etl::imessage*>(data);
-      }
-
-      enum
-      {
-        SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9>::size,
-        ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9>::alignment
-      };
-
-    private:
-
-      typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    };
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8,  T9> message_packet;
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -1776,89 +1049,7 @@ namespace etl
   {
   public:
 
-    //**********************************************
-    class message_packet
-    {
-    public:
-
-      //********************************************
-      explicit message_packet(const etl::imessage& msg)
-      {
-        const size_t id = msg.message_id;
-
-        void* p = data;
-
-        switch (id)
-        {
-          case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
-          case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
-          case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
-          case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
-          case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
-          case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
-          case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
-          case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
-          default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
-        }
-      }
-
-      //********************************************
-      template <typename T>
-      explicit message_packet(const T& msg)
-      {
-        ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7, T8>::value), "Unsupported type for this message packet");
-
-        void* p = data;
-        ::new (p) T(static_cast<const T&>(msg));
-      }
-
-      //********************************************
-      ~message_packet()
-      {
-        etl::imessage* pmsg = static_cast<etl::imessage*>(data);
-
-  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
-        pmsg->~imessage();
-  #else
-        size_t id = pmsg->message_id;
-
-        switch (id)
-        {
-          case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
-          case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
-          case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
-          case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
-          case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
-          case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
-          case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
-          case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
-          default: assert(false); break;
-        }
-  #endif
-      }
-
-      //********************************************
-      etl::imessage& get()
-      {
-        return *static_cast<etl::imessage*>(data);
-      }
-
-      //********************************************
-      const etl::imessage& get() const
-      {
-        return *static_cast<const etl::imessage*>(data);
-      }
-
-      enum
-      {
-        SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8>::size,
-        ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8>::alignment
-      };
-
-    private:
-
-      typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    };
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7,  T8> message_packet;
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -1952,87 +1143,7 @@ namespace etl
   {
   public:
 
-    //**********************************************
-    class message_packet
-    {
-    public:
-
-      //********************************************
-      explicit message_packet(const etl::imessage& msg)
-      {
-        const size_t id = msg.message_id;
-
-        void* p = data;
-
-        switch (id)
-        {
-          case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
-          case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
-          case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
-          case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
-          case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
-          case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
-          case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
-          default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
-        }
-      }
-
-      //********************************************
-      template <typename T>
-      explicit message_packet(const T& msg)
-      {
-        ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6, T7>::value), "Unsupported type for this message packet");
-
-        void* p = data;
-        ::new (p) T(static_cast<const T&>(msg));
-      }
-
-      //********************************************
-      ~message_packet()
-      {
-        etl::imessage* pmsg = static_cast<etl::imessage*>(data);
-
-  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
-        pmsg->~imessage();
-  #else
-        size_t id = pmsg->message_id;
-
-        switch (id)
-        {
-          case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
-          case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
-          case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
-          case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
-          case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
-          case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
-          case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
-          default: assert(false); break;
-        }
-  #endif
-      }
-
-      //********************************************
-      etl::imessage& get()
-      {
-        return *static_cast<etl::imessage*>(data);
-      }
-
-      //********************************************
-      const etl::imessage& get() const
-      {
-        return *static_cast<const etl::imessage*>(data);
-      }
-
-      enum
-      {
-        SIZE      = etl::largest<T1, T2, T3, T4, T5, T6, T7>::size,
-        ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7>::alignment
-      };
-
-    private:
-
-      typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    };
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6,  T7> message_packet;
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -2124,85 +1235,7 @@ namespace etl
   {
   public:
 
-    //**********************************************
-    class message_packet
-    {
-    public:
-
-      //********************************************
-      explicit message_packet(const etl::imessage& msg)
-      {
-        const size_t id = msg.message_id;
-
-        void* p = data;
-
-        switch (id)
-        {
-          case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
-          case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
-          case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
-          case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
-          case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
-          case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
-          default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
-        }
-      }
-
-      //********************************************
-      template <typename T>
-      explicit message_packet(const T& msg)
-      {
-        ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5, T6>::value), "Unsupported type for this message packet");
-
-        void* p = data;
-        ::new (p) T(static_cast<const T&>(msg));
-      }
-
-      //********************************************
-      ~message_packet()
-      {
-        etl::imessage* pmsg = static_cast<etl::imessage*>(data);
-
-  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
-        pmsg->~imessage();
-  #else
-        size_t id = pmsg->message_id;
-
-        switch (id)
-        {
-          case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
-          case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
-          case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
-          case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
-          case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
-          case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
-          default: assert(false); break;
-        }
-  #endif
-      }
-
-      //********************************************
-      etl::imessage& get()
-      {
-        return *static_cast<etl::imessage*>(data);
-      }
-
-      //********************************************
-      const etl::imessage& get() const
-      {
-        return *static_cast<const etl::imessage*>(data);
-      }
-
-      enum
-      {
-        SIZE      = etl::largest<T1, T2, T3, T4, T5, T6>::size,
-        ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6>::alignment
-      };
-
-    private:
-
-      typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    };
+    typedef etl::message_packet<T1, T2, T3, T4, T5,  T6> message_packet;
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -2293,83 +1326,7 @@ namespace etl
   {
   public:
 
-    //**********************************************
-    class message_packet
-    {
-    public:
-
-      //********************************************
-      explicit message_packet(const etl::imessage& msg)
-      {
-        const size_t id = msg.message_id;
-
-        void* p = data;
-
-        switch (id)
-        {
-          case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
-          case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
-          case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
-          case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
-          case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
-          default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
-        }
-      }
-
-      //********************************************
-      template <typename T>
-      explicit message_packet(const T& msg)
-      {
-        ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4, T5>::value), "Unsupported type for this message packet");
-
-        void* p = data;
-        ::new (p) T(static_cast<const T&>(msg));
-      }
-
-      //********************************************
-      ~message_packet()
-      {
-        etl::imessage* pmsg = static_cast<etl::imessage*>(data);
-
-  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
-        pmsg->~imessage();
-  #else
-        size_t id = pmsg->message_id;
-
-        switch (id)
-        {
-          case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
-          case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
-          case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
-          case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
-          case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
-          default: assert(false); break;
-        }
-  #endif
-      }
-
-      //********************************************
-      etl::imessage& get()
-      {
-        return *static_cast<etl::imessage*>(data);
-      }
-
-      //********************************************
-      const etl::imessage& get() const
-      {
-        return *static_cast<const etl::imessage*>(data);
-      }
-
-      enum
-      {
-        SIZE      = etl::largest<T1, T2, T3, T4, T5>::size,
-        ALIGNMENT = etl::largest<T1, T2, T3, T4, T5>::alignment
-      };
-
-    private:
-
-      typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    };
+    typedef etl::message_packet<T1, T2, T3, T4,  T5> message_packet;
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -2458,81 +1415,7 @@ namespace etl
   {
   public:
 
-    //**********************************************
-    class message_packet
-    {
-    public:
-
-      //********************************************
-      explicit message_packet(const etl::imessage& msg)
-      {
-        const size_t id = msg.message_id;
-
-        void* p = data;
-
-        switch (id)
-        {
-          case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
-          case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
-          case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
-          case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
-          default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
-        }
-      }
-
-      //********************************************
-      template <typename T>
-      explicit message_packet(const T& msg)
-      {
-        ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3, T4>::value), "Unsupported type for this message packet");
-
-        void* p = data;
-        ::new (p) T(static_cast<const T&>(msg));
-      }
-
-      //********************************************
-      ~message_packet()
-      {
-        etl::imessage* pmsg = static_cast<etl::imessage*>(data);
-
-  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
-        pmsg->~imessage();
-  #else
-        size_t id = pmsg->message_id;
-
-        switch (id)
-        {
-          case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
-          case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
-          case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
-          case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
-          default: assert(false); break;
-        }
-  #endif
-      }
-
-      //********************************************
-      etl::imessage& get()
-      {
-        return *static_cast<etl::imessage*>(data);
-      }
-
-      //********************************************
-      const etl::imessage& get() const
-      {
-        return *static_cast<const etl::imessage*>(data);
-      }
-
-      enum
-      {
-        SIZE      = etl::largest<T1, T2, T3, T4>::size,
-        ALIGNMENT = etl::largest<T1, T2, T3, T4>::alignment
-      };
-
-    private:
-
-      typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    };
+    typedef etl::message_packet<T1, T2, T3,  T4> message_packet;
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -2620,79 +1503,7 @@ namespace etl
   {
   public:
 
-    //**********************************************
-    class message_packet
-    {
-    public:
-
-      //********************************************
-      explicit message_packet(const etl::imessage& msg)
-      {
-        const size_t id = msg.message_id;
-
-        void* p = data;
-
-        switch (id)
-        {
-          case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
-          case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
-          case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
-          default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
-        }
-      }
-
-      //********************************************
-      template <typename T>
-      explicit message_packet(const T& msg)
-      {
-        ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2, T3>::value), "Unsupported type for this message packet");
-
-        void* p = data;
-        ::new (p) T(static_cast<const T&>(msg));
-      }
-
-      //********************************************
-      ~message_packet()
-      {
-        etl::imessage* pmsg = static_cast<etl::imessage*>(data);
-
-  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
-        pmsg->~imessage();
-  #else
-        size_t id = pmsg->message_id;
-
-        switch (id)
-        {
-          case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
-          case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
-          case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
-          default: assert(false); break;
-        }
-  #endif
-      }
-
-      //********************************************
-      etl::imessage& get()
-      {
-        return *static_cast<etl::imessage*>(data);
-      }
-
-      //********************************************
-      const etl::imessage& get() const
-      {
-        return *static_cast<const etl::imessage*>(data);
-      }
-
-      enum
-      {
-        SIZE      = etl::largest<T1, T2, T3>::size,
-        ALIGNMENT = etl::largest<T1, T2, T3>::alignment
-      };
-
-    private:
-
-      typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    };
+    typedef etl::message_packet<T1, T2,  T3> message_packet;
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -2779,77 +1590,7 @@ namespace etl
   {
   public:
 
-    //**********************************************
-    class message_packet
-    {
-    public:
-
-      //********************************************
-      explicit message_packet(const etl::imessage& msg)
-      {
-        const size_t id = msg.message_id;
-
-        void* p = data;
-
-        switch (id)
-        {
-          case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
-          case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
-          default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
-        }
-      }
-
-      //********************************************
-      template <typename T>
-      explicit message_packet(const T& msg)
-      {
-        ETL_STATIC_ASSERT((etl::is_one_of<T, T1, T2>::value), "Unsupported type for this message packet");
-
-        void* p = data;
-        ::new (p) T(static_cast<const T&>(msg));
-      }
-
-      //********************************************
-      ~message_packet()
-      {
-        etl::imessage* pmsg = static_cast<etl::imessage*>(data);
-
-  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
-        pmsg->~imessage();
-  #else
-        size_t id = pmsg->message_id;
-
-        switch (id)
-        {
-          case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
-          case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
-          default: assert(false); break;
-        }
-  #endif
-      }
-
-      //********************************************
-      etl::imessage& get()
-      {
-        return *static_cast<etl::imessage*>(data);
-      }
-
-      //********************************************
-      const etl::imessage& get() const
-      {
-        return *static_cast<const etl::imessage*>(data);
-      }
-
-      enum
-      {
-        SIZE      = etl::largest<T1, T2>::size,
-        ALIGNMENT = etl::largest<T1, T2>::alignment
-      };
-
-    private:
-
-      typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    };
+    typedef etl::message_packet<T1,  T2> message_packet;
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -2935,75 +1676,7 @@ namespace etl
   {
   public:
 
-    //**********************************************
-    class message_packet
-    {
-    public:
-
-      //********************************************
-      explicit message_packet(const etl::imessage& msg)
-      {
-        const size_t id = msg.message_id;
-
-        void* p = data;
-
-        switch (id)
-        {
-          case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
-          default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
-        }
-      }
-
-      //********************************************
-      template <typename T>
-      explicit message_packet(const T& msg)
-      {
-        ETL_STATIC_ASSERT((etl::is_one_of<T, T1>::value), "Unsupported type for this message packet");
-
-        void* p = data;
-        ::new (p) T(static_cast<const T&>(msg));
-      }
-
-      //********************************************
-      ~message_packet()
-      {
-        etl::imessage* pmsg = static_cast<etl::imessage*>(data);
-
-  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
-        pmsg->~imessage();
-  #else
-        size_t id = pmsg->message_id;
-
-        switch (id)
-        {
-          case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
-          default: assert(false); break;
-        }
-  #endif
-      }
-
-      //********************************************
-      etl::imessage& get()
-      {
-        return *static_cast<etl::imessage*>(data);
-      }
-
-      //********************************************
-      const etl::imessage& get() const
-      {
-        return *static_cast<const etl::imessage*>(data);
-      }
-
-      enum
-      {
-        SIZE      = etl::largest<T1>::size,
-        ALIGNMENT = etl::largest<T1>::alignment
-      };
-
-    private:
-
-      typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    };
+    typedef etl::message_packet< T1> message_packet;
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
diff --git a/include/etl/message_router_generator.h b/include/etl/message_router_generator.h
index 8049b5e1..61951531 100644
--- a/include/etl/message_router_generator.h
+++ b/include/etl/message_router_generator.h
@@ -68,6 +68,7 @@ cog.outl("//********************************************************************
 
 #include "platform.h"
 #include "message.h"
+#include "message_packet.h"
 #include "message_types.h"
 #include "alignment.h"
 #include "error_handler.h"
@@ -272,89 +273,10 @@ namespace etl
       cog.outl("{")
       cog.outl("public:")
       cog.outl("")
-      cog.outl("  //**********************************************")
-      cog.outl("  class message_packet")
-      cog.outl("  {")
-      cog.outl("  public:")
-      cog.outl("")
-      cog.outl("    //********************************************")
-      cog.outl("    explicit message_packet(const etl::imessage& msg)")
-      cog.outl("    {")
-      cog.outl("      const size_t id = msg.message_id;")
-      cog.outl("")
-      cog.outl("      void* p = data;")
-      cog.outl("")
-      cog.outl("      switch (id)")
-      cog.outl("      {")
-      for n in range(1, int(Handlers) + 1):
-          cog.outl("        case T%s::ID: ::new (p) T%s(static_cast<const T%s&>(msg)); break;" % (n, n, n))
-      cog.outl("        default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;")
-      cog.outl("      }")
-      cog.outl("    }")
-      cog.outl("")
-      cog.outl("    //********************************************")
-      cog.outl("    template <typename T>")
-      cog.outl("    explicit message_packet(const T& msg)")
-      cog.outl("    {")
-      cog.out("      ETL_STATIC_ASSERT((etl::is_one_of<T, ")
+      cog.out("  typedef etl::message_packet<")
       for n in range(1, int(Handlers)):
           cog.out("T%s, " % n)
-          if n % 16 == 0:
-              cog.outl("")
-              cog.out("                                       ")
-      cog.outl("""T%s>::value), "Unsupported type for this message packet");""" % int(Handlers))
-      cog.outl("")
-      cog.outl("      void* p = data;")
-      cog.outl("      ::new (p) T(static_cast<const T&>(msg));")
-      cog.outl("    }")
-      cog.outl("")
-      cog.outl("    //********************************************")
-      cog.outl("    ~message_packet()")
-      cog.outl("    {")
-      cog.outl("      etl::imessage* pmsg = static_cast<etl::imessage*>(data);")
-      cog.outl("")
-      cog.outl("#if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)")
-      cog.outl("      pmsg->~imessage();")
-      cog.outl("#else")
-      cog.outl("      size_t id = pmsg->message_id;")
-      cog.outl("")
-      cog.outl("      switch (id)")
-      cog.outl("      {")
-      for n in range(1, int(Handlers) + 1):
-          cog.outl("        case T%s::ID: static_cast<T%s*>(pmsg)->~T%s(); break;" % (n, n, n))
-      cog.outl("        default: assert(false); break;")
-      cog.outl("      }")
-      cog.outl("#endif")
-      cog.outl("    }")
-      cog.outl("")
-      cog.outl("    //********************************************")
-      cog.outl("    etl::imessage& get()")
-      cog.outl("    {")
-      cog.outl("      return *static_cast<etl::imessage*>(data);")
-      cog.outl("    }")
-      cog.outl("")
-      cog.outl("    //********************************************")
-      cog.outl("    const etl::imessage& get() const")
-      cog.outl("    {")
-      cog.outl("      return *static_cast<const etl::imessage*>(data);")
-      cog.outl("    }")
-      cog.outl("")
-      cog.outl("    enum")
-      cog.outl("    {")
-      cog.out("      SIZE      = etl::largest<")
-      for n in range(1, int(Handlers)):
-          cog.out("T%s, " % n)
-      cog.outl("T%s>::size," % int(Handlers))
-      cog.out("      ALIGNMENT = etl::largest<")
-      for n in range(1, int(Handlers)):
-          cog.out("T%s, " % n)
-      cog.outl("T%s>::alignment" % int(Handlers))
-      cog.outl("    };")
-      cog.outl("")
-      cog.outl("  private:")
-      cog.outl("")
-      cog.outl("    typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;")
-      cog.outl("  };")
+      cog.outl(" T%s> message_packet;" % int(Handlers))
       cog.outl("")
       cog.outl("  //**********************************************")
       cog.outl("  message_router(etl::message_router_id_t id_)")
@@ -472,89 +394,10 @@ namespace etl
           cog.outl("{")
           cog.outl("public:")
           cog.outl("")
-          cog.outl("  //**********************************************")
-          cog.outl("  class message_packet")
-          cog.outl("  {")
-          cog.outl("  public:")
-          cog.outl("")
-          cog.outl("    //********************************************")
-          cog.outl("    explicit message_packet(const etl::imessage& msg)")
-          cog.outl("    {")
-          cog.outl("      const size_t id = msg.message_id;")
-          cog.outl("")
-          cog.outl("      void* p = data;")
-          cog.outl("")
-          cog.outl("      switch (id)")
-          cog.outl("      {")
-          for t in range(1, n + 1):
-              cog.outl("        case T%s::ID: ::new (p) T%s(static_cast<const T%s&>(msg)); break;" % (t, t, t))
-          cog.outl("        default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;")
-          cog.outl("      }")
-          cog.outl("    }")
-          cog.outl("")
-          cog.outl("    //********************************************")
-          cog.outl("    template <typename T>")
-          cog.outl("    explicit message_packet(const T& msg)")
-          cog.outl("    {")
-          cog.out("      ETL_STATIC_ASSERT((etl::is_one_of<T, ")
+          cog.out("  typedef etl::message_packet<")
           for t in range(1, n):
               cog.out("T%s, " % t)
-              if t % 16 == 0:
-                  cog.outl("")
-                  cog.out("                                       ")
-          cog.outl("""T%s>::value), "Unsupported type for this message packet");""" % n)
-          cog.outl("")
-          cog.outl("      void* p = data;")
-          cog.outl("      ::new (p) T(static_cast<const T&>(msg));")
-          cog.outl("    }")
-          cog.outl("")
-          cog.outl("    //********************************************")
-          cog.outl("    ~message_packet()")
-          cog.outl("    {")
-          cog.outl("      etl::imessage* pmsg = static_cast<etl::imessage*>(data);")
-          cog.outl("")
-          cog.outl("#if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)")
-          cog.outl("      pmsg->~imessage();")
-          cog.outl("#else")
-          cog.outl("      size_t id = pmsg->message_id;")
-          cog.outl("")
-          cog.outl("      switch (id)")
-          cog.outl("      {")
-          for t in range(1, n + 1):
-              cog.outl("        case T%s::ID: static_cast<T%s*>(pmsg)->~T%s(); break;" % (t, t, t))
-          cog.outl("        default: assert(false); break;")
-          cog.outl("      }")
-          cog.outl("#endif")
-          cog.outl("    }")
-          cog.outl("")
-          cog.outl("    //********************************************")
-          cog.outl("    etl::imessage& get()")
-          cog.outl("    {")
-          cog.outl("      return *static_cast<etl::imessage*>(data);")
-          cog.outl("    }")
-          cog.outl("")
-          cog.outl("    //********************************************")
-          cog.outl("    const etl::imessage& get() const")
-          cog.outl("    {")
-          cog.outl("      return *static_cast<const etl::imessage*>(data);")
-          cog.outl("    }")
-          cog.outl("")
-          cog.outl("    enum")
-          cog.outl("    {")
-          cog.out("      SIZE      = etl::largest<")
-          for t in range(1, n):
-              cog.out("T%s, " % t)
-          cog.outl("T%s>::size," % n)
-          cog.out("      ALIGNMENT = etl::largest<")
-          for t in range(1, n):
-              cog.out("T%s, " % t)
-          cog.outl("T%s>::alignment" % n)
-          cog.outl("    };")
-          cog.outl("")
-          cog.outl("  private:")
-          cog.outl("")
-          cog.outl("    typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;")
-          cog.outl("  };")
+          cog.outl(" T%s> message_packet;" % n)
           cog.outl("")
           cog.outl("  //**********************************************")
           cog.outl("  message_router(etl::message_router_id_t id_)")
diff --git a/include/etl/platform.h b/include/etl/platform.h
index a00a434a..a556338b 100644
--- a/include/etl/platform.h
+++ b/include/etl/platform.h
@@ -72,6 +72,7 @@ SOFTWARE.
   #define ETL_CONST_OR_CONSTEXPR constexpr
   #define ETL_DELETE    = delete
   #define ETL_EXPLICIT explicit
+  #define ETL_OVERRIDE override
   #if defined(ETL_EXCEPTIONS_DISABLED)
     #define ETL_NOEXCEPT
     #define ETL_NOEXCEPT_EXPR(expression)
@@ -84,6 +85,7 @@ SOFTWARE.
   #define ETL_CONST_OR_CONSTEXPR const
   #define ETL_DELETE
   #define ETL_EXPLICIT
+  #define ETL_OVERRIDE
   #define ETL_NOEXCEPT
   #define ETL_NOEXCEPT_EXPR(expression)
 #endif
diff --git a/include/etl/version.h b/include/etl/version.h
index 83d8d60f..ae06c800 100644
--- a/include/etl/version.h
+++ b/include/etl/version.h
@@ -38,8 +38,8 @@ SOFTWARE.
 ///\ingroup utilities
 
 #define ETL_VERSION_MAJOR 16
-#define ETL_VERSION_MINOR  7
-#define ETL_VERSION_PATCH  1
+#define ETL_VERSION_MINOR  8
+#define ETL_VERSION_PATCH  0
 #define ETL_VERSION       ETL_STRINGIFY(ETL_VERSION_MAJOR) "." ETL_STRINGIFY(ETL_VERSION_MINOR) "." ETL_STRINGIFY(ETL_VERSION_PATCH)
 #define ETL_VERSION_W     ETL_STRINGIFY(ETL_VERSION_MAJOR) L"." ETL_STRINGIFY(ETL_VERSION_MINOR) L"." ETL_STRINGIFY(ETL_VERSION_PATCH)
 #define ETL_VERSION_U16   ETL_STRINGIFY(ETL_VERSION_MAJOR) u"." ETL_STRINGIFY(ETL_VERSION_MINOR) u"." ETL_STRINGIFY(ETL_VERSION_PATCH)
diff --git a/library.json b/library.json
index d9f6e5e7..75b96331 100644
--- a/library.json
+++ b/library.json
@@ -1,6 +1,6 @@
 {
   "name": "Embedded Template Library",
-  "version": "16.7.1",
+  "version": "16.8.0",
   "authors": {
     "name": "John Wellbelove",
     "email": "john.wellbelove@etlcpp.com"
diff --git a/library.properties b/library.properties
index f1379e04..b554dfd3 100644
--- a/library.properties
+++ b/library.properties
@@ -1,5 +1,5 @@
 name=Embedded Template Library
-version=16.7.1
+version=16.8.0
 author= John Wellbelove <john.wellbelove@etlcpp.com>
 maintainer=John Wellbelove <john.wellbelove@etlcpp.com>
 license=MIT
diff --git a/support/Release notes.txt b/support/Release notes.txt
index 82f88819..d971f82e 100644
--- a/support/Release notes.txt	
+++ b/support/Release notes.txt	
@@ -1,3 +1,7 @@
+===============================================================================
+16.8.0
+Extracted message_packet from etl::message_router for use as an independant class.
+
 ===============================================================================
 16.7.1
 Fix C++03 compatibility issues in memory.h and utility.h
diff --git a/test/test_message_packet.cpp b/test/test_message_packet.cpp
new file mode 100644
index 00000000..a107098a
--- /dev/null
+++ b/test/test_message_packet.cpp
@@ -0,0 +1,158 @@
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+http://www.etlcpp.com
+
+Copyright(c) 2020 jwellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+#include "UnitTest++/UnitTest++.h"
+#include "ExtraCheckMacros.h"
+
+#include "etl/message_packet.h"
+
+#include <string>
+
+//***************************************************************************
+// The set of messages.
+//***************************************************************************
+namespace
+{
+  enum
+  {
+    MESSAGE1,
+    MESSAGE2,
+    MESSAGE3,
+    MESSAGE4
+  };
+
+  struct Message1 : public etl::message<MESSAGE1>
+  {
+    Message1(int x_)
+      : x(x_)
+    {
+    }
+
+    int x;
+  };
+
+  struct Message2 : public etl::message<MESSAGE2>
+  {
+    Message2(double x_)
+      : x(x_)
+    {
+    }
+
+    double x;
+  };
+
+  struct Message3 : public etl::message<MESSAGE3>
+  {
+    Message3(std::string x_)
+      : x(x_)
+    {
+    }
+
+    std::string x;
+  };
+
+  struct Message4 : public etl::message<MESSAGE4>
+  {
+  };
+
+  using Packet = etl::message_packet<Message1, Message2, Message3>;
+
+  SUITE(test_message_packet)
+  {
+    //*************************************************************************
+    TEST(message_packet_construction)
+    {
+      Message1 message1(1);
+      Message2 message2(2.2);
+      Message3 message3("3");
+      Message4 message4;
+
+      Packet packet1(message1);
+      Packet packet2(message2);
+      Packet packet3(message3);
+
+      // The next line should result in a compile error.
+      //Packet packet4(message4);
+
+      CHECK_EQUAL(MESSAGE1, packet1.get().message_id);
+      CHECK_EQUAL(MESSAGE2, packet2.get().message_id);
+      CHECK_EQUAL(MESSAGE3, packet3.get().message_id);
+
+      CHECK_EQUAL(1,   static_cast<Message1&>(packet1.get()).x);
+      CHECK_EQUAL(2.2, static_cast<Message2&>(packet2.get()).x);
+      CHECK_EQUAL("3", static_cast<Message3&>(packet3.get()).x);
+    }
+
+    //*************************************************************************
+    TEST(message_constant_packet_construction)
+    {
+      Message1 message1(1);
+      Message2 message2(2.2);
+      Message3 message3("3");
+      Message4 message4;
+
+      const Packet packet1(message1);
+      const Packet packet2(message2);
+      const Packet packet3(message3);
+
+      // The next line should result in a compile error.
+      //Packet packet4(message4);
+
+      CHECK_EQUAL(MESSAGE1, packet1.get().message_id);
+      CHECK_EQUAL(MESSAGE2, packet2.get().message_id);
+      CHECK_EQUAL(MESSAGE3, packet3.get().message_id);
+
+      CHECK_EQUAL(1,   static_cast<const Message1&>(packet1.get()).x);
+      CHECK_EQUAL(2.2, static_cast<const Message2&>(packet2.get()).x);
+      CHECK_EQUAL("3", static_cast<const Message3&>(packet3.get()).x);
+    }
+
+    //*************************************************************************
+    TEST(message_packet_construction_from_base)
+    {
+      Message1 message1(1);
+      Message2 message2(2.2);
+      Message3 message3("3");
+      Message4 message4;
+
+      Packet packet1(static_cast<etl::imessage&>(message1));
+      Packet packet2(static_cast<etl::imessage&>(message2));
+      Packet packet3(static_cast<etl::imessage&>(message3));
+
+      CHECK_THROW(Packet packet4(static_cast<etl::imessage&>(message4)), etl::unhandled_message_exception);
+
+      CHECK_EQUAL(MESSAGE1, packet1.get().message_id);
+      CHECK_EQUAL(MESSAGE2, packet2.get().message_id);
+      CHECK_EQUAL(MESSAGE3, packet3.get().message_id);
+
+      CHECK_EQUAL(1,   static_cast<Message1&>(packet1.get()).x);
+      CHECK_EQUAL(2.2, static_cast<Message2&>(packet2.get()).x);
+      CHECK_EQUAL("3", static_cast<Message3&>(packet3.get()).x);
+    }
+  };
+}
diff --git a/test/test_message_router.cpp b/test/test_message_router.cpp
index f1fe6113..5b2d1b94 100644
--- a/test/test_message_router.cpp
+++ b/test/test_message_router.cpp
@@ -32,7 +32,6 @@ SOFTWARE.
 #include "etl/message_router.h"
 #include "etl/queue.h"
 #include "etl/largest.h"
-#include "etl/packet.h"
 
 //***************************************************************************
 // The set of messages.
diff --git a/test/vs2017/etl.vcxproj b/test/vs2017/etl.vcxproj
index 19b622de..6b0c44fa 100644
--- a/test/vs2017/etl.vcxproj
+++ b/test/vs2017/etl.vcxproj
@@ -888,6 +888,9 @@
     <ClInclude Include="..\..\include\etl\absolute.h" />
     <ClInclude Include="..\..\include\etl\limits.h" />
     <ClInclude Include="..\..\include\etl\macros.h" />
+    <ClInclude Include="..\..\include\etl\message_packet temp.h" />
+    <ClInclude Include="..\..\include\etl\message_packet.h" />
+    <ClInclude Include="..\..\include\etl\message_packet_generator.h" />
     <ClInclude Include="..\..\include\etl\multi_array.h" />
     <ClInclude Include="..\..\include\etl\mutex\mutex_freertos.h" />
     <ClInclude Include="..\..\include\etl\negative.h" />
@@ -1106,6 +1109,7 @@
     <ClCompile Include="..\test_limits.cpp" />
     <ClCompile Include="..\test_list_shared_pool.cpp" />
     <ClCompile Include="..\test_make_string.cpp" />
+    <ClCompile Include="..\test_message_packet.cpp" />
     <ClCompile Include="..\test_multi_array.cpp" />
     <ClCompile Include="..\test_array.cpp">
       <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../../unittest-cpp</AdditionalIncludeDirectories>
@@ -1442,6 +1446,7 @@
   <ItemGroup>
     <None Include="..\..\etl.pspimage" />
     <None Include="..\..\etl.xar" />
+    <None Include="..\..\include\etl\generate_message_packet.bat" />
     <None Include="..\..\include\etl\generate_type_select.bat" />
     <None Include="..\..\library.json" />
     <None Include="..\..\library.properties" />
diff --git a/test/vs2017/etl.vcxproj.filters b/test/vs2017/etl.vcxproj.filters
index 06cd6e63..bde4af08 100644
--- a/test/vs2017/etl.vcxproj.filters
+++ b/test/vs2017/etl.vcxproj.filters
@@ -822,6 +822,15 @@
     <ClInclude Include="..\..\include\etl\mutex\mutex_freertos.h">
       <Filter>ETL\Utilities\Mutex</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\include\etl\message_packet_generator.h">
+      <Filter>ETL\Frameworks\Generators</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\etl\message_packet temp.h">
+      <Filter>ETL\Frameworks</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\etl\message_packet.h">
+      <Filter>ETL\Frameworks</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\main.cpp">
@@ -1277,6 +1286,9 @@
     <ClCompile Include="..\test_parity_checksum.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="..\test_message_packet.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <None Include="..\..\library.properties">
@@ -1324,6 +1336,9 @@
     <None Include="cpp.hint">
       <Filter>Resource Files</Filter>
     </None>
+    <None Include="..\..\include\etl\generate_message_packet.bat">
+      <Filter>Resource Files\Generators</Filter>
+    </None>
   </ItemGroup>
   <ItemGroup>
     <Text Include="..\..\include\etl\file_error_numbers.txt">