diff --git a/include/etl/fsm.h b/include/etl/fsm.h
index 36130a47..05b5259f 100644
--- a/include/etl/fsm.h
+++ b/include/etl/fsm.h
@@ -27,7 +27,7 @@ SOFTWARE.
 ******************************************************************************/
 
 #if 0
-#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+  #error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
 #endif
 
 //***************************************************************************
@@ -49,24 +49,24 @@ SOFTWARE.
 //***************************************************************************
 
 #ifndef ETL_FSM_INCLUDED
-#define ETL_FSM_INCLUDED
+  #define ETL_FSM_INCLUDED
 
-#include "platform.h"
-#include "array.h"
-#include "nullptr.h"
-#include "error_handler.h"
-#include "exception.h"
-#include "user_type.h"
-#include "message_router.h"
-#include "integral_limits.h"
-#include "largest.h"
-#if ETL_USING_CPP11
-  #include "tuple.h"
-#endif
+  #include "platform.h"
+  #include "array.h"
+  #include "error_handler.h"
+  #include "exception.h"
+  #include "integral_limits.h"
+  #include "largest.h"
+  #include "message_router.h"
+  #include "nullptr.h"
+  #include "user_type.h"
+  #if ETL_USING_CPP11
+    #include "tuple.h"
+  #endif
 
-#include <stdint.h>
+  #include <stdint.h>
 
-#include "private/minmax_push.h"
+  #include "private/minmax_push.h"
 
 namespace etl
 {
@@ -74,26 +74,26 @@ namespace etl
   class hfsm;
 
   /// Allow alternative type for state id.
-#if !defined(ETL_FSM_STATE_ID_TYPE)
+  #if !defined(ETL_FSM_STATE_ID_TYPE)
   typedef uint_least8_t fsm_state_id_t;
-#else
+  #else
   typedef ETL_FSM_STATE_ID_TYPE fsm_state_id_t;
-#endif
+  #endif
 
   // For internal FSM use.
   typedef typename etl::larger_type<etl::message_id_t>::type fsm_internal_id_t;
 
-#if ETL_USING_CPP17 && !defined(ETL_FSM_FORCE_CPP03_IMPLEMENTATION) // For C++17 and above
+  #if ETL_USING_CPP17 && !defined(ETL_FSM_FORCE_CPP03_IMPLEMENTATION) // For C++17 and above
   template <typename, typename, etl::fsm_state_id_t, typename...>
   class fsm_state;
-#else
+  #else
   template <typename, typename, etl::fsm_state_id_t,
-            typename, typename, typename, typename, 
-            typename, typename, typename, typename, 
-            typename, typename, typename, typename, 
+            typename, typename, typename, typename,
+            typename, typename, typename, typename,
+            typename, typename, typename, typename,
             typename, typename, typename, typename>
   class fsm_state;
-#endif
+  #endif
 
   //***************************************************************************
   /// Base exception class for FSM.
@@ -166,6 +166,7 @@ namespace etl
   class fsm_not_started : public etl::fsm_exception
   {
   public:
+
     fsm_not_started(string_type file_name_, numeric_type line_number_)
       : etl::fsm_exception(ETL_ERROR_TEXT("fsm:not started", ETL_FSM_FILE_ID"F"), file_name_, line_number_)
     {
@@ -179,6 +180,7 @@ namespace etl
   class fsm_reentrant_transition_forbidden : public etl::fsm_exception
   {
   public:
+
     fsm_reentrant_transition_forbidden(string_type file_name_, numeric_type line_number_)
       : etl::fsm_exception(ETL_ERROR_TEXT("fsm:reentrant calls to start/receive/etc. forbidden", ETL_FSM_FILE_ID"G"), file_name_, line_number_)
     {
@@ -195,7 +197,7 @@ namespace etl
       // Pass this whenever no state change is desired.
       // The highest unsigned value of fsm_state_id_t.
       static ETL_CONSTANT fsm_state_id_t No_State_Change = etl::integral_limits<fsm_state_id_t>::max;
-      
+
       // Pass this when this event also needs to be passed to the parent.
       static ETL_CONSTANT fsm_state_id_t Pass_To_Parent = No_State_Change - 1U;
 
@@ -213,15 +215,16 @@ namespace etl
     ETL_CONSTANT fsm_state_id_t ifsm_state_helper<T>::Self_Transition;
 
     // Compile-time: TState::ID must equal its index in the type list (0..N-1)
-    template <size_t Id, typename...> struct check_ids : etl::true_type 
+    template <size_t Id, typename...>
+    struct check_ids : etl::true_type
     {
     };
 
     template <size_t Id, typename TState0, typename... TRest>
     struct check_ids<Id, TState0, TRest...>
-      : etl::integral_constant<bool, (TState0::STATE_ID == Id) && private_fsm::check_ids<Id + 1, TRest...>::value> 
+      : etl::integral_constant<bool, (TState0::STATE_ID == Id) && private_fsm::check_ids<Id + 1, TRest...>::value>
     {
-    };   
+    };
 
     //***************************************************************************
     /// RAII detection mechanism to catch reentrant calls to methods that might
@@ -231,6 +234,7 @@ namespace etl
     class fsm_reentrancy_guard
     {
     public:
+
       //*******************************************
       /// Constructor.
       /// Checks if another method has locked reentrancy.
@@ -250,29 +254,30 @@ namespace etl
       {
         is_locked = false;
       }
-      
+
     private:
+
       // Reference to the flag signifying a lock on the state machine.
       bool& is_locked;
-      
+
       // Copy & move semantics disabled since this is a guard.
       fsm_reentrancy_guard(fsm_reentrancy_guard const&) ETL_DELETE;
-      fsm_reentrancy_guard& operator= (fsm_reentrancy_guard const&) ETL_DELETE;
-#if ETL_USING_CPP11
+      fsm_reentrancy_guard& operator=(fsm_reentrancy_guard const&) ETL_DELETE;
+  #if ETL_USING_CPP11
       fsm_reentrancy_guard(fsm_reentrancy_guard&&) ETL_DELETE;
-      fsm_reentrancy_guard& operator= (fsm_reentrancy_guard&&) ETL_DELETE;
-#endif
+      fsm_reentrancy_guard& operator=(fsm_reentrancy_guard&&) ETL_DELETE;
+  #endif
     };
-  }
+  } // namespace private_fsm
 
   class ifsm_state;
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //***************************************************************************
   /// A class to store FSM states.
   //***************************************************************************
   template <typename... TStates>
-  class fsm_state_pack 
+  class fsm_state_pack
   {
   public:
 
@@ -294,18 +299,18 @@ namespace etl
     /// Gets a reference to the state.
     //*********************************
     template <typename TState>
-    TState& get() 
-    { 
-      return etl::get<TState>(storage); 
+    TState& get()
+    {
+      return etl::get<TState>(storage);
     }
 
     //*********************************
     /// Gets a const reference to the state.
     //*********************************
     template <typename TState>
-    const TState& get() const 
-    { 
-      return etl::get<TState>(storage); 
+    const TState& get() const
+    {
+      return etl::get<TState>(storage);
     }
 
   private:
@@ -322,9 +327,9 @@ namespace etl
     etl::tuple<TStates...> storage{};
 
     /// Pointers to the states.
-    etl::ifsm_state* states[sizeof...(TStates)]{ &etl::get<TStates>(storage)... };
+    etl::ifsm_state* states[sizeof...(TStates)]{&etl::get<TStates>(storage)...};
   };
-#endif
+  #endif
 
   //***************************************************************************
   /// Interface class for FSM states.
@@ -341,17 +346,17 @@ namespace etl
     using private_fsm::ifsm_state_helper<>::Pass_To_Parent;
     using private_fsm::ifsm_state_helper<>::Self_Transition;
 
-#if ETL_USING_CPP17 && !defined(ETL_FSM_FORCE_CPP03_IMPLEMENTATION) // For C++17 and above
+  #if ETL_USING_CPP17 && !defined(ETL_FSM_FORCE_CPP03_IMPLEMENTATION) // For C++17 and above
     template <typename, typename, etl::fsm_state_id_t, typename...>
     friend class fsm_state;
-#else
+  #else
     template <typename, typename, etl::fsm_state_id_t,
-              typename, typename, typename, typename, 
-              typename, typename, typename, typename, 
-              typename, typename, typename, typename, 
+              typename, typename, typename, typename,
+              typename, typename, typename, typename,
+              typename, typename, typename, typename,
               typename, typename, typename, typename>
     friend class etl::fsm_state;
-#endif
+  #endif
 
     //*******************************************
     /// Gets the id for this state.
@@ -383,7 +388,7 @@ namespace etl
     template <typename TSize>
     void set_child_states(etl::ifsm_state** state_list, TSize size)
     {
-      p_active_child = ETL_NULLPTR;
+      p_active_child  = ETL_NULLPTR;
       p_default_child = ETL_NULLPTR;
 
       for (TSize i = 0; i < size; ++i)
@@ -399,11 +404,11 @@ namespace etl
     /// Constructor.
     //*******************************************
     ifsm_state(etl::fsm_state_id_t state_id_)
-      : state_id(state_id_),
-      p_context(ETL_NULLPTR),
-      p_parent(ETL_NULLPTR),
-      p_active_child(ETL_NULLPTR),
-      p_default_child(ETL_NULLPTR)
+      : state_id(state_id_)
+      , p_context(ETL_NULLPTR)
+      , p_parent(ETL_NULLPTR)
+      , p_active_child(ETL_NULLPTR)
+      , p_default_child(ETL_NULLPTR)
     {
     }
 
@@ -424,8 +429,11 @@ namespace etl
 
     virtual fsm_state_id_t process_event(const etl::imessage& message) = 0;
 
-    virtual fsm_state_id_t on_enter_state() { return No_State_Change; } // By default, do nothing.
-    virtual void on_exit_state() {}  // By default, do nothing.
+    virtual fsm_state_id_t on_enter_state()
+    {
+      return No_State_Change;
+    } // By default, do nothing.
+    virtual void on_exit_state() {} // By default, do nothing.
 
     //*******************************************
     void set_fsm_context(etl::fsm& context)
@@ -450,7 +458,7 @@ namespace etl
 
     // Disabled.
     ifsm_state(const ifsm_state&) ETL_DELETE;
-    ifsm_state& operator =(const ifsm_state&) ETL_DELETE;
+    ifsm_state& operator=(const ifsm_state&) ETL_DELETE;
   };
 
   //***************************************************************************
@@ -482,7 +490,7 @@ namespace etl
     template <typename TSize>
     void set_states(etl::ifsm_state** p_states, TSize size)
     {
-      state_list = p_states;
+      state_list       = p_states;
       number_of_states = etl::fsm_state_id_t(size);
 
       ETL_ASSERT(number_of_states > 0, ETL_ERROR(etl::fsm_state_list_exception));
@@ -496,7 +504,7 @@ namespace etl
       }
     }
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
     //*******************************************
     /// Set the states for the FSM
     /// From an etl::fsm_state_pack.
@@ -504,7 +512,7 @@ namespace etl
     template <typename... TStates>
     void set_states(etl::fsm_state_pack<TStates...>& state_pack)
     {
-      state_list = state_pack.get_state_list();
+      state_list       = state_pack.get_state_list();
       number_of_states = etl::fsm_state_id_t(state_pack.size());
 
       for (etl::fsm_state_id_t i = 0; i < number_of_states; ++i)
@@ -512,7 +520,7 @@ namespace etl
         state_list[i]->set_fsm_context(*this);
       }
     }
-#endif
+  #endif
 
     //*******************************************
     /// Starts the FSM.
@@ -533,11 +541,11 @@ namespace etl
         if (call_on_enter_state)
         {
           etl::fsm_state_id_t next_state_id;
-          etl::ifsm_state* p_last_state;
+          etl::ifsm_state*    p_last_state;
 
           do
           {
-            p_last_state = p_state;
+            p_last_state  = p_state;
             next_state_id = p_state->on_enter_state();
             if (next_state_id != ifsm_state::No_State_Change)
             {
@@ -560,7 +568,7 @@ namespace etl
       {
         etl::fsm_state_id_t next_state_id = p_state->process_event(message);
 
-        process_state_change(next_state_id); 
+        process_state_change(next_state_id);
       }
       else
       {
@@ -670,9 +678,7 @@ namespace etl
     //********************************************
     bool have_changed_state(etl::fsm_state_id_t next_state_id) const
     {
-      return (next_state_id != p_state->get_state_id()) &&
-             (next_state_id != ifsm_state::No_State_Change) &&
-             (next_state_id != ifsm_state::Self_Transition);
+      return (next_state_id != p_state->get_state_id()) && (next_state_id != ifsm_state::No_State_Change) && (next_state_id != ifsm_state::Self_Transition);
     }
 
     //********************************************
@@ -691,7 +697,7 @@ namespace etl
         p_state->on_exit_state();
         next_state_id = p_state->on_enter_state();
       }
-      
+
       if (have_changed_state(next_state_id))
       {
         ETL_ASSERT_OR_RETURN_VALUE(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception), p_state->get_state_id());
@@ -715,16 +721,16 @@ namespace etl
       return p_state->get_state_id();
     }
 
-    etl::ifsm_state*    p_state;          ///< A pointer to the current state.
-    etl::ifsm_state**   state_list;       ///< The list of added states.
-    etl::fsm_state_id_t number_of_states; ///< The number of states.
-    bool is_processing_state_change;      ///< Whether a method call that could potentially trigger a state change is active
+    etl::ifsm_state*    p_state;                    ///< A pointer to the current state.
+    etl::ifsm_state**   state_list;                 ///< The list of added states.
+    etl::fsm_state_id_t number_of_states;           ///< The number of states.
+    bool                is_processing_state_change; ///< Whether a method call that could potentially trigger a state change is active
   };
 
   //*************************************************************************************************
   // For C++17 and above.
   //*************************************************************************************************
-#if ETL_USING_CPP17 && !defined(ETL_FSM_FORCE_CPP03_IMPLEMENTATION) // For C++17 and above
+  #if ETL_USING_CPP17 && !defined(ETL_FSM_FORCE_CPP03_IMPLEMENTATION) // For C++17 and above
   //***************************************************************************
   // The definition for all types.
   //***************************************************************************
@@ -756,7 +762,7 @@ namespace etl
     //********************************************
     struct result_t
     {
-      bool was_handled;
+      bool                was_handled;
       etl::fsm_state_id_t state_id;
     };
 
@@ -795,17 +801,17 @@ namespace etl
   template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, typename... TMessageTypes>
   ETL_CONSTANT etl::fsm_state_id_t fsm_state<TContext, TDerived, STATE_ID_, TMessageTypes...>::STATE_ID;
 
-#else
-//*************************************************************************************************
-// For C++14 and below.
-//*************************************************************************************************
+  #else
+  //*************************************************************************************************
+  // For C++14 and below.
+  //*************************************************************************************************
   //***************************************************************************
   // The definition for all 16 message types.
   //***************************************************************************
-  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, 
-            typename T1 = void, 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, 
+  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,
+            typename T1 = void, 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 fsm_state : public ifsm_state
   {
@@ -834,7 +840,7 @@ namespace etl
     etl::fsm_state_id_t process_event(const etl::imessage& message)
     {
       etl::fsm_state_id_t new_state_id;
-      etl::message_id_t event_id = message.get_message_id();
+      etl::message_id_t   event_id = message.get_message_id();
 
       switch (event_id)
       {
@@ -864,10 +870,10 @@ namespace etl
   //***************************************************************************
   // Specialisation for 15 message types.
   //***************************************************************************
-  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, 
-            typename T1, typename T2, typename T3, typename T4, 
-            typename T5, typename T6, typename T7, typename T8, 
-            typename T9, typename T10, typename T11, typename T12, 
+  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,
+            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 fsm_state<TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, void> : public ifsm_state
   {
@@ -896,7 +902,7 @@ namespace etl
     etl::fsm_state_id_t process_event(const etl::imessage& message)
     {
       etl::fsm_state_id_t new_state_id;
-      etl::message_id_t event_id = message.get_message_id();
+      etl::message_id_t   event_id = message.get_message_id();
 
       switch (event_id)
       {
@@ -925,10 +931,10 @@ namespace etl
   //***************************************************************************
   // Specialisation for 14 message types.
   //***************************************************************************
-  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, 
-            typename T1, typename T2, typename T3, typename T4, 
-            typename T5, typename T6, typename T7, typename T8, 
-            typename T9, typename T10, typename T11, typename T12, 
+  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,
+            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 fsm_state<TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, void, void> : public ifsm_state
   {
@@ -957,7 +963,7 @@ namespace etl
     etl::fsm_state_id_t process_event(const etl::imessage& message)
     {
       etl::fsm_state_id_t new_state_id;
-      etl::message_id_t event_id = message.get_message_id();
+      etl::message_id_t   event_id = message.get_message_id();
 
       switch (event_id)
       {
@@ -985,10 +991,10 @@ namespace etl
   //***************************************************************************
   // Specialisation for 13 message types.
   //***************************************************************************
-  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, 
-            typename T1, typename T2, typename T3, typename T4, 
-            typename T5, typename T6, typename T7, typename T8, 
-            typename T9, typename T10, typename T11, typename T12, 
+  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,
+            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 fsm_state<TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, void, void, void> : public ifsm_state
   {
@@ -1017,7 +1023,7 @@ namespace etl
     etl::fsm_state_id_t process_event(const etl::imessage& message)
     {
       etl::fsm_state_id_t new_state_id;
-      etl::message_id_t event_id = message.get_message_id();
+      etl::message_id_t   event_id = message.get_message_id();
 
       switch (event_id)
       {
@@ -1044,9 +1050,9 @@ namespace etl
   //***************************************************************************
   // Specialisation for 12 message types.
   //***************************************************************************
-  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, 
-            typename T1, typename T2, typename T3, typename T4, 
-            typename T5, typename T6, typename T7, typename T8, 
+  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,
+            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 fsm_state<TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, void, void, void, void> : public ifsm_state
   {
@@ -1075,7 +1081,7 @@ namespace etl
     etl::fsm_state_id_t process_event(const etl::imessage& message)
     {
       etl::fsm_state_id_t new_state_id;
-      etl::message_id_t event_id = message.get_message_id();
+      etl::message_id_t   event_id = message.get_message_id();
 
       switch (event_id)
       {
@@ -1101,9 +1107,9 @@ namespace etl
   //***************************************************************************
   // Specialisation for 11 message types.
   //***************************************************************************
-  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, 
-            typename T1, typename T2, typename T3, typename T4, 
-            typename T5, typename T6, typename T7, typename T8, 
+  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,
+            typename T1, typename T2, typename T3, typename T4,
+            typename T5, typename T6, typename T7, typename T8,
             typename T9, typename T10, typename T11>
   class fsm_state<TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, void, void, void, void, void> : public ifsm_state
   {
@@ -1132,7 +1138,7 @@ namespace etl
     etl::fsm_state_id_t process_event(const etl::imessage& message)
     {
       etl::fsm_state_id_t new_state_id;
-      etl::message_id_t event_id = message.get_message_id();
+      etl::message_id_t   event_id = message.get_message_id();
 
       switch (event_id)
       {
@@ -1157,9 +1163,9 @@ namespace etl
   //***************************************************************************
   // Specialisation for 10 message types.
   //***************************************************************************
-  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, 
-            typename T1, typename T2, typename T3, typename T4, 
-            typename T5, typename T6, typename T7, typename T8, 
+  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,
+            typename T1, typename T2, typename T3, typename T4,
+            typename T5, typename T6, typename T7, typename T8,
             typename T9, typename T10>
   class fsm_state<TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, void, void, void, void, void, void> : public ifsm_state
   {
@@ -1188,7 +1194,7 @@ namespace etl
     etl::fsm_state_id_t process_event(const etl::imessage& message)
     {
       etl::fsm_state_id_t new_state_id;
-      etl::message_id_t event_id = message.get_message_id();
+      etl::message_id_t   event_id = message.get_message_id();
 
       switch (event_id)
       {
@@ -1212,9 +1218,9 @@ namespace etl
   //***************************************************************************
   // Specialisation for 9 message types.
   //***************************************************************************
-  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, 
-            typename T1, typename T2, typename T3, typename T4, 
-            typename T5, typename T6, typename T7, typename T8, 
+  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,
+            typename T1, typename T2, typename T3, typename T4,
+            typename T5, typename T6, typename T7, typename T8,
             typename T9>
   class fsm_state<TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, T7, T8, T9, void, void, void, void, void, void, void> : public ifsm_state
   {
@@ -1243,7 +1249,7 @@ namespace etl
     etl::fsm_state_id_t process_event(const etl::imessage& message)
     {
       etl::fsm_state_id_t new_state_id;
-      etl::message_id_t event_id = message.get_message_id();
+      etl::message_id_t   event_id = message.get_message_id();
 
       switch (event_id)
       {
@@ -1266,8 +1272,8 @@ namespace etl
   //***************************************************************************
   // Specialisation for 8 message types.
   //***************************************************************************
-  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, 
-            typename T1, typename T2, typename T3, typename T4, 
+  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,
+            typename T1, typename T2, typename T3, typename T4,
             typename T5, typename T6, typename T7, typename T8>
   class fsm_state<TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, T7, T8, void, void, void, void, void, void, void, void> : public ifsm_state
   {
@@ -1296,7 +1302,7 @@ namespace etl
     etl::fsm_state_id_t process_event(const etl::imessage& message)
     {
       etl::fsm_state_id_t new_state_id;
-      etl::message_id_t event_id = message.get_message_id();
+      etl::message_id_t   event_id = message.get_message_id();
 
       switch (event_id)
       {
@@ -1318,8 +1324,8 @@ namespace etl
   //***************************************************************************
   // Specialisation for 7 message types.
   //***************************************************************************
-  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, 
-            typename T1, typename T2, typename T3, typename T4, 
+  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,
+            typename T1, typename T2, typename T3, typename T4,
             typename T5, typename T6, typename T7>
   class fsm_state<TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, T7, void, void, void, void, void, void, void, void, void> : public ifsm_state
   {
@@ -1348,7 +1354,7 @@ namespace etl
     etl::fsm_state_id_t process_event(const etl::imessage& message)
     {
       etl::fsm_state_id_t new_state_id;
-      etl::message_id_t event_id = message.get_message_id();
+      etl::message_id_t   event_id = message.get_message_id();
 
       switch (event_id)
       {
@@ -1369,8 +1375,8 @@ namespace etl
   //***************************************************************************
   // Specialisation for 6 message types.
   //***************************************************************************
-  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, 
-            typename T1, typename T2, typename T3, typename T4, 
+  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,
+            typename T1, typename T2, typename T3, typename T4,
             typename T5, typename T6>
   class fsm_state<TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, void, void, void, void, void, void, void, void, void, void> : public ifsm_state
   {
@@ -1399,7 +1405,7 @@ namespace etl
     etl::fsm_state_id_t process_event(const etl::imessage& message)
     {
       etl::fsm_state_id_t new_state_id;
-      etl::message_id_t event_id = message.get_message_id();
+      etl::message_id_t   event_id = message.get_message_id();
 
       switch (event_id)
       {
@@ -1419,8 +1425,8 @@ namespace etl
   //***************************************************************************
   // Specialisation for 5 message types.
   //***************************************************************************
-  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, 
-            typename T1, typename T2, typename T3, typename T4, 
+  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,
+            typename T1, typename T2, typename T3, typename T4,
             typename T5>
   class fsm_state<TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, void, void, void, void, void, void, void, void, void, void, void> : public ifsm_state
   {
@@ -1449,7 +1455,7 @@ namespace etl
     etl::fsm_state_id_t process_event(const etl::imessage& message)
     {
       etl::fsm_state_id_t new_state_id;
-      etl::message_id_t event_id = message.get_message_id();
+      etl::message_id_t   event_id = message.get_message_id();
 
       switch (event_id)
       {
@@ -1468,7 +1474,7 @@ namespace etl
   //***************************************************************************
   // Specialisation for 4 message types.
   //***************************************************************************
-  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, 
+  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,
             typename T1, typename T2, typename T3, typename T4>
   class fsm_state<TContext, TDerived, STATE_ID_, T1, T2, T3, T4, void, void, void, void, void, void, void, void, void, void, void, void> : public ifsm_state
   {
@@ -1497,7 +1503,7 @@ namespace etl
     etl::fsm_state_id_t process_event(const etl::imessage& message)
     {
       etl::fsm_state_id_t new_state_id;
-      etl::message_id_t event_id = message.get_message_id();
+      etl::message_id_t   event_id = message.get_message_id();
 
       switch (event_id)
       {
@@ -1515,7 +1521,7 @@ namespace etl
   //***************************************************************************
   // Specialisation for 3 message types.
   //***************************************************************************
-  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, 
+  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,
             typename T1, typename T2, typename T3>
   class fsm_state<TContext, TDerived, STATE_ID_, T1, T2, T3, void, void, void, void, void, void, void, void, void, void, void, void, void> : public ifsm_state
   {
@@ -1544,7 +1550,7 @@ namespace etl
     etl::fsm_state_id_t process_event(const etl::imessage& message)
     {
       etl::fsm_state_id_t new_state_id;
-      etl::message_id_t event_id = message.get_message_id();
+      etl::message_id_t   event_id = message.get_message_id();
 
       switch (event_id)
       {
@@ -1561,7 +1567,7 @@ namespace etl
   //***************************************************************************
   // Specialisation for 2 message types.
   //***************************************************************************
-  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, 
+  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,
             typename T1, typename T2>
   class fsm_state<TContext, TDerived, STATE_ID_, T1, T2, void, void, void, void, void, void, void, void, void, void, void, void, void, void> : public ifsm_state
   {
@@ -1590,7 +1596,7 @@ namespace etl
     etl::fsm_state_id_t process_event(const etl::imessage& message)
     {
       etl::fsm_state_id_t new_state_id;
-      etl::message_id_t event_id = message.get_message_id();
+      etl::message_id_t   event_id = message.get_message_id();
 
       switch (event_id)
       {
@@ -1606,7 +1612,7 @@ namespace etl
   //***************************************************************************
   // Specialisation for 1 message type.
   //***************************************************************************
-  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, 
+  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,
             typename T1>
   class fsm_state<TContext, TDerived, STATE_ID_, T1, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void> : public ifsm_state
   {
@@ -1635,7 +1641,7 @@ namespace etl
     etl::fsm_state_id_t process_event(const etl::imessage& message)
     {
       etl::fsm_state_id_t new_state_id;
-      etl::message_id_t event_id = message.get_message_id();
+      etl::message_id_t   event_id = message.get_message_id();
 
       switch (event_id)
       {
@@ -1672,6 +1678,7 @@ namespace etl
     {
       return static_cast<TContext&>(ifsm_state::get_fsm_context());
     }
+
   private:
 
     etl::fsm_state_id_t process_event(const etl::imessage& message)
@@ -1680,15 +1687,15 @@ namespace etl
     }
   };
 
-  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, 
-            typename T1, typename T2, typename T3, typename T4, 
-            typename T5, typename T6, typename T7, typename T8, 
-            typename T9, typename T10, typename T11, typename T12, 
+  template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,
+            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, typename T16>
   ETL_CONSTANT etl::fsm_state_id_t fsm_state<TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::STATE_ID;
-#endif
-}
+  #endif
+} // namespace etl
 
-#include "private/minmax_pop.h"
+  #include "private/minmax_pop.h"
 
 #endif
diff --git a/include/etl/generators/fsm_generator.h b/include/etl/generators/fsm_generator.h
index 0887af6c..85d9a813 100644
--- a/include/etl/generators/fsm_generator.h
+++ b/include/etl/generators/fsm_generator.h
@@ -31,7 +31,7 @@ import cog
 cog.outl("#if 0")
 ]]]*/
 /*[[[end]]]*/
-#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+  #error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
 /*[[[cog
 import cog
 cog.outl("#endif")
@@ -61,24 +61,24 @@ cog.outl("//********************************************************************
 //***************************************************************************
 
 #ifndef ETL_FSM_INCLUDED
-#define ETL_FSM_INCLUDED
+  #define ETL_FSM_INCLUDED
 
-#include "platform.h"
-#include "array.h"
-#include "nullptr.h"
-#include "error_handler.h"
-#include "exception.h"
-#include "user_type.h"
-#include "message_router.h"
-#include "integral_limits.h"
-#include "largest.h"
-#if ETL_USING_CPP11
-  #include "tuple.h"
-#endif
+  #include "platform.h"
+  #include "array.h"
+  #include "error_handler.h"
+  #include "exception.h"
+  #include "integral_limits.h"
+  #include "largest.h"
+  #include "message_router.h"
+  #include "nullptr.h"
+  #include "user_type.h"
+  #if ETL_USING_CPP11
+    #include "tuple.h"
+  #endif
 
-#include <stdint.h>
+  #include <stdint.h>
 
-#include "private/minmax_push.h"
+  #include "private/minmax_push.h"
 
 namespace etl
 {
@@ -86,33 +86,33 @@ namespace etl
   class hfsm;
 
   /// Allow alternative type for state id.
-#if !defined(ETL_FSM_STATE_ID_TYPE)
+  #if !defined(ETL_FSM_STATE_ID_TYPE)
   typedef uint_least8_t fsm_state_id_t;
-#else
+  #else
   typedef ETL_FSM_STATE_ID_TYPE fsm_state_id_t;
-#endif
+  #endif
 
   // For internal FSM use.
   typedef typename etl::larger_type<etl::message_id_t>::type fsm_internal_id_t;
 
-#if ETL_USING_CPP17 && !defined(ETL_FSM_FORCE_CPP03_IMPLEMENTATION) // For C++17 and above
+  #if ETL_USING_CPP17 && !defined(ETL_FSM_FORCE_CPP03_IMPLEMENTATION) // For C++17 and above
   template <typename, typename, etl::fsm_state_id_t, typename...>
   class fsm_state;
-#else
-  /*[[[cog
+  #else
+    /*[[[cog
   import cog
   cog.outl("template <typename, typename, etl::fsm_state_id_t,")
-  cog.out("          ")
+  cog.out("         ")
   for n in range(1, int(Handlers)):
-    cog.out("typename, ")
+    cog.out(" typename,")
     if n % 4 == 0:
         cog.outl("")
-        cog.out("          ")
-  cog.outl("typename>")
+        cog.out("         ")
+  cog.outl(" typename>")
   cog.outl("class fsm_state;")
   ]]]*/
-  /*[[[end]]]*/
-#endif
+    /*[[[end]]]*/
+  #endif
 
   //***************************************************************************
   /// Base exception class for FSM.
@@ -185,6 +185,7 @@ namespace etl
   class fsm_not_started : public etl::fsm_exception
   {
   public:
+
     fsm_not_started(string_type file_name_, numeric_type line_number_)
       : etl::fsm_exception(ETL_ERROR_TEXT("fsm:not started", ETL_FSM_FILE_ID"F"), file_name_, line_number_)
     {
@@ -198,6 +199,7 @@ namespace etl
   class fsm_reentrant_transition_forbidden : public etl::fsm_exception
   {
   public:
+
     fsm_reentrant_transition_forbidden(string_type file_name_, numeric_type line_number_)
       : etl::fsm_exception(ETL_ERROR_TEXT("fsm:reentrant calls to start/receive/etc. forbidden", ETL_FSM_FILE_ID"G"), file_name_, line_number_)
     {
@@ -214,7 +216,7 @@ namespace etl
       // Pass this whenever no state change is desired.
       // The highest unsigned value of fsm_state_id_t.
       static ETL_CONSTANT fsm_state_id_t No_State_Change = etl::integral_limits<fsm_state_id_t>::max;
-      
+
       // Pass this when this event also needs to be passed to the parent.
       static ETL_CONSTANT fsm_state_id_t Pass_To_Parent = No_State_Change - 1U;
 
@@ -232,15 +234,16 @@ namespace etl
     ETL_CONSTANT fsm_state_id_t ifsm_state_helper<T>::Self_Transition;
 
     // Compile-time: TState::ID must equal its index in the type list (0..N-1)
-    template <size_t Id, typename...> struct check_ids : etl::true_type 
+    template <size_t Id, typename...>
+    struct check_ids : etl::true_type
     {
     };
 
     template <size_t Id, typename TState0, typename... TRest>
     struct check_ids<Id, TState0, TRest...>
-      : etl::integral_constant<bool, (TState0::STATE_ID == Id) && private_fsm::check_ids<Id + 1, TRest...>::value> 
+      : etl::integral_constant<bool, (TState0::STATE_ID == Id) && private_fsm::check_ids<Id + 1, TRest...>::value>
     {
-    };   
+    };
 
     //***************************************************************************
     /// RAII detection mechanism to catch reentrant calls to methods that might
@@ -250,6 +253,7 @@ namespace etl
     class fsm_reentrancy_guard
     {
     public:
+
       //*******************************************
       /// Constructor.
       /// Checks if another method has locked reentrancy.
@@ -269,29 +273,30 @@ namespace etl
       {
         is_locked = false;
       }
-      
+
     private:
+
       // Reference to the flag signifying a lock on the state machine.
       bool& is_locked;
-      
+
       // Copy & move semantics disabled since this is a guard.
       fsm_reentrancy_guard(fsm_reentrancy_guard const&) ETL_DELETE;
-      fsm_reentrancy_guard& operator= (fsm_reentrancy_guard const&) ETL_DELETE;
-#if ETL_USING_CPP11
+      fsm_reentrancy_guard& operator=(fsm_reentrancy_guard const&) ETL_DELETE;
+  #if ETL_USING_CPP11
       fsm_reentrancy_guard(fsm_reentrancy_guard&&) ETL_DELETE;
-      fsm_reentrancy_guard& operator= (fsm_reentrancy_guard&&) ETL_DELETE;
-#endif
+      fsm_reentrancy_guard& operator=(fsm_reentrancy_guard&&) ETL_DELETE;
+  #endif
     };
-  }
+  } // namespace private_fsm
 
   class ifsm_state;
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //***************************************************************************
   /// A class to store FSM states.
   //***************************************************************************
   template <typename... TStates>
-  class fsm_state_pack 
+  class fsm_state_pack
   {
   public:
 
@@ -313,18 +318,18 @@ namespace etl
     /// Gets a reference to the state.
     //*********************************
     template <typename TState>
-    TState& get() 
-    { 
-      return etl::get<TState>(storage); 
+    TState& get()
+    {
+      return etl::get<TState>(storage);
     }
 
     //*********************************
     /// Gets a const reference to the state.
     //*********************************
     template <typename TState>
-    const TState& get() const 
-    { 
-      return etl::get<TState>(storage); 
+    const TState& get() const
+    {
+      return etl::get<TState>(storage);
     }
 
   private:
@@ -341,9 +346,9 @@ namespace etl
     etl::tuple<TStates...> storage{};
 
     /// Pointers to the states.
-    etl::ifsm_state* states[sizeof...(TStates)]{ &etl::get<TStates>(storage)... };
+    etl::ifsm_state* states[sizeof...(TStates)]{&etl::get<TStates>(storage)...};
   };
-#endif
+  #endif
 
   //***************************************************************************
   /// Interface class for FSM states.
@@ -360,24 +365,24 @@ namespace etl
     using private_fsm::ifsm_state_helper<>::Pass_To_Parent;
     using private_fsm::ifsm_state_helper<>::Self_Transition;
 
-#if ETL_USING_CPP17 && !defined(ETL_FSM_FORCE_CPP03_IMPLEMENTATION) // For C++17 and above
+  #if ETL_USING_CPP17 && !defined(ETL_FSM_FORCE_CPP03_IMPLEMENTATION) // For C++17 and above
     template <typename, typename, etl::fsm_state_id_t, typename...>
     friend class fsm_state;
-#else
+  #else
     /*[[[cog
     import cog
     cog.outl("  template <typename, typename, etl::fsm_state_id_t,")
-    cog.out("            ")
+    cog.out("           ")
     for n in range(1, int(Handlers)):
-      cog.out("typename, ")
+      cog.out(" typename,")
       if n % 4 == 0:
           cog.outl("")
-          cog.out("            ")
-    cog.outl("typename>")
+          cog.out("           ")
+    cog.outl(" typename>")
     ]]]*/
     /*[[[end]]]*/
     friend class etl::fsm_state;
-#endif
+  #endif
 
     //*******************************************
     /// Gets the id for this state.
@@ -409,7 +414,7 @@ namespace etl
     template <typename TSize>
     void set_child_states(etl::ifsm_state** state_list, TSize size)
     {
-      p_active_child = ETL_NULLPTR;
+      p_active_child  = ETL_NULLPTR;
       p_default_child = ETL_NULLPTR;
 
       for (TSize i = 0; i < size; ++i)
@@ -425,11 +430,11 @@ namespace etl
     /// Constructor.
     //*******************************************
     ifsm_state(etl::fsm_state_id_t state_id_)
-      : state_id(state_id_),
-      p_context(ETL_NULLPTR),
-      p_parent(ETL_NULLPTR),
-      p_active_child(ETL_NULLPTR),
-      p_default_child(ETL_NULLPTR)
+      : state_id(state_id_)
+      , p_context(ETL_NULLPTR)
+      , p_parent(ETL_NULLPTR)
+      , p_active_child(ETL_NULLPTR)
+      , p_default_child(ETL_NULLPTR)
     {
     }
 
@@ -450,8 +455,11 @@ namespace etl
 
     virtual fsm_state_id_t process_event(const etl::imessage& message) = 0;
 
-    virtual fsm_state_id_t on_enter_state() { return No_State_Change; } // By default, do nothing.
-    virtual void on_exit_state() {}  // By default, do nothing.
+    virtual fsm_state_id_t on_enter_state()
+    {
+      return No_State_Change;
+    } // By default, do nothing.
+    virtual void on_exit_state() {} // By default, do nothing.
 
     //*******************************************
     void set_fsm_context(etl::fsm& context)
@@ -476,7 +484,7 @@ namespace etl
 
     // Disabled.
     ifsm_state(const ifsm_state&) ETL_DELETE;
-    ifsm_state& operator =(const ifsm_state&) ETL_DELETE;
+    ifsm_state& operator=(const ifsm_state&) ETL_DELETE;
   };
 
   //***************************************************************************
@@ -508,7 +516,7 @@ namespace etl
     template <typename TSize>
     void set_states(etl::ifsm_state** p_states, TSize size)
     {
-      state_list = p_states;
+      state_list       = p_states;
       number_of_states = etl::fsm_state_id_t(size);
 
       ETL_ASSERT(number_of_states > 0, ETL_ERROR(etl::fsm_state_list_exception));
@@ -522,7 +530,7 @@ namespace etl
       }
     }
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
     //*******************************************
     /// Set the states for the FSM
     /// From an etl::fsm_state_pack.
@@ -530,7 +538,7 @@ namespace etl
     template <typename... TStates>
     void set_states(etl::fsm_state_pack<TStates...>& state_pack)
     {
-      state_list = state_pack.get_state_list();
+      state_list       = state_pack.get_state_list();
       number_of_states = etl::fsm_state_id_t(state_pack.size());
 
       for (etl::fsm_state_id_t i = 0; i < number_of_states; ++i)
@@ -538,7 +546,7 @@ namespace etl
         state_list[i]->set_fsm_context(*this);
       }
     }
-#endif
+  #endif
 
     //*******************************************
     /// Starts the FSM.
@@ -559,11 +567,11 @@ namespace etl
         if (call_on_enter_state)
         {
           etl::fsm_state_id_t next_state_id;
-          etl::ifsm_state* p_last_state;
+          etl::ifsm_state*    p_last_state;
 
           do
           {
-            p_last_state = p_state;
+            p_last_state  = p_state;
             next_state_id = p_state->on_enter_state();
             if (next_state_id != ifsm_state::No_State_Change)
             {
@@ -586,7 +594,7 @@ namespace etl
       {
         etl::fsm_state_id_t next_state_id = p_state->process_event(message);
 
-        process_state_change(next_state_id); 
+        process_state_change(next_state_id);
       }
       else
       {
@@ -696,9 +704,7 @@ namespace etl
     //********************************************
     bool have_changed_state(etl::fsm_state_id_t next_state_id) const
     {
-      return (next_state_id != p_state->get_state_id()) &&
-             (next_state_id != ifsm_state::No_State_Change) &&
-             (next_state_id != ifsm_state::Self_Transition);
+      return (next_state_id != p_state->get_state_id()) && (next_state_id != ifsm_state::No_State_Change) && (next_state_id != ifsm_state::Self_Transition);
     }
 
     //********************************************
@@ -717,7 +723,7 @@ namespace etl
         p_state->on_exit_state();
         next_state_id = p_state->on_enter_state();
       }
-      
+
       if (have_changed_state(next_state_id))
       {
         ETL_ASSERT_OR_RETURN_VALUE(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception), p_state->get_state_id());
@@ -741,16 +747,16 @@ namespace etl
       return p_state->get_state_id();
     }
 
-    etl::ifsm_state*    p_state;          ///< A pointer to the current state.
-    etl::ifsm_state**   state_list;       ///< The list of added states.
-    etl::fsm_state_id_t number_of_states; ///< The number of states.
-    bool is_processing_state_change;      ///< Whether a method call that could potentially trigger a state change is active
+    etl::ifsm_state*    p_state;                    ///< A pointer to the current state.
+    etl::ifsm_state**   state_list;                 ///< The list of added states.
+    etl::fsm_state_id_t number_of_states;           ///< The number of states.
+    bool                is_processing_state_change; ///< Whether a method call that could potentially trigger a state change is active
   };
 
   //*************************************************************************************************
   // For C++17 and above.
   //*************************************************************************************************
-#if ETL_USING_CPP17 && !defined(ETL_FSM_FORCE_CPP03_IMPLEMENTATION) // For C++17 and above
+  #if ETL_USING_CPP17 && !defined(ETL_FSM_FORCE_CPP03_IMPLEMENTATION) // For C++17 and above
   //***************************************************************************
   // The definition for all types.
   //***************************************************************************
@@ -782,7 +788,7 @@ namespace etl
     //********************************************
     struct result_t
     {
-      bool was_handled;
+      bool                was_handled;
       etl::fsm_state_id_t state_id;
     };
 
@@ -821,11 +827,11 @@ namespace etl
   template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, typename... TMessageTypes>
   ETL_CONSTANT etl::fsm_state_id_t fsm_state<TContext, TDerived, STATE_ID_, TMessageTypes...>::STATE_ID;
 
-#else
-//*************************************************************************************************
-// For C++14 and below.
-//*************************************************************************************************
-  /*[[[cog
+  #else
+  //*************************************************************************************************
+  // For C++14 and below.
+  //*************************************************************************************************
+    /*[[[cog
   import cog
   ################################################
   # The first definition for all of the events.
@@ -833,14 +839,14 @@ namespace etl
   cog.outl("//***************************************************************************")
   cog.outl("// The definition for all %s message types." % Handlers)
   cog.outl("//***************************************************************************")
-  cog.outl("template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, ")
-  cog.out("          ")
+  cog.outl("template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,")
+  cog.out("         ")
   for n in range(1, int(Handlers)):
-      cog.out("typename T%s = void, " % n)
+      cog.out(" typename T%s = void," % n)
       if n % 4 == 0:
           cog.outl("")
-          cog.out("          ")
-  cog.outl("typename T%s = void>" % Handlers)
+          cog.out("         ")
+  cog.outl(" typename T%s = void>" % Handlers)
   cog.outl("class fsm_state : public ifsm_state")
   cog.outl("{")
   cog.outl("public:")
@@ -868,7 +874,7 @@ namespace etl
   cog.outl("  etl::fsm_state_id_t process_event(const etl::imessage& message)")
   cog.outl("  {")
   cog.outl("    etl::fsm_state_id_t new_state_id;")
-  cog.outl("    etl::message_id_t event_id = message.get_message_id();")
+  cog.outl("    etl::message_id_t   event_id = message.get_message_id();")
   cog.outl("")
   cog.outl("    switch (event_id)")
   cog.outl("    {")
@@ -896,14 +902,14 @@ namespace etl
       else:
           cog.outl("// Specialisation for %d message types." % n)
       cog.outl("//***************************************************************************")
-      cog.outl("template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, ")
-      cog.out("          ")
+      cog.outl("template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,")
+      cog.out("         ")
       for t in range(1, n):
-          cog.out("typename T%d, " % t)
+          cog.out(" typename T%d," % t)
           if t % 4 == 0:
               cog.outl("")
-              cog.out("          ")
-      cog.outl("typename T%d>" % n)
+              cog.out("         ")
+      cog.outl(" typename T%d>" % n)
       cog.out("class fsm_state<TContext, TDerived, STATE_ID_, ")
       for t in range(1, n + 1):
           cog.out("T%d, " % t)
@@ -942,7 +948,7 @@ namespace etl
       cog.outl("  etl::fsm_state_id_t process_event(const etl::imessage& message)")
       cog.outl("  {")
       cog.outl("    etl::fsm_state_id_t new_state_id;")
-      cog.outl("    etl::message_id_t event_id = message.get_message_id();")
+      cog.outl("    etl::message_id_t   event_id = message.get_message_id();")
       cog.outl("")
       cog.outl("    switch (event_id)")
       cog.outl("    {")
@@ -993,6 +999,7 @@ namespace etl
   cog.outl("  {")
   cog.outl("    return static_cast<TContext&>(ifsm_state::get_fsm_context());")
   cog.outl("  }")
+  cog.outl("")
   cog.outl("private:")
   cog.outl("")
   cog.outl("  etl::fsm_state_id_t process_event(const etl::imessage& message)")
@@ -1002,23 +1009,23 @@ namespace etl
   cog.outl("};")
 
   cog.outl("")
-  cog.outl("template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_, ")
-  cog.out("          ")
+  cog.outl("template <typename TContext, typename TDerived, etl::fsm_state_id_t STATE_ID_,")
+  cog.out("         ")
   for n in range(1, int(Handlers)):
-      cog.out("typename T%s, " % n)
+      cog.out(" typename T%s," % n)
       if n % 4 == 0:
           cog.outl("")
-          cog.out("          ")
-  cog.outl("typename T%s>" % Handlers)
+          cog.out("         ")
+  cog.outl(" typename T%s>" % Handlers)
   cog.out("ETL_CONSTANT etl::fsm_state_id_t fsm_state<TContext, TDerived, STATE_ID_, ")
   for n in range(1, int(Handlers)):
       cog.out("T%s, " % n)
   cog.outl("T%s>::STATE_ID;" % Handlers)
   ]]]*/
-  /*[[[end]]]*/
-#endif
-}
+    /*[[[end]]]*/
+  #endif
+} // namespace etl
 
-#include "private/minmax_pop.h"
+  #include "private/minmax_pop.h"
 
 #endif
diff --git a/include/etl/generators/largest_generator.h b/include/etl/generators/largest_generator.h
index ff31d050..bc28bdd3 100644
--- a/include/etl/generators/largest_generator.h
+++ b/include/etl/generators/largest_generator.h
@@ -33,7 +33,7 @@ import cog
 cog.outl("#if 0")
 ]]]*/
 /*[[[end]]]*/
-#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+  #error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
 /*[[[cog
 import cog
 cog.outl("#endif")
@@ -63,19 +63,19 @@ cog.outl("//********************************************************************
 //***************************************************************************
 
 #ifndef ETL_LARGEST_INCLUDED
-#define ETL_LARGEST_INCLUDED
+  #define ETL_LARGEST_INCLUDED
 
 ///\defgroup largest largest
 ///\ingroup utilities
 
-#include "platform.h"
-#include "type_traits.h"
-#include "smallest.h"
-#include "static_assert.h"
+  #include "platform.h"
+  #include "smallest.h"
+  #include "static_assert.h"
+  #include "type_traits.h"
 
 namespace etl
 {
-#if ETL_USING_CPP11 && !defined(ETL_LARGEST_TYPE_FORCE_CPP03_IMPLEMENTATION)
+  #if ETL_USING_CPP11 && !defined(ETL_LARGEST_TYPE_FORCE_CPP03_IMPLEMENTATION)
   //***************************************************************************
   /// Template to determine the largest type and size.
   /// Defines 'value_type' which is the type of the largest parameter.
@@ -94,10 +94,10 @@ namespace etl
 
     // Set 'type' to be the largest of the first parameter and any of the others.
     // This is recursive.
-    using type = typename etl::conditional<(etl::size_of<T1>::value > etl::size_of<largest_other>::value),  // Boolean
-                                            T1,                                                             // TrueType
-                                            largest_other>                                                  // FalseType
-                                            ::type;                                                         // The largest type of the two.
+    using type = typename etl::conditional<(etl::size_of<T1>::value > etl::size_of<largest_other>::value), // Boolean
+                                           T1,                                                             // TrueType
+                                           largest_other>                                                  // FalseType
+      ::type;                                                                                              // The largest type of the two.
 
     // The size of the largest type.
     enum
@@ -122,18 +122,18 @@ namespace etl
     };
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename... T>
   using largest_type_t = typename largest_type<T...>::type;
-#endif
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename... T>
   constexpr size_t largest_type_v = largest_type<T...>::size;
-#endif
+    #endif
 
-#else
-  /*[[[cog
+  #else
+    /*[[[cog
   import cog
   cog.outl("//***************************************************************************")
   cog.outl("/// Template to determine the largest type and size.")
@@ -142,16 +142,16 @@ namespace etl
   cog.outl("/// Defines 'size' which is the size of the largest parameter.")
   cog.outl("///\\ingroup largest")
   cog.outl("//***************************************************************************")
-  cog.out("template <typename T1, ")
+  cog.out("template <typename T1,")
   for n in range(2, int(NTypes)):
-      cog.out("typename T%s = void, " % n)
+      cog.out(" typename T%s = void," % n)
       if n % 4 == 0:
           cog.outl("")
-          cog.out("          ")
-  cog.outl("typename T%s = void>" % int(NTypes))
+          cog.out("         ")
+  cog.outl(" typename T%s = void>" % int(NTypes))
   cog.outl("struct largest_type")
   cog.outl("{")
-  cog.outl("  // Define 'largest_other' as 'largest_type' with all but the first parameter. ")
+  cog.outl("  // Define 'largest_other' as 'largest_type' with all but the first parameter.")
   cog.out("  typedef typename largest_type<")
   for n in range(2, int(NTypes)):
       cog.out("T%s, " % n)
@@ -163,9 +163,9 @@ namespace etl
   cog.outl("  // Set 'type' to be the largest of the first parameter and any of the others.")
   cog.outl("  // This is recursive.")
   cog.outl("  typedef typename etl::conditional<(sizeof(T1) > sizeof(largest_other)), // Boolean")
-  cog.outl("                                     T1,                                  // TrueType")
-  cog.outl("                                     largest_other>                       // FalseType")
-  cog.outl("                                     ::type type;                         // The largest type of the two.")
+  cog.outl("                                    T1,                                   // TrueType")
+  cog.outl("                                    largest_other>                        // FalseType")
+  cog.outl("    ::type type;                                                          // The largest type of the two.")
   cog.outl("")
   cog.outl("  // The size of the largest type.")
   cog.outl("  enum")
@@ -178,13 +178,13 @@ namespace etl
   cog.outl("// Specialisation for one template parameter.")
   cog.outl("//***************************************************************************")
   cog.outl("template <typename T1>")
-  cog.out("struct largest_type<T1,   ")
+  cog.out("struct largest_type<T1,")
   for n in range(2, int(NTypes)):
-      cog.out("void, ")
+      cog.out(" void,")
       if n % 8 == 0:
           cog.outl("")
-          cog.out("                    ")
-  cog.outl("void>")
+          cog.out("                   ")
+  cog.outl(" void>")
   cog.outl("{")
   cog.outl("  typedef T1 type;")
   cog.outl("")
@@ -194,10 +194,10 @@ namespace etl
   cog.outl("  };")
   cog.outl("};")
   ]]]*/
-  /*[[[end]]]*/
-#endif
+    /*[[[end]]]*/
+  #endif
 
-#if ETL_USING_CPP11 && !defined(ETL_LARGEST_ALIGNMENT_FORCE_CPP03_IMPLEMENTATION)
+  #if ETL_USING_CPP11 && !defined(ETL_LARGEST_ALIGNMENT_FORCE_CPP03_IMPLEMENTATION)
   //***************************************************************************
   /// Template to determine the largest alignment.
   /// Defines <b>value</b> which is the largest alignment of all the parameters.
@@ -212,9 +212,9 @@ namespace etl
     // Set 'type' to be the largest of the first parameter and any of the others.
     // This is recursive.
     using type = typename etl::conditional<(etl::alignment_of<T1>::value > etl::alignment_of<largest_other>::value), // Boolean
-                                            T1,                                                                      // TrueType
-                                            largest_other>                                                           // FalseType
-                                            ::type;                                                                  // The largest type of the two.
+                                           T1,                                                                       // TrueType
+                                           largest_other>                                                            // FalseType
+      ::type;                                                                                                        // The largest type of the two.
 
     // The largest alignment.
     enum
@@ -237,13 +237,13 @@ namespace etl
     };
   };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename... T>
   inline constexpr size_t largest_alignment_v = largest_alignment<T...>::value;
-#endif
+    #endif
 
-#else
-  /*[[[cog
+  #else
+    /*[[[cog
   import cog
   cog.outl("//***************************************************************************")
   cog.outl("/// Template to determine the largest alignment.")
@@ -251,16 +251,16 @@ namespace etl
   cog.outl("/// Defines <b>value</b> which is the largest alignment of all the parameters.")
   cog.outl("///\\ingroup largest")
   cog.outl("//***************************************************************************")
-  cog.out("template <typename T1, ")
+  cog.out("template <typename T1,")
   for n in range(2, int(NTypes)):
-      cog.out("typename T%s = void, " % n)
+      cog.out(" typename T%s = void," % n)
       if n % 4 == 0:
           cog.outl("")
-          cog.out("          ")
-  cog.outl("typename T%s = void>" % int(NTypes))
+          cog.out("         ")
+  cog.outl(" typename T%s = void>" % int(NTypes))
   cog.outl("struct largest_alignment")
   cog.outl("{")
-  cog.outl("  // Define 'largest_other' as 'largest_type' with all but the first parameter. ")
+  cog.outl("  // Define 'largest_other' as 'largest_type' with all but the first parameter.")
   cog.out("  typedef typename largest_alignment<")
   for n in range(2, int(NTypes)):
       cog.out("T%s, " % n)
@@ -272,9 +272,9 @@ namespace etl
   cog.outl("  // Set 'type' to be the largest of the first parameter and any of the others.")
   cog.outl("  // This is recursive.")
   cog.outl("  typedef typename etl::conditional<(etl::alignment_of<T1>::value > etl::alignment_of<largest_other>::value), // Boolean")
-  cog.outl("                                     T1,                                                                      // TrueType")
-  cog.outl("                                     largest_other>                                                           // FalseType")
-  cog.outl("                                     ::type type;                                                             // The largest type of the two.")
+  cog.outl("                                    T1,                                                                       // TrueType")
+  cog.outl("                                    largest_other>                                                            // FalseType")
+  cog.outl("    ::type type;                                                                                              // The largest type of the two.")
   cog.outl("")
   cog.outl("  // The largest alignment.")
   cog.outl("  enum")
@@ -287,13 +287,13 @@ namespace etl
   cog.outl("// Specialisation for one template parameter.")
   cog.outl("//***************************************************************************")
   cog.outl("template <typename T1>")
-  cog.out("struct largest_alignment<T1,   ")
+  cog.out("struct largest_alignment<T1,")
   for n in range(2, int(NTypes)):
-      cog.out("void, ")
+      cog.out(" void,")
       if n % 8 == 0:
           cog.outl("")
-          cog.out("                         ")
-  cog.outl("void>")
+          cog.out("                        ")
+  cog.outl(" void>")
   cog.outl("{")
   cog.outl("  typedef T1 type;")
   cog.outl("")
@@ -303,8 +303,8 @@ namespace etl
   cog.outl("  };")
   cog.outl("};")
   ]]]*/
-  /*[[[end]]]*/
-#endif
+    /*[[[end]]]*/
+  #endif
 
   //***************************************************************************
   /// Defines a type that is as larger or larger than the specified type.
@@ -319,10 +319,10 @@ namespace etl
     typedef typename etl::smallest_int_for_bits<etl::integral_limits<typename etl::make_signed<T>::type>::bits + 1>::type type;
   };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename T>
   using larger_int_type_t = typename larger_int_type<T>::type;
-#endif
+  #endif
 
   //***************************************************************************
   /// Defines a type that is as larger or larger than the specified type.
@@ -337,10 +337,10 @@ namespace etl
     typedef typename etl::smallest_uint_for_bits<etl::integral_limits<typename etl::make_unsigned<T>::type>::bits + 1>::type type;
   };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename T>
   using larger_uint_type_t = typename larger_uint_type<T>::type;
-#endif
+  #endif
 
   //***************************************************************************
   /// Defines a type that is as larger or larger than the specified type.
@@ -367,12 +367,12 @@ namespace etl
     typedef typename etl::smallest_int_for_bits<etl::integral_limits<T>::bits + 1>::type type;
   };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename T>
   using larger_type_t = typename larger_type<T>::type;
-#endif
+  #endif
 
-#if ETL_USING_CPP11 && !defined(ETL_LARGEST_FORCE_CPP03_IMPLEMENTATION)
+  #if ETL_USING_CPP11 && !defined(ETL_LARGEST_FORCE_CPP03_IMPLEMENTATION)
   //***************************************************************************
   /// Template to determine the largest type, size and alignment.
   /// Defines <b>value</b> which is the largest type, size and alignment of all the parameters.
@@ -390,18 +390,18 @@ namespace etl
     };
   };
 
-#if ETL_USING_CPP11
-    template <typename... T>
-    using largest_t = typename largest<T...>::type;
-#endif
+    #if ETL_USING_CPP11
+  template <typename... T>
+  using largest_t = typename largest<T...>::type;
+    #endif
 
-#if ETL_USING_CPP17
-    template <typename... T>
-    inline constexpr size_t largest_size = largest<T...>::size;
-#endif
+    #if ETL_USING_CPP17
+  template <typename... T>
+  inline constexpr size_t largest_size = largest<T...>::size;
+    #endif
 
-#else
-  /*[[[cog
+  #else
+    /*[[[cog
   import cog
   cog.outl("//***************************************************************************")
   cog.outl("/// Template to determine the largest type, size and alignment.")
@@ -409,13 +409,13 @@ namespace etl
   cog.outl("/// Defines <b>value</b> which is the largest type, size and alignment of all the parameters.")
   cog.outl("///\\ingroup largest")
   cog.outl("//***************************************************************************")
-  cog.out("template <typename T1, ")
+  cog.out("template <typename T1,")
   for n in range(2, int(NTypes)):
-      cog.out("typename T%s = void, " % n)
+      cog.out(" typename T%s = void," % n)
       if n % 4 == 0:
           cog.outl("")
-          cog.out("          ")
-  cog.outl("typename T%s = void>" % NTypes)
+          cog.out("         ")
+  cog.outl(" typename T%s = void>" % NTypes)
   cog.outl("struct largest")
   cog.outl("{")
   cog.out("  typedef typename etl::largest_type<")
@@ -445,8 +445,8 @@ namespace etl
   cog.outl("  };")
   cog.outl("};")
   ]]]*/
-  /*[[[end]]]*/
-#endif
-}
+    /*[[[end]]]*/
+  #endif
+} // namespace etl
 
 #endif
diff --git a/include/etl/generators/message_packet_generator.h b/include/etl/generators/message_packet_generator.h
index 36430509..d6eed1be 100644
--- a/include/etl/generators/message_packet_generator.h
+++ b/include/etl/generators/message_packet_generator.h
@@ -31,7 +31,7 @@ import cog
 cog.outl("#if 0")
 ]]]*/
 /*[[[end]]]*/
-#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+  #error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
 /*[[[cog
 import cog
 cog.outl("#endif")
@@ -61,30 +61,29 @@ cog.outl("//********************************************************************
 //***************************************************************************
 
 #ifndef ETL_MESSAGE_PACKET_INCLUDED
-#define ETL_MESSAGE_PACKET_INCLUDED
+  #define ETL_MESSAGE_PACKET_INCLUDED
 
-#include "platform.h"
+  #include "platform.h"
 
-#include "message.h"
-#include "error_handler.h"
-#include "static_assert.h"
-#include "largest.h"
-#include "alignment.h"
-#include "utility.h"
-#include "type_list.h"
+  #include "alignment.h"
+  #include "error_handler.h"
+  #include "largest.h"
+  #include "message.h"
+  #include "static_assert.h"
+  #include "type_list.h"
+  #include "utility.h"
 
-#include <stdint.h>
+  #include <stdint.h>
 
 namespace etl
 {
-#if ETL_USING_CPP17 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+  #if ETL_USING_CPP17 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
   //***************************************************************************
   // The definition for all message types.
   //***************************************************************************
   template <typename... TMessageTypes>
   class message_packet
   {
-
   private:
 
     template <typename T>
@@ -100,18 +99,18 @@ namespace etl
 
     using message_types = etl::type_list<TMessageTypes...>;
 
-    //********************************************
-#include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     constexpr message_packet() noexcept
       : valid(false)
     {
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //********************************************
-    ///
-    //********************************************
-#include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+      ///
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     template <typename T, typename = typename etl::enable_if<IsIMessage<T> || IsInMessageList<T>, int>::type>
     explicit message_packet(T&& msg)
       : valid(true)
@@ -139,7 +138,7 @@ namespace etl
         ETL_STATIC_ASSERT(IsInMessageList<T>, "Message not in packet type list");
       }
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
     //**********************************************
     message_packet(const message_packet& other)
@@ -152,7 +151,7 @@ namespace etl
       }
     }
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     //**********************************************
     message_packet(message_packet&& other)
     {
@@ -163,7 +162,7 @@ namespace etl
         add_new_message(etl::move(other.get()));
       }
     }
-#endif
+    #endif
 
     //**********************************************
     void copy(const message_packet& other)
@@ -187,9 +186,9 @@ namespace etl
       }
     }
 
-    //**********************************************
-#include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -200,11 +199,11 @@ namespace etl
 
       return *this;
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //**********************************************
-#include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -215,7 +214,7 @@ namespace etl
 
       return *this;
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
     //********************************************
     ~message_packet()
@@ -263,7 +262,7 @@ namespace etl
     //**********************************************
     template <typename TMessage>
     static ETL_CONSTEXPR
-    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
+      typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
       accepts()
     {
       return accepts<TMessage::ID>();
@@ -271,7 +270,7 @@ namespace etl
 
     enum
     {
-      SIZE = etl::largest<TMessageTypes...>::size,
+      SIZE      = etl::largest<TMessageTypes...>::size,
       ALIGNMENT = etl::largest<TMessageTypes...>::alignment
     };
 
@@ -291,24 +290,24 @@ namespace etl
       return Id1 == id2;
     }
 
-    //********************************************
-#include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     void delete_current_message()
     {
       if (valid)
       {
         etl::imessage* pmsg = static_cast<etl::imessage*>(data);
 
-#if ETL_HAS_VIRTUAL_MESSAGES
+    #if ETL_HAS_VIRTUAL_MESSAGES
         pmsg->~imessage();
-#else
+    #else
         delete_message(pmsg);
-#endif
+    #endif
       }
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-#if !ETL_HAS_VIRTUAL_MESSAGES
+    #if !ETL_HAS_VIRTUAL_MESSAGES
     //********************************************
     void delete_message(etl::imessage* pmsg)
     {
@@ -330,7 +329,7 @@ namespace etl
         return false;
       }
     }
-#endif
+    #endif
 
     //********************************************
     void add_new_message(const etl::imessage& msg)
@@ -344,7 +343,7 @@ namespace etl
       (add_new_message_type<TMessageTypes>(etl::move(msg)) || ...);
     }
 
-#include "private/diagnostic_uninitialized_push.h"
+    #include "private/diagnostic_uninitialized_push.h"
     //********************************************
     /// Only enabled for types that are in the typelist.
     //********************************************
@@ -355,9 +354,9 @@ namespace etl
       void* p = data;
       new (p) etl::remove_reference_t<TMessage>((etl::forward<TMessage>(msg)));
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-#include "private/diagnostic_uninitialized_push.h"
+    #include "private/diagnostic_uninitialized_push.h"
     //********************************************
     template <typename TType>
     bool add_new_message_type(const etl::imessage& msg)
@@ -373,7 +372,7 @@ namespace etl
         return false;
       }
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
     //********************************************
     template <typename TType>
@@ -392,7 +391,7 @@ namespace etl
     }
 
     typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    bool valid;
+    bool                                                 valid;
   };
 
   //***************************************************************************
@@ -416,24 +415,24 @@ namespace etl
 
     using message_types = etl::type_list<>;
 
-    //********************************************
-#include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     constexpr message_packet() noexcept
     {
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
     //**********************************************
     message_packet(const message_packet& /*other*/)
     {
     }
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     //**********************************************
     message_packet(message_packet&& /*other*/)
     {
     }
-#endif
+    #endif
 
     //**********************************************
     void copy(const message_packet& /*other*/)
@@ -445,21 +444,21 @@ namespace etl
     {
     }
 
-    //**********************************************
-#include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& /*rhs*/)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& /*rhs*/)
     {
       return *this;
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //**********************************************
-#include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& /*rhs*/)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& /*rhs*/)
     {
       return *this;
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
     //********************************************
     ~message_packet()
@@ -502,7 +501,7 @@ namespace etl
 
     enum
     {
-      SIZE = 0,
+      SIZE      = 0,
       ALIGNMENT = 1
     };
   };
@@ -521,7 +520,7 @@ namespace etl
   template <typename TTypeList>
   using message_packet_from_type_list_t = typename message_packet_from_type_list<TTypeList>::type;
 
-#else
+  #else
 
   /*[[[cog
     import cog
@@ -532,10 +531,11 @@ namespace etl
         for i in range(1, n + 1):
             cog.out(" T%d::ID == id" % i)
             if i < n:
-                cog.out(" ||")
                 if i % 4 == 0:
                     cog.outl("")
-                    cog.out("          ")
+                    cog.out("           ||")
+                else:
+                    cog.out(" ||")
         cog.outl(";")
 
     ################################################
@@ -544,10 +544,11 @@ namespace etl
         for i in range(1, n + 1):
             cog.out(" T%d::ID == Id" % i)
             if i < n:
-                cog.out(" ||")
                 if i % 4 == 0:
                     cog.outl("")
-                    cog.out("          ")
+                    cog.out("           ||")
+                else:
+                    cog.out(" ||")
         cog.outl(";")
 
     ################################################
@@ -556,10 +557,11 @@ namespace etl
         for i in range(1, n + 1):
             cog.out(" T%d::ID == TMessage::ID" % i)
             if i < n:
-                cog.out(" ||")
                 if i % 4 == 0:
                     cog.outl("")
-                    cog.out("          ")
+                    cog.out("           ||")
+                else:
+                    cog.out(" ||")
         cog.outl(";")
 
     ################################################
@@ -568,9 +570,9 @@ namespace etl
         cog.out("    static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<")
         for i in range(1, n):
             cog.out("T%d, " % i)
-        cog.outl("T%s> >::value &&" % n)
-        cog.outl("                                 !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&")
-        cog.out("                                 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,")
+        cog.outl("T%s> >::value" % n)
+        cog.outl("                                 && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value")
+        cog.out("                                 && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, ")
         for i in range(1, n):
             cog.out("T%d, " % i)
         cog.outl("T%s>::value);" % n)
@@ -583,9 +585,9 @@ namespace etl
         cog.out("    static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<")
         for i in range(1, n):
             cog.out("T%d, " % i)
-        cog.outl("T%s> >::value &&" % n)
-        cog.outl("                                     !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&")
-        cog.out("                                     etl::is_one_of<typename etl::remove_cvref<TMessage>::type,")
+        cog.outl("T%s> >::value" % n)
+        cog.outl("                                     && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value")
+        cog.out("                                     && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, ")
         for i in range(1, n):
             cog.out("T%d, " % i)
         cog.outl("T%s>::value);" % n)
@@ -598,36 +600,36 @@ namespace etl
     cog.outl("//***************************************************************************")
     cog.outl("// The definition for all %s message types." % Handlers)
     cog.outl("//***************************************************************************")
-    cog.out("template <")
-    for n in range(1, int(Handlers)):
-        cog.out("typename T%s = void, " % n)
+    cog.out("template <typename T1 = void,")
+    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.out("         ")
+    cog.outl(" typename T%s = void>" % int(Handlers))
     cog.outl("class message_packet")
     cog.outl("{")
     cog.outl("public:")
     cog.outl("")
     
-    cog.outl("#if ETL_USING_CPP11")
+    cog.outl("  #if ETL_USING_CPP11")
     cog.out("  using message_types = etl::type_list<")
     for n in range(1, int(Handlers)):
         cog.out("T%s, " % n)
     cog.outl("T%s>;" % int(Handlers))
-    cog.outl("#endif")
+    cog.outl("  #endif")
     cog.outl("")
 
-    cog.outl("  //********************************************")
-    cog.outl("#include \"private/diagnostic_uninitialized_push.h\"")
+    cog.outl("    //********************************************")
+    cog.outl("  #include \"private/diagnostic_uninitialized_push.h\"")
     cog.outl("  ETL_CONSTEXPR message_packet() ETL_NOEXCEPT")
     cog.outl("    : valid(false)")
     cog.outl("  {")
     cog.outl("  }")
-    cog.outl("#include \"private/diagnostic_pop.h\"")
+    cog.outl("  #include \"private/diagnostic_pop.h\"")
     cog.outl("")
-    cog.outl("  //********************************************")
-    cog.outl("#include \"private/diagnostic_uninitialized_push.h\"")
+    cog.outl("    //********************************************")
+    cog.outl("  #include \"private/diagnostic_uninitialized_push.h\"")
     cog.outl("  explicit message_packet(const etl::imessage& msg)")
     cog.outl("  {")
     cog.outl("    if (accepts(msg))")
@@ -642,11 +644,11 @@ namespace etl
     cog.outl("")
     cog.outl("    ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));")
     cog.outl("  }")
-    cog.outl("#include \"private/diagnostic_pop.h\"")
+    cog.outl("  #include \"private/diagnostic_pop.h\"")
     cog.outl("")
-    cog.outl("#if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
-    cog.outl("  //********************************************")
-    cog.outl("#include \"private/diagnostic_uninitialized_push.h\"")
+    cog.outl("  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
+    cog.outl("      //********************************************")
+    cog.outl("    #include \"private/diagnostic_uninitialized_push.h\"")
     cog.outl("  explicit message_packet(etl::imessage&& msg)")
     cog.outl("  {")
     cog.outl("    if (accepts(msg))")
@@ -661,49 +663,51 @@ namespace etl
     cog.outl("")
     cog.outl("    ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));")
     cog.outl("  }")
-    cog.outl("#include \"private/diagnostic_pop.h\"")
-    cog.outl("#endif")
+    cog.outl("    #include \"private/diagnostic_pop.h\"")
+    cog.outl("  #endif")
     cog.outl("")
-    cog.outl("#if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)")
-    cog.outl("  //********************************************")
-    cog.outl("#include \"private/diagnostic_uninitialized_push.h\"")
+    cog.outl("  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)")
+    cog.outl("      //********************************************")
+    cog.outl("    #include \"private/diagnostic_uninitialized_push.h\"")
     cog.out("  template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<")
     for n in range(1, int(Handlers)):
         cog.out("T%s, " % n)
-    cog.outl("T%s> >::value &&" % int(Handlers))
-    cog.outl("                                                                  !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&")
-    cog.out("                                                                  !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, ")
+    cog.outl("T%s> >::value" % int(Handlers))
+    cog.outl("                                                                    && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value")
+    cog.out("                                                                    && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, ")
     for n in range(1, int(Handlers)):
         cog.out("T%s, " % n)
-    cog.outl("T%s>::value, int>::type>" % int(Handlers))
+    cog.outl("T%s>::value," % int(Handlers))
+    cog.outl("                                                                  int>::type>")
     cog.outl("  explicit message_packet(TMessage&& /*msg*/)")
     cog.outl("    : valid(true)")
     cog.outl("  {")
     generate_static_assert_cpp11(int(Handlers))
     cog.outl("  }")
-    cog.outl("#include \"private/diagnostic_pop.h\"")
-    cog.outl("#else")
-    cog.outl("  //********************************************")
-    cog.outl("#include \"private/diagnostic_uninitialized_push.h\"")
+    cog.outl("    #include \"private/diagnostic_pop.h\"")
+    cog.outl("  #else")
+    cog.outl("      //********************************************")
+    cog.outl("    #include \"private/diagnostic_uninitialized_push.h\"")
     cog.outl("  template <typename TMessage>")
     cog.out("  explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<")
     for n in range(1, int(Handlers)):
         cog.out("T%s, " % n)
-    cog.outl("T%s> >::value &&" % int(Handlers))
-    cog.outl("                                                                       !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&")
-    cog.out("                                                                       !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, ")
+    cog.outl("T%s> >::value" % int(Handlers))
+    cog.outl("                                                                             && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value")
+    cog.out("                                                                             && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, ")
     for n in range(1, int(Handlers)):
         cog.out("T%s, " % n)
-    cog.outl("T%s>::value, int>::type = 0)" % int(Handlers))
+    cog.outl("T%s>::value," % int(Handlers))
+    cog.outl("                                                                           int>::type = 0)")
     cog.outl("    : valid(true)")
     cog.outl("  {")
     generate_static_assert_cpp03(int(Handlers))
     cog.outl("  }")
-    cog.outl("#include \"private/diagnostic_pop.h\"")
-    cog.outl("#endif")
+    cog.outl("    #include \"private/diagnostic_pop.h\"")
+    cog.outl("  #endif")
     cog.outl("")
-    cog.outl("  //**********************************************")
-    cog.outl("#include \"private/diagnostic_uninitialized_push.h\"")
+    cog.outl("    //**********************************************")
+    cog.outl("  #include \"private/diagnostic_uninitialized_push.h\"")
     cog.outl("  message_packet(const message_packet& other)")
     cog.outl("    : valid(other.is_valid())")
     cog.outl("  {")
@@ -712,11 +716,11 @@ namespace etl
     cog.outl("      add_new_message(other.get());")
     cog.outl("    }")
     cog.outl("  }")
-    cog.outl("#include \"private/diagnostic_pop.h\"")
+    cog.outl("  #include \"private/diagnostic_pop.h\"")
     cog.outl("")
-    cog.outl("#if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
-    cog.outl("  //**********************************************")
-    cog.outl("#include \"private/diagnostic_uninitialized_push.h\"")
+    cog.outl("  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
+    cog.outl("      //**********************************************")
+    cog.outl("    #include \"private/diagnostic_uninitialized_push.h\"")
     cog.outl("  message_packet(message_packet&& other)")
     cog.outl("    : valid(other.is_valid())")
     cog.outl("  {")
@@ -725,12 +729,12 @@ namespace etl
     cog.outl("      add_new_message(etl::move(other.get()));")
     cog.outl("    }")
     cog.outl("  }")
-    cog.outl("#include \"private/diagnostic_pop.h\"")
-    cog.outl("#endif")
+    cog.outl("    #include \"private/diagnostic_pop.h\"")
+    cog.outl("  #endif")
     cog.outl("")
-    cog.outl("  //**********************************************")
-    cog.outl("#include \"private/diagnostic_uninitialized_push.h\"")
-    cog.outl("  message_packet& operator =(const message_packet& rhs)")
+    cog.outl("    //**********************************************")
+    cog.outl("  #include \"private/diagnostic_uninitialized_push.h\"")
+    cog.outl("  message_packet& operator=(const message_packet& rhs)")
     cog.outl("  {")
     cog.outl("    delete_current_message();")
     cog.outl("    valid = rhs.is_valid();")
@@ -741,12 +745,12 @@ namespace etl
     cog.outl("")
     cog.outl("    return *this;")
     cog.outl("  }")
-    cog.outl("#include \"private/diagnostic_pop.h\"")
+    cog.outl("  #include \"private/diagnostic_pop.h\"")
     cog.outl("")
-    cog.outl("#if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
-    cog.outl("  //**********************************************")
-    cog.outl("#include \"private/diagnostic_uninitialized_push.h\"")
-    cog.outl("  message_packet& operator =(message_packet&& rhs)")
+    cog.outl("  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
+    cog.outl("      //**********************************************")
+    cog.outl("    #include \"private/diagnostic_uninitialized_push.h\"")
+    cog.outl("  message_packet& operator=(message_packet&& rhs)")
     cog.outl("  {")
     cog.outl("    delete_current_message();")
     cog.outl("    valid = rhs.is_valid();")
@@ -757,8 +761,8 @@ namespace etl
     cog.outl("")
     cog.outl("    return *this;")
     cog.outl("  }")
-    cog.outl("#include \"private/diagnostic_pop.h\"")
-    cog.outl("#endif")
+    cog.outl("    #include \"private/diagnostic_pop.h\"")
+    cog.outl("  #endif")
     cog.outl("")
     cog.outl("  //********************************************")
     cog.outl("  ~message_packet()")
@@ -806,7 +810,7 @@ namespace etl
     cog.outl("  //**********************************************")
     cog.outl("  template <typename TMessage>")
     cog.outl("  static ETL_CONSTEXPR")
-    cog.outl("  typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type")
+    cog.outl("    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type")
     cog.outl("    accepts()")
     cog.outl("  {")
     generate_accepts_return_compile_time_TMessage(int(Handlers))
@@ -834,11 +838,11 @@ namespace etl
     cog.outl("    {")
     cog.outl("      etl::imessage* pmsg = static_cast<etl::imessage*>(data);")
     cog.outl("")
-    cog.outl("#if ETL_HAS_VIRTUAL_MESSAGES")
+    cog.outl("  #if ETL_HAS_VIRTUAL_MESSAGES")
     cog.outl("      pmsg->~imessage();")
-    cog.outl("#else")
+    cog.outl("  #else")
     cog.outl("      delete_message(pmsg);")
-    cog.outl("#endif")
+    cog.outl("  #endif")
     cog.outl("    }")
     cog.outl("  }")
     cog.outl("  #include \"private/diagnostic_pop.h\"")
@@ -859,7 +863,7 @@ namespace etl
     cog.outl("  void add_new_message(const etl::imessage& msg)")
     cog.outl("  {")
     cog.outl("    const size_t id = msg.get_message_id();")
-    cog.outl("    void* p = data;")
+    cog.outl("    void*        p  = data;")
     cog.outl("")
     cog.outl("    switch (id)")
     cog.outl("    {")
@@ -869,12 +873,12 @@ namespace etl
     cog.outl("    }")
     cog.outl("  }")
     cog.outl("")
-    cog.outl("#if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
+    cog.outl("  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
     cog.outl("  //********************************************")
     cog.outl("  void add_new_message(etl::imessage&& msg)")
     cog.outl("  {")
     cog.outl("    const size_t id = msg.get_message_id();")
-    cog.outl("    void* p = data;")
+    cog.outl("    void*        p  = data;")
     cog.outl("")
     cog.outl("    switch (id)")
     cog.outl("    {")
@@ -883,14 +887,14 @@ namespace etl
     cog.outl("      default: ETL_ASSERT_FAIL(ETL_ERROR(unhandled_message_exception)); break;")
     cog.outl("    }")
     cog.outl("  }")
-    cog.outl("#endif")
+    cog.outl("  #endif")
     cog.outl("")
     cog.outl("  typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;")
-    cog.outl("  bool valid;")
+    cog.outl("  bool                                                 valid;")
     cog.outl("};")
 
     ####################################
-    # All of the other specialisations.
+    #All of the other specialisations.
     ####################################
     for n in range(int(Handlers) - 1, 0, -1):
         cog.outl("")
@@ -900,13 +904,16 @@ namespace etl
         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)
+        if n == 1:
+            cog.outl("template <typename T1>")
+        else:
+            cog.out("template <typename T1,")
+            for t in range(2, 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)
@@ -923,25 +930,25 @@ namespace etl
         cog.outl("public:")
         cog.outl("")
 
-        cog.out("#if ETL_USING_CPP11")
+        cog.out("  #if ETL_USING_CPP11")
         cog.outl("")
         cog.out("  using message_types = etl::type_list<")
         for t in range(1, int(n)):
           cog.out("T%s, " % t)
         cog.outl("T%s>;" % int(n))
-        cog.outl("#endif")
+        cog.outl("  #endif")
         cog.outl("")
 
-        cog.outl("  //********************************************")
-        cog.outl("#include \"private/diagnostic_uninitialized_push.h\"")
+        cog.outl("    //********************************************")
+        cog.outl("  #include \"private/diagnostic_uninitialized_push.h\"")
         cog.outl("  ETL_CONSTEXPR message_packet() ETL_NOEXCEPT")
         cog.outl("    : valid(false)")
         cog.outl("  {")
         cog.outl("  }")
-        cog.outl("#include \"private/diagnostic_pop.h\"")
+        cog.outl("  #include \"private/diagnostic_pop.h\"")
         cog.outl("")
-        cog.outl("  //********************************************")
-        cog.outl("#include \"private/diagnostic_uninitialized_push.h\"")
+        cog.outl("    //********************************************")
+        cog.outl("  #include \"private/diagnostic_uninitialized_push.h\"")
         cog.outl("  explicit message_packet(const etl::imessage& msg)")
         cog.outl("  {")
         cog.outl("    if (accepts(msg))")
@@ -956,11 +963,11 @@ namespace etl
         cog.outl("")
         cog.outl("    ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));")
         cog.outl("  }")
-        cog.outl("#include \"private/diagnostic_pop.h\"")
+        cog.outl("  #include \"private/diagnostic_pop.h\"")
         cog.outl("")
-        cog.outl("#if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
-        cog.outl("  //********************************************")
-        cog.outl("#include \"private/diagnostic_uninitialized_push.h\"")
+        cog.outl("  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
+        cog.outl("      //********************************************")
+        cog.outl("    #include \"private/diagnostic_uninitialized_push.h\"")
         cog.outl("  explicit message_packet(etl::imessage&& msg)")
         cog.outl("  {")
         cog.outl("    if (accepts(msg))")
@@ -975,49 +982,51 @@ namespace etl
         cog.outl("")
         cog.outl("    ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));")
         cog.outl("  }")
-        cog.outl("#include \"private/diagnostic_pop.h\"")
-        cog.outl("#endif")
+        cog.outl("    #include \"private/diagnostic_pop.h\"")
+        cog.outl("  #endif")
         cog.outl("")
-        cog.outl("#if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)")
-        cog.outl("  //********************************************")
-        cog.outl("#include \"private/diagnostic_uninitialized_push.h\"")
+        cog.outl("  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)")
+        cog.outl("      //********************************************")
+        cog.outl("    #include \"private/diagnostic_uninitialized_push.h\"")
         cog.out("  template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<")
         for t in range(1, n):
             cog.out("T%s, " % t)
-        cog.outl("T%s> >::value &&" % n)
-        cog.outl("                                                                  !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&")
-        cog.out("                                                                  !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, ")
+        cog.outl("T%s> >::value" % n)
+        cog.outl("                                                                    && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value")
+        cog.out("                                                                    && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, ")
         for t in range(1, n):
             cog.out("T%s, " % t)
-        cog.outl("T%s>::value, int>::type>" % n)
+        cog.outl("T%s>::value," % n)
+        cog.outl("                                                                  int>::type>")
         cog.outl("  explicit message_packet(TMessage&& /*msg*/)")
         cog.outl("    : valid(true)")
         cog.outl("  {")
         generate_static_assert_cpp11(n)
         cog.outl("  }")
-        cog.outl("#include \"private/diagnostic_pop.h\"")
-        cog.outl("#else")
-        cog.outl("  //********************************************")
-        cog.outl("#include \"private/diagnostic_uninitialized_push.h\"")
+        cog.outl("    #include \"private/diagnostic_pop.h\"")
+        cog.outl("  #else")
+        cog.outl("      //********************************************")
+        cog.outl("    #include \"private/diagnostic_uninitialized_push.h\"")
         cog.outl("  template <typename TMessage>")
         cog.out("  explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<")
         for t in range(1, n):
             cog.out("T%s, " % t)
-        cog.outl("T%s> >::value &&" % n)
-        cog.outl("                                                                       !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&")
-        cog.out("                                                                       !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, ")
+        cog.outl("T%s> >::value" % n)
+        cog.outl("                                                                             && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value")
+        cog.out("                                                                             && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, ")
         for t in range(1, n):
             cog.out("T%s, " % t)
-        cog.outl("T%s>::value, int>::type = 0)" % n)
+        cog.outl("T%s>::value," % n)
+        cog.outl("                                                                           int>::type = 0)")
         cog.outl("    : valid(true)")
         cog.outl("  {")
         generate_static_assert_cpp03(n)
         cog.outl("  }")
-        cog.outl("#include \"private/diagnostic_pop.h\"")
-        cog.outl("#endif")
+        cog.outl("    #include \"private/diagnostic_pop.h\"")
+        cog.outl("  #endif")
         cog.outl("")
-        cog.outl("  //**********************************************")
-        cog.outl("#include \"private/diagnostic_uninitialized_push.h\"")
+        cog.outl("    //**********************************************")
+        cog.outl("  #include \"private/diagnostic_uninitialized_push.h\"")
         cog.outl("  message_packet(const message_packet& other)")
         cog.outl("    : valid(other.is_valid())")
         cog.outl("  {")
@@ -1026,11 +1035,11 @@ namespace etl
         cog.outl("      add_new_message(other.get());")
         cog.outl("    }")
         cog.outl("  }")
-        cog.outl("#include \"private/diagnostic_pop.h\"")
+        cog.outl("  #include \"private/diagnostic_pop.h\"")
         cog.outl("")
-        cog.outl("#if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
-        cog.outl("  //**********************************************")
-        cog.outl("#include \"private/diagnostic_uninitialized_push.h\"")
+        cog.outl("  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
+        cog.outl("      //**********************************************")
+        cog.outl("    #include \"private/diagnostic_uninitialized_push.h\"")
         cog.outl("  message_packet(message_packet&& other)")
         cog.outl("    : valid(other.is_valid())")
         cog.outl("  {")
@@ -1039,12 +1048,12 @@ namespace etl
         cog.outl("      add_new_message(etl::move(other.get()));")
         cog.outl("    }")
         cog.outl("  }")
-        cog.outl("#include \"private/diagnostic_pop.h\"")
-        cog.outl("#endif")
+        cog.outl("    #include \"private/diagnostic_pop.h\"")
+        cog.outl("  #endif")
         cog.outl("")
-        cog.outl("  //**********************************************")
-        cog.outl("#include \"private/diagnostic_uninitialized_push.h\"")
-        cog.outl("  message_packet& operator =(const message_packet& rhs)")
+        cog.outl("    //**********************************************")
+        cog.outl("  #include \"private/diagnostic_uninitialized_push.h\"")
+        cog.outl("  message_packet& operator=(const message_packet& rhs)")
         cog.outl("  {")
         cog.outl("    delete_current_message();")
         cog.outl("    valid = rhs.is_valid();")
@@ -1055,12 +1064,12 @@ namespace etl
         cog.outl("")
         cog.outl("    return *this;")
         cog.outl("  }")
-        cog.outl("#include \"private/diagnostic_pop.h\"")
+        cog.outl("  #include \"private/diagnostic_pop.h\"")
         cog.outl("")
-        cog.outl("#if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
-        cog.outl("  //**********************************************")
-        cog.outl("#include \"private/diagnostic_uninitialized_push.h\"")
-        cog.outl("  message_packet& operator =(message_packet&& rhs)")
+        cog.outl("  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
+        cog.outl("      //**********************************************")
+        cog.outl("    #include \"private/diagnostic_uninitialized_push.h\"")
+        cog.outl("  message_packet& operator=(message_packet&& rhs)")
         cog.outl("  {")
         cog.outl("    delete_current_message();")
         cog.outl("    valid = rhs.is_valid();")
@@ -1071,8 +1080,8 @@ namespace etl
         cog.outl("")
         cog.outl("    return *this;")
         cog.outl("  }")
-        cog.outl("#include \"private/diagnostic_pop.h\"")
-        cog.outl("#endif")
+        cog.outl("    #include \"private/diagnostic_pop.h\"")
+        cog.outl("  #endif")
         cog.outl("")
         cog.outl("  //********************************************")
         cog.outl("  ~message_packet()")
@@ -1120,7 +1129,7 @@ namespace etl
         cog.outl("  //**********************************************")
         cog.outl("  template <typename TMessage>")
         cog.outl("  static ETL_CONSTEXPR")
-        cog.outl("  typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type")
+        cog.outl("    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type")
         cog.outl("    accepts()")
         cog.outl("  {")
         generate_accepts_return_compile_time_TMessage(n)
@@ -1148,12 +1157,11 @@ namespace etl
         cog.outl("    {")
         cog.outl("      etl::imessage* pmsg = static_cast<etl::imessage*>(data);")
         cog.outl("")
-        cog.outl("")
-        cog.outl("#if ETL_HAS_VIRTUAL_MESSAGES")
+        cog.outl("  #if ETL_HAS_VIRTUAL_MESSAGES")
         cog.outl("      pmsg->~imessage();")
-        cog.outl("#else")
+        cog.outl("  #else")
         cog.outl("      delete_message(pmsg);")
-        cog.outl("#endif")
+        cog.outl("  #endif")
         cog.outl("    }")
         cog.outl("  }")
         cog.outl("  #include \"private/diagnostic_pop.h\"")
@@ -1174,7 +1182,7 @@ namespace etl
         cog.outl("  void add_new_message(const etl::imessage& msg)")
         cog.outl("  {")
         cog.outl("    const size_t id = msg.get_message_id();")
-        cog.outl("    void* p = data;")
+        cog.outl("    void*        p  = data;")
         cog.outl("")
         cog.outl("    switch (id)")
         cog.outl("    {")
@@ -1184,12 +1192,12 @@ namespace etl
         cog.outl("    }")
         cog.outl("  }")
         cog.outl("")
-        cog.outl("#if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
+        cog.outl("  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
         cog.outl("  //********************************************")
         cog.outl("  void add_new_message(etl::imessage&& msg)")
         cog.outl("  {")
         cog.outl("    const size_t id = msg.get_message_id();")
-        cog.outl("    void* p = data;")
+        cog.outl("    void*        p  = data;")
         cog.outl("")
         cog.outl("    switch (id)")
         cog.outl("    {")
@@ -1198,10 +1206,10 @@ namespace etl
         cog.outl("      default: break;")
         cog.outl("    }")
         cog.outl("  }")
-        cog.outl("#endif")
+        cog.outl("  #endif")
         cog.outl("")
         cog.outl("  typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;")
-        cog.outl("  bool valid;")
+        cog.outl("  bool                                                 valid;")
         cog.outl("};")
   ]]]*/
   /*[[[end]]]*/
@@ -1215,9 +1223,9 @@ namespace etl
   {
   public:
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<>;
-#endif
+    #endif
 
     ETL_CONSTEXPR message_packet() ETL_NOEXCEPT
       : valid(false)
@@ -1253,7 +1261,7 @@ namespace etl
 
     enum
     {
-      SIZE = 0U,
+      SIZE      = 0U,
       ALIGNMENT = 1U
     };
 
@@ -1261,7 +1269,7 @@ namespace etl
 
     bool valid;
   };
-#endif
-}
+  #endif
+} // namespace etl
 
 #endif
diff --git a/include/etl/generators/message_router_generator.h b/include/etl/generators/message_router_generator.h
index eeec698f..8106be25 100644
--- a/include/etl/generators/message_router_generator.h
+++ b/include/etl/generators/message_router_generator.h
@@ -31,7 +31,7 @@ import cog
 cog.outl("#if 0")
 ]]]*/
 /*[[[end]]]*/
-#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+  #error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
 /*[[[cog
 import cog
 cog.outl("#endif")
@@ -61,25 +61,25 @@ cog.outl("//********************************************************************
 //***************************************************************************
 
 #ifndef ETL_MESSAGE_ROUTER_INCLUDED
-#define ETL_MESSAGE_ROUTER_INCLUDED
+  #define ETL_MESSAGE_ROUTER_INCLUDED
 
-#include "platform.h"
-#include "message.h"
-#include "shared_message.h"
-#include "message_packet.h"
-#include "message_types.h"
-#include "alignment.h"
-#include "error_handler.h"
-#include "exception.h"
-#include "largest.h"
-#include "nullptr.h"
-#include "placement_new.h"
-#include "successor.h"
-#include "type_traits.h"
-#include "type_list.h"
-#include "array.h"
+  #include "platform.h"
+  #include "alignment.h"
+  #include "array.h"
+  #include "error_handler.h"
+  #include "exception.h"
+  #include "largest.h"
+  #include "message.h"
+  #include "message_packet.h"
+  #include "message_types.h"
+  #include "nullptr.h"
+  #include "placement_new.h"
+  #include "shared_message.h"
+  #include "successor.h"
+  #include "type_list.h"
+  #include "type_traits.h"
 
-#include <stdint.h>
+  #include <stdint.h>
 
 namespace etl
 {
@@ -120,7 +120,8 @@ namespace etl
     template <typename... TMessageTypes>
     class traits
     {
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
+
     private:
 
       using message_id_sequence = etl::index_sequence<TMessageTypes::ID...>;
@@ -131,10 +132,10 @@ namespace etl
       using message_types        = etl::type_list<TMessageTypes...>;
       using sorted_message_types = etl::type_list_sort_t<message_types, etl::compare_message_id_less>;
 
-      static_assert(etl::type_list_is_unique<message_types>::value,                    "All TMessageTypes must be unique");
+      static_assert(etl::type_list_is_unique<message_types>::value, "All TMessageTypes must be unique");
       static_assert(etl::type_list_all_of<message_types, etl::is_message_type>::value, "All TMessageTypes must satisfy the condition etl::is_message_type");
-      static_assert(etl::index_sequence_is_unique<message_id_sequence>::value,         "All message IDs must be unique");
-#endif
+      static_assert(etl::index_sequence_is_unique<message_id_sequence>::value, "All message IDs must be unique");
+  #endif
     };
 
     //***************************************************************************
@@ -148,13 +149,13 @@ namespace etl
     {
     public:
 
-#if ETL_USING_CPP11
-      using message_packet = etl::message_packet<>;
-      using message_types = etl::type_list<>;
+  #if ETL_USING_CPP11
+      using message_packet       = etl::message_packet<>;
+      using message_types        = etl::type_list<>;
       using sorted_message_types = etl::type_list<>;
-#endif
+  #endif
     };
-  }
+  } // namespace private_message_router
 
   //***************************************************************************
   /// Forward declare null message router functionality.
@@ -171,11 +172,11 @@ namespace etl
   public:
 
     virtual ~imessage_router() {}
-    virtual void receive(const etl::imessage&) = 0;
+    virtual void receive(const etl::imessage&)    = 0;
     virtual bool accepts(etl::message_id_t) const = 0;
-    virtual bool is_null_router() const = 0;
-    virtual bool is_producer() const = 0;
-    virtual bool is_consumer() const = 0;
+    virtual bool is_null_router() const           = 0;
+    virtual bool is_producer() const              = 0;
+    virtual bool is_consumer() const              = 0;
 
     //********************************************
     virtual void receive(etl::message_router_id_t destination_router_id, const etl::imessage& message)
@@ -240,16 +241,16 @@ namespace etl
 
     // Disabled.
     imessage_router(const imessage_router&);
-    imessage_router& operator =(const imessage_router&);
+    imessage_router& operator=(const imessage_router&);
 
-    etl::message_router_id_t  message_router_id;
+    etl::message_router_id_t message_router_id;
   };
 
   //***************************************************************************
   /// This router can be used as a sink for messages or a 'null source' router.
   //***************************************************************************
   class null_message_router : public imessage_router
-                            , public private_message_router::traits<>
+    , public private_message_router::traits<>
   {
   public:
 
@@ -328,7 +329,7 @@ namespace etl
   /// This router can be used as a producer-only of messages, such an interrupt routine.
   //***************************************************************************
   class message_producer : public imessage_router
-                         , public private_message_router::traits<>
+    , public private_message_router::traits<>
   {
   public:
 
@@ -416,7 +417,7 @@ namespace etl
   //***************************************************************************
   template <typename TRouter, typename TMessage>
   static
-  typename etl::enable_if<etl::is_message_router<TRouter>::value && etl::is_message<TMessage>::value, void>::type
+    typename etl::enable_if<etl::is_message_router<TRouter>::value && etl::is_message<TMessage>::value, void>::type
     send_message(TRouter&        destination,
                  const TMessage& message)
   {
@@ -428,7 +429,7 @@ namespace etl
   //***************************************************************************
   template <typename TRouter>
   static
-  typename etl::enable_if<etl::is_message_router<TRouter>::value, void>::type
+    typename etl::enable_if<etl::is_message_router<TRouter>::value, void>::type
     send_message(TRouter&            destination,
                  etl::shared_message message)
   {
@@ -440,7 +441,7 @@ namespace etl
   //***************************************************************************
   template <typename TRouter, typename TMessage>
   static
-  typename etl::enable_if<etl::is_message_router<TRouter>::value && etl::is_message<TMessage>::value, void>::type
+    typename etl::enable_if<etl::is_message_router<TRouter>::value && etl::is_message<TMessage>::value, void>::type
     send_message(TRouter&                 destination,
                  etl::message_router_id_t id,
                  const TMessage&          message)
@@ -453,7 +454,7 @@ namespace etl
   //***************************************************************************
   template <typename TRouter>
   static
-  typename etl::enable_if<etl::is_message_router<TRouter>::value, void>::type
+    typename etl::enable_if<etl::is_message_router<TRouter>::value, void>::type
     send_message(TRouter&                 destination,
                  etl::message_router_id_t id,
                  etl::shared_message      message)
@@ -464,13 +465,13 @@ namespace etl
   //*************************************************************************************************
   // For C++11 and above.
   //*************************************************************************************************
-#if ETL_USING_CPP11 && !defined(ETL_MESSAGE_ROUTER_FORCE_CPP03_IMPLEMENTATION)
+  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_ROUTER_FORCE_CPP03_IMPLEMENTATION)
   //***************************************************************************
   // The definition for all message types.
   //***************************************************************************
   template <typename TDerived, typename... TMessageTypes>
   class message_router : public imessage_router
-                       , public private_message_router::traits<TMessageTypes...>
+    , public private_message_router::traits<TMessageTypes...>
   {
   public:
 
@@ -525,8 +526,8 @@ namespace etl
     //***********************************************
     void receive(const etl::imessage& msg) ETL_OVERRIDE
     {
-      etl::message_id_t id = msg.get_message_id();
-      size_t index = Number_Of_Messages;
+      etl::message_id_t id    = msg.get_message_id();
+      size_t            index = Number_Of_Messages;
 
       // The IDs are sorted, so an ID less than the first is not handled by this router.
       if (id >= Message_Id_Start)
@@ -548,9 +549,9 @@ namespace etl
         }
         else
         {
-#include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
           static_cast<TDerived*>(this)->on_receive_unknown(msg);
-#include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
         }
       }
     }
@@ -564,9 +565,9 @@ namespace etl
     template <typename TMessage, typename etl::enable_if<etl::is_one_of<TMessage, TMessageTypes...>::value, int>::type = 0>
     void receive(const TMessage& msg)
     {
-#include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
-#include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     //**********************************************
@@ -575,8 +576,7 @@ namespace etl
     /// \param msg The message.
     /// Enabled if TMessage is a message type, but not in the message type list.
     //**********************************************
-    template <typename TMessage, typename etl::enable_if<etl::is_message<TMessage>::value &&
-                                                         !etl::is_one_of<TMessage, TMessageTypes...>::value, int>::type = 0>
+    template <typename TMessage, typename etl::enable_if<etl::is_message<TMessage>::value && !etl::is_one_of<TMessage, TMessageTypes...>::value, int>::type = 0>
     void receive(const TMessage& msg)
     {
       if (has_successor())
@@ -585,9 +585,9 @@ namespace etl
       }
       else
       {
-#include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
-#include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
       }
     }
 
@@ -662,9 +662,7 @@ namespace etl
 
     template <size_t Index>
     struct contiguous_impl<Index, false>
-      : etl::bool_constant<(etl::type_list_type_at_index_t<sorted_message_types, Index>::ID + 1U ==
-                            etl::type_list_type_at_index_t<sorted_message_types, Index + 1U>::ID) &&
-                            contiguous_impl<Index + 1U>::value>
+      : etl::bool_constant<(etl::type_list_type_at_index_t<sorted_message_types, Index>::ID + 1U == etl::type_list_type_at_index_t<sorted_message_types, Index + 1U>::ID) && contiguous_impl<Index + 1U>::value>
     {
     };
 
@@ -701,7 +699,7 @@ namespace etl
     template <size_t... Indices>
     static constexpr message_dispatch_table_t make_message_dispatch_table(etl::index_sequence<Indices...>)
     {
-      return message_dispatch_table_t{ { get_message_handler<Indices>()... } };
+      return message_dispatch_table_t{{get_message_handler<Indices>()...}};
     }
 
     //**********************************************
@@ -721,7 +719,7 @@ namespace etl
     template <size_t... Indices>
     static constexpr message_id_table_t make_message_id_table(etl::index_sequence<Indices...>)
     {
-      return message_id_table_t{ { get_message_id_from_index<Indices>()... } };
+      return message_id_table_t{{get_message_id_from_index<Indices>()...}};
     }
 
     //**********************************************
@@ -732,7 +730,7 @@ namespace etl
     //**********************************************
     static size_t get_dispatch_index_from_message_id(etl::message_id_t id)
     {
-      if ETL_IF_CONSTEXPR(Message_Ids_Are_Contiguous)
+      if ETL_IF_CONSTEXPR (Message_Ids_Are_Contiguous)
       {
         // The IDs are contiguous, so we can calculate the index directly.
         return static_cast<size_t>(id - Message_Id_Start);
@@ -786,7 +784,7 @@ namespace etl
       etl::message_router<TDerived, TMessageTypes...>::make_message_id_table(etl::make_index_sequence<etl::message_router<TDerived, TMessageTypes...>::Number_Of_Messages>{});
   };
 
-#if ETL_USING_CPP11 && !ETL_USING_CPP17
+    #if ETL_USING_CPP11 && !ETL_USING_CPP17
   template <typename TDerived, typename... TMessageTypes>
   constexpr const typename etl::message_router<TDerived, TMessageTypes...>::message_dispatch_table_t
     etl::message_router<TDerived, TMessageTypes...>::message_dispatch_table;
@@ -794,14 +792,14 @@ namespace etl
   template <typename TDerived, typename... TMessageTypes>
   constexpr const typename etl::message_router<TDerived, TMessageTypes...>::message_id_table_t
     etl::message_router<TDerived, TMessageTypes...>::message_id_table;
-#endif
+    #endif
 
   //***************************************************************************
   // The definition of a message_router for zero message types.
   //***************************************************************************
   template <typename TDerived>
   class message_router<TDerived> : public imessage_router
-                                 , public private_message_router::traits<>
+    , public private_message_router::traits<>
   {
   public:
 
@@ -850,12 +848,12 @@ namespace etl
     //***********************************************
     void receive(const etl::imessage& msg) ETL_OVERRIDE
     {
-#include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       if (has_successor())
       {
         get_successor().receive(msg);
       }
-#include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     //**********************************************
@@ -912,7 +910,7 @@ namespace etl
   template <typename TDerived, typename TTypeList>
   using message_router_from_type_list_t = typename message_router_from_type_list<TDerived, TTypeList>::type;
 
-#else
+  #else
   //*************************************************************************************************
   // For C++03/98.
   //*************************************************************************************************
@@ -935,7 +933,7 @@ namespace etl
               cog.out(" ")
       cog.outl("typename T%s = void>" % int(Handlers))
       cog.out("class message_router")
-      cog.outl("  : public imessage_router")
+      cog.outl(" : public imessage_router")
       cog.outl("{")
       cog.outl("public:")
       cog.outl("")
@@ -945,12 +943,12 @@ namespace etl
       cog.outl("T%s> message_packet;" % int(Handlers))
       cog.outl("")
 
-      cog.outl("#if ETL_USING_CPP11")
+      cog.outl("  #if ETL_USING_CPP11")
       cog.out("  using message_types = etl::type_list<")
       for n in range(1, int(Handlers)):
           cog.out("T%s, " % n)
       cog.outl("T%s>;" % int(Handlers))
-      cog.outl("#endif")
+      cog.outl("  #endif")
       cog.outl("")
 
       cog.outl("  //**********************************************")
@@ -986,7 +984,7 @@ namespace etl
       cog.outl("  {")
       cog.outl("    const etl::message_id_t id = msg.get_message_id();")
       cog.outl("")
-      cog.outl("#include \"etl/private/diagnostic_array_bounds_push.h\"")
+      cog.outl("  #include \"etl/private/diagnostic_array_bounds_push.h\"")
       cog.outl("    switch (id)")
       cog.outl("    {")
       for n in range(1, int(Handlers) + 1):
@@ -994,19 +992,19 @@ namespace etl
           cog.out(" static_cast<TDerived*>(this)->on_receive(static_cast<const T%d&>(msg));" % n)
           cog.outl(" break;")
       cog.outl("      default:")
-      cog.outl("      {")
-      cog.outl("         if (has_successor())")
-      cog.outl("         {")
-      cog.outl("           get_successor().receive(msg);")
-      cog.outl("         }")
-      cog.outl("         else")
-      cog.outl("         {")
-      cog.outl("           static_cast<TDerived*>(this)->on_receive_unknown(msg);")
-      cog.outl("         }")
-      cog.outl("         break;")
-      cog.outl("      }")
+      cog.outl("        {")
+      cog.outl("          if (has_successor())")
+      cog.outl("          {")
+      cog.outl("            get_successor().receive(msg);")
+      cog.outl("          }")
+      cog.outl("          else")
+      cog.outl("          {")
+      cog.outl("            static_cast<TDerived*>(this)->on_receive_unknown(msg);")
+      cog.outl("          }")
+      cog.outl("          break;")
+      cog.outl("        }")
       cog.outl("    }")
-      cog.outl("#include \"etl/private/diagnostic_pop.h\"")
+      cog.outl("  #include \"etl/private/diagnostic_pop.h\"")
       cog.outl("  }")
       cog.outl("")
       cog.outl("  template <typename TMessage>")
@@ -1016,9 +1014,9 @@ namespace etl
       cog.outl("T%s>::value, void>::type" % int(Handlers))
       cog.outl("    receive(const TMessage& msg)")
       cog.outl("  {")
-      cog.outl("#include \"etl/private/diagnostic_array_bounds_push.h\"")
+      cog.outl("  #include \"etl/private/diagnostic_array_bounds_push.h\"")
       cog.outl("    static_cast<TDerived*>(this)->on_receive(msg);")
-      cog.outl("#include \"etl/private/diagnostic_pop.h\"")
+      cog.outl("  #include \"etl/private/diagnostic_pop.h\"")
       cog.outl("  }")
       cog.outl("")
       cog.outl("  template <typename TMessage>")
@@ -1034,9 +1032,9 @@ namespace etl
       cog.outl("    }")
       cog.outl("    else")
       cog.outl("    {")
-      cog.outl("#include \"etl/private/diagnostic_array_bounds_push.h\"")
+      cog.outl("  #include \"etl/private/diagnostic_array_bounds_push.h\"")
       cog.outl("      static_cast<TDerived*>(this)->on_receive_unknown(msg);")
-      cog.outl("#include \"etl/private/diagnostic_pop.h\"")
+      cog.outl("  #include \"etl/private/diagnostic_pop.h\"")
       cog.outl("    }")
       cog.outl("  }")
       cog.outl("")
@@ -1047,24 +1045,20 @@ namespace etl
       cog.outl("  {")
       cog.outl("    switch (id)")
       cog.outl("    {")
-      cog.out("     ")
       for n in range(1, int(Handlers) + 1):
-          cog.out(" case T%d::ID:" % n)
-          if n % 8 == 0:
-              cog.outl("")
-              cog.out("     ")
-      cog.outl("   return true;")
+          cog.outl("      case T%d::ID:" % n)
+      cog.outl("        return true;")
       cog.outl("      default:")
-      cog.outl("      {")
-      cog.outl("        if (has_successor())")
       cog.outl("        {")
-      cog.outl("          return get_successor().accepts(id);")
+      cog.outl("          if (has_successor())")
+      cog.outl("          {")
+      cog.outl("            return get_successor().accepts(id);")
+      cog.outl("          }")
+      cog.outl("          else")
+      cog.outl("          {")
+      cog.outl("            return false;")
+      cog.outl("          }")
       cog.outl("        }")
-      cog.outl("        else")
-      cog.outl("        {")
-      cog.outl("          return false;")
-      cog.outl("        }")
-      cog.outl("      }")
       cog.outl("    }")
       cog.outl("  }")
       cog.outl("")
@@ -1120,22 +1114,22 @@ namespace etl
                   cog.outl("")
                   cog.out("               ")
           cog.outl("void>")
-          cog.outl(" : public imessage_router")
+          cog.outl("  : public imessage_router")
           cog.outl("{")
           cog.outl("public:")
           cog.outl("")
           cog.out("  typedef etl::message_packet<")
           for t in range(1, n):
               cog.out("T%s, " % t)
-          cog.outl(" T%s> message_packet;" % n)
+          cog.outl("T%s> message_packet;" % n)
           cog.outl("")
 
-          cog.outl("#if ETL_USING_CPP11")
+          cog.outl("  #if ETL_USING_CPP11")
           cog.out("  using message_types = etl::type_list<")
           for t in range(1, n):
               cog.out("T%s, " % t)
           cog.outl("T%s>;" % n)
-          cog.outl("#endif")
+          cog.outl("  #endif")
           cog.outl("")
 
           cog.outl("  //**********************************************")
@@ -1171,7 +1165,7 @@ namespace etl
           cog.outl("  {")
           cog.outl("    const size_t id = msg.get_message_id();")
           cog.outl("")
-          cog.outl("#include \"etl/private/diagnostic_array_bounds_push.h\"")
+          cog.outl("  #include \"etl/private/diagnostic_array_bounds_push.h\"")
           cog.outl("    switch (id)")
           cog.outl("    {")
           for t in range(1, n + 1):
@@ -1179,19 +1173,19 @@ namespace etl
               cog.out(" static_cast<TDerived*>(this)->on_receive(static_cast<const T%d&>(msg));" % t)
               cog.outl(" break;")
           cog.outl("      default:")
-          cog.outl("      {")
-          cog.outl("         if (has_successor())")
-          cog.outl("         {")
-          cog.outl("           get_successor().receive(msg);")
-          cog.outl("         }")
-          cog.outl("         else")
-          cog.outl("         {")
-          cog.outl("           static_cast<TDerived*>(this)->on_receive_unknown(msg);")
-          cog.outl("         }")
-          cog.outl("         break;")
-          cog.outl("      }")
+          cog.outl("        {")
+          cog.outl("          if (has_successor())")
+          cog.outl("          {")
+          cog.outl("            get_successor().receive(msg);")
+          cog.outl("          }")
+          cog.outl("          else")
+          cog.outl("          {")
+          cog.outl("            static_cast<TDerived*>(this)->on_receive_unknown(msg);")
+          cog.outl("          }")
+          cog.outl("          break;")
+          cog.outl("        }")
           cog.outl("    }")
-          cog.outl("#include \"etl/private/diagnostic_pop.h\"")
+          cog.outl("  #include \"etl/private/diagnostic_pop.h\"")
           cog.outl("  }")
           cog.outl("")
           cog.outl("  template <typename TMessage>")
@@ -1201,9 +1195,9 @@ namespace etl
           cog.outl("T%s>::value, void>::type" % n)
           cog.outl("    receive(const TMessage& msg)")
           cog.outl("  {")
-          cog.outl("#include \"etl/private/diagnostic_array_bounds_push.h\"")
+          cog.outl("  #include \"etl/private/diagnostic_array_bounds_push.h\"")
           cog.outl("    static_cast<TDerived*>(this)->on_receive(msg);")
-          cog.outl("#include \"etl/private/diagnostic_pop.h\"")
+          cog.outl("  #include \"etl/private/diagnostic_pop.h\"")
           cog.outl("  }")
           cog.outl("")
           cog.outl("  template <typename TMessage>")
@@ -1219,13 +1213,12 @@ namespace etl
           cog.outl("    }")
           cog.outl("    else")
           cog.outl("    {")
-          cog.outl("#include \"etl/private/diagnostic_array_bounds_push.h\"")
+          cog.outl("  #include \"etl/private/diagnostic_array_bounds_push.h\"")
           cog.outl("      static_cast<TDerived*>(this)->on_receive_unknown(msg);")
-          cog.outl("#include \"etl/private/diagnostic_pop.h\"")
+          cog.outl("  #include \"etl/private/diagnostic_pop.h\"")
           cog.outl("    }")
           cog.outl("  }")
           cog.outl("")
-          cog.outl("")
           cog.outl("  //**********************************************")
           cog.outl("  using imessage_router::accepts;")
           cog.outl("")
@@ -1233,26 +1226,20 @@ namespace etl
           cog.outl("  {")
           cog.outl("    switch (id)")
           cog.outl("    {")
-          cog.out("     ")
           for t in range(1, n + 1):
-              cog.out(" case T%d::ID:" % t)
-              if t % 8 == 0:
-                  cog.outl("")
-                  if t != n:
-                      cog.out("     ")
-          cog.outl("")
+              cog.outl("      case T%d::ID:" % t)
           cog.outl("        return true;")
           cog.outl("      default:")
-          cog.outl("      {")
-          cog.outl("        if (has_successor())")
           cog.outl("        {")
-          cog.outl("          return get_successor().accepts(id);")
+          cog.outl("          if (has_successor())")
+          cog.outl("          {")
+          cog.outl("            return get_successor().accepts(id);")
+          cog.outl("          }")
+          cog.outl("          else")
+          cog.outl("          {")
+          cog.outl("            return false;")
+          cog.outl("          }")
           cog.outl("        }")
-          cog.outl("        else")
-          cog.outl("        {")
-          cog.outl("          return false;")
-          cog.outl("        }")
-          cog.outl("      }")
           cog.outl("    }")
           cog.outl("  }")
           cog.outl("")
@@ -1288,9 +1275,9 @@ namespace etl
 
     typedef etl::message_packet<> message_packet;
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<>;
-#endif
+    #endif
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -1323,12 +1310,12 @@ namespace etl
 
     void receive(const etl::imessage& msg) ETL_OVERRIDE
     {
-#include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       if (has_successor())
       {
         get_successor().receive(msg);
       }
-#include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     //**********************************************
@@ -1364,7 +1351,7 @@ namespace etl
       return true;
     }
   };
-#endif
-}
+  #endif
+} // namespace etl
 
 #endif
diff --git a/include/etl/generators/smallest_generator.h b/include/etl/generators/smallest_generator.h
index 1690119c..46e3ce2b 100644
--- a/include/etl/generators/smallest_generator.h
+++ b/include/etl/generators/smallest_generator.h
@@ -33,7 +33,7 @@ import cog
 cog.outl("#if 0")
 ]]]*/
 /*[[[end]]]*/
-#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+  #error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
 /*[[[cog
 import cog
 cog.outl("#endif")
@@ -63,19 +63,19 @@ cog.outl("//********************************************************************
 //***************************************************************************
 
 #ifndef ETL_SMALLEST_INCLUDED
-#define ETL_SMALLEST_INCLUDED
+  #define ETL_SMALLEST_INCLUDED
 
-#include "platform.h"
-#include "integral_limits.h"
+  #include "platform.h"
+  #include "integral_limits.h"
 
-#include <stdint.h>
+  #include <stdint.h>
 
 ///\defgroup smallest smallest
 ///\ingroup utilities
 
 namespace etl
 {
-#if ETL_USING_CPP11 && !defined(ETL_SMALLEST_TYPE_FORCE_CPP03_IMPLEMENTATION)
+  #if ETL_USING_CPP11 && !defined(ETL_SMALLEST_TYPE_FORCE_CPP03_IMPLEMENTATION)
   //***************************************************************************
   /// Template to determine the largest type and size.
   /// Defines 'value_type' which is the type of the largest parameter.
@@ -95,9 +95,9 @@ namespace etl
     // Set 'type' to be the smallest of the first parameter and any of the others.
     // This is recursive.
     using type = typename etl::conditional<(etl::size_of<T1>::value < etl::size_of<smallest_other>::value), // Boolean
-                                            T1,                                                             // TrueType
-                                            smallest_other>                                                 // FalseType
-                                            ::type;                                                         // The smallest type of the two.
+                                           T1,                                                              // TrueType
+                                           smallest_other>                                                  // FalseType
+      ::type;                                                                                               // The smallest type of the two.
 
     // The size of the smallest type.
     enum
@@ -122,18 +122,18 @@ namespace etl
     };
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename... T>
   using smallest_type_t = typename smallest_type<T...>::type;
-#endif
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename... T>
   constexpr size_t smallest_type_v = smallest_type<T...>::size;
-#endif
+    #endif
 
-#else
-  /*[[[cog
+  #else
+    /*[[[cog
   import cog
   cog.outl("//***************************************************************************")
   cog.outl("/// Template to determine the smallest type and size.")
@@ -142,13 +142,13 @@ namespace etl
   cog.outl("/// Defines 'size' which is the size of the smallest parameter.")
   cog.outl("///\\ingroup smallest")
   cog.outl("//***************************************************************************")
-  cog.out("template <typename T1, ")
+  cog.out("template <typename T1,")
   for n in range(2, int(NTypes)):
-      cog.out("typename T%s = void, " % n)
+      cog.out(" typename T%s = void," % n)
       if n % 4 == 0:
           cog.outl("")
-          cog.out("          ")
-  cog.outl("typename T%s = void>" % int(NTypes))
+          cog.out("         ")
+  cog.outl(" typename T%s = void>" % int(NTypes))
   cog.outl("struct smallest_type")
   cog.outl("{")
   cog.outl("private:")
@@ -165,7 +165,7 @@ namespace etl
   cog.outl("    typedef TrueType type;")
   cog.outl("  };")
   cog.outl("")
-  cog.outl("  // Specialisation for 'false'. ")
+  cog.outl("  // Specialisation for 'false'.")
   cog.outl("  // Defines 'type' as 'FalseType'.")
   cog.outl("  template <typename TrueType, typename FalseType>")
   cog.outl("  struct choose_type<false, TrueType, FalseType>")
@@ -175,21 +175,21 @@ namespace etl
   cog.outl("")
   cog.outl("public:")
   cog.outl("")
-  cog.outl("  // Define 'smallest_other' as 'smallest_type' with all but the first parameter. ")
-  cog.out("  typedef typename smallest_type<")
-  for n in range(2, int(NTypes)):
-      cog.out("T%s, " % n)
+  cog.outl("  // Define 'smallest_other' as 'smallest_type' with all but the first parameter.")
+  cog.out("  typedef typename smallest_type<T2,")
+  for n in range(3, int(NTypes)):
+      cog.out(" T%s," % n)
       if n % 16 == 0:
           cog.outl("")
           cog.out("                                ")
-  cog.outl("T%s>::type smallest_other;" % int(NTypes))
+  cog.outl(" T%s>::type smallest_other;" % int(NTypes))
   cog.outl("")
   cog.outl("  // Set 'type' to be the smallest of the first parameter and any of the others.")
   cog.outl("  // This is recursive.")
   cog.outl("  typedef typename choose_type<(sizeof(T1) < sizeof(smallest_other)), // Boolean")
-  cog.outl("                                T1,                                   // TrueType")
-  cog.outl("                                smallest_other>                       // FalseType")
-  cog.outl("                                ::type type;                          // The smallest type of the two.")
+  cog.outl("                               T1,                                    // TrueType")
+  cog.outl("                               smallest_other>                        // FalseType")
+  cog.outl("    ::type type;                                                      // The smallest type of the two.")
   cog.outl("")
   cog.outl("  // The size of the smallest type.")
   cog.outl("  enum")
@@ -202,13 +202,13 @@ namespace etl
   cog.outl("// Specialisation for one template parameter.")
   cog.outl("//***************************************************************************")
   cog.outl("template <typename T1>")
-  cog.out("struct smallest_type<T1,   ")
+  cog.out("struct smallest_type<T1,")
   for n in range(2, int(NTypes)):
-      cog.out("void, ")
+      cog.out(" void,")
       if n % 8 == 0:
           cog.outl("")
-          cog.out("                     ")
-  cog.outl("void>")
+          cog.out("                    ")
+  cog.outl(" void>")
   cog.outl("{")
   cog.outl("  typedef T1 type;")
   cog.outl("")
@@ -218,8 +218,8 @@ namespace etl
   cog.outl("  };")
   cog.outl("};")
   ]]]*/
-  /*[[[end]]]*/
-#endif
+    /*[[[end]]]*/
+  #endif
 
   namespace private_smallest
   {
@@ -256,7 +256,7 @@ namespace etl
       typedef uint_least32_t type;
     };
 
-#if ETL_USING_64BIT_TYPES
+  #if ETL_USING_64BIT_TYPES
     //*************************************************************************
     // Greater than 32 bits.
     //*************************************************************************
@@ -265,7 +265,7 @@ namespace etl
     {
       typedef uint_least64_t type;
     };
-#endif
+  #endif
 
     //*************************************************************************
     // Determine the type to hold the number of bits based on the index.
@@ -300,7 +300,7 @@ namespace etl
       typedef int_least32_t type;
     };
 
-#if ETL_USING_64BIT_TYPES
+  #if ETL_USING_64BIT_TYPES
     //*************************************************************************
     // Greater than 32 bits.
     //*************************************************************************
@@ -309,8 +309,8 @@ namespace etl
     {
       typedef int_least64_t type;
     };
-#endif
-  }
+  #endif
+  } // namespace private_smallest
 
   //***************************************************************************
   /// Template to determine the smallest unsigned int type that can contain a
@@ -324,9 +324,7 @@ namespace etl
   private:
 
     // Determines the index of the best unsigned type for the required number of bits.
-    static ETL_CONSTANT int TYPE_INDEX = ((NBITS >  8) ? 1 : 0) +
-                                         ((NBITS > 16) ? 1 : 0) +
-                                         ((NBITS > 32) ? 1 : 0);
+    static ETL_CONSTANT int TYPE_INDEX = ((NBITS > 8) ? 1 : 0) + ((NBITS > 16) ? 1 : 0) + ((NBITS > 32) ? 1 : 0);
 
   public:
 
@@ -336,10 +334,10 @@ namespace etl
   template <size_t NBITS>
   ETL_CONSTANT int smallest_uint_for_bits<NBITS>::TYPE_INDEX;
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <size_t NBITS>
   using smallest_uint_for_bits_t = typename smallest_uint_for_bits<NBITS>::type;
-#endif
+  #endif
 
   //***************************************************************************
   /// Template to determine the smallest signed int type that can contain a
@@ -353,9 +351,7 @@ namespace etl
   private:
 
     // Determines the index of the best unsigned type for the required number of bits.
-    static ETL_CONSTANT int TYPE_INDEX = ((NBITS >  8) ? 1 : 0) +
-                                         ((NBITS > 16) ? 1 : 0) +
-                                         ((NBITS > 32) ? 1 : 0);
+    static ETL_CONSTANT int TYPE_INDEX = ((NBITS > 8) ? 1 : 0) + ((NBITS > 16) ? 1 : 0) + ((NBITS > 32) ? 1 : 0);
 
   public:
 
@@ -365,10 +361,10 @@ namespace etl
   template <size_t NBITS>
   ETL_CONSTANT int smallest_int_for_bits<NBITS>::TYPE_INDEX;
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <size_t NBITS>
   using smallest_int_for_bits_t = typename smallest_int_for_bits<NBITS>::type;
-#endif
+  #endif
 
   //***************************************************************************
   /// Template to determine the smallest unsigned int type that can contain the
@@ -382,9 +378,7 @@ namespace etl
   private:
 
     // Determines the index of the best unsigned type for the required value.
-    static ETL_CONSTANT int TYPE_INDEX = ((VALUE > UINT_LEAST8_MAX) ? 1 : 0) +
-      ((VALUE > UINT16_MAX) ? 1 : 0) +
-      ((VALUE > UINT32_MAX) ? 1 : 0);
+    static ETL_CONSTANT int TYPE_INDEX = ((VALUE > UINT_LEAST8_MAX) ? 1 : 0) + ((VALUE > UINT16_MAX) ? 1 : 0) + ((VALUE > UINT32_MAX) ? 1 : 0);
 
   public:
 
@@ -394,10 +388,10 @@ namespace etl
   template <uintmax_t VALUE>
   ETL_CONSTANT int smallest_uint_for_value<VALUE>::TYPE_INDEX;
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <uintmax_t VALUE>
   using smallest_uint_for_value_t = typename smallest_uint_for_value<VALUE>::type;
-#endif
+  #endif
 
   //***************************************************************************
   /// Template to determine the smallest int type that can contain the
@@ -411,9 +405,7 @@ namespace etl
   private:
 
     // Determines the index of the best signed type for the required value.
-    static ETL_CONSTANT int TYPE_INDEX = (((VALUE > intmax_t(INT_LEAST8_MAX)) || (VALUE < intmax_t(INT_LEAST8_MIN))) ? 1 : 0) +
-      (((VALUE > intmax_t(INT16_MAX)) || (VALUE < intmax_t(INT16_MIN))) ? 1 : 0) +
-      (((VALUE > intmax_t(INT32_MAX)) || (VALUE < intmax_t(INT32_MIN))) ? 1 : 0);
+    static ETL_CONSTANT int TYPE_INDEX = (((VALUE > intmax_t(INT_LEAST8_MAX)) || (VALUE < intmax_t(INT_LEAST8_MIN))) ? 1 : 0) + (((VALUE > intmax_t(INT16_MAX)) || (VALUE < intmax_t(INT16_MIN))) ? 1 : 0) + (((VALUE > intmax_t(INT32_MAX)) || (VALUE < intmax_t(INT32_MIN))) ? 1 : 0);
 
   public:
 
@@ -423,10 +415,10 @@ namespace etl
   template <intmax_t VALUE>
   ETL_CONSTANT int smallest_int_for_value<VALUE>::TYPE_INDEX;
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <intmax_t VALUE>
   using smallest_int_for_value_t = typename smallest_int_for_value<VALUE>::type;
-#endif
-}
+  #endif
+} // namespace etl
 
 #endif
diff --git a/include/etl/generators/type_lookup_generator.h b/include/etl/generators/type_lookup_generator.h
index f1f2bb7e..43c56275 100644
--- a/include/etl/generators/type_lookup_generator.h
+++ b/include/etl/generators/type_lookup_generator.h
@@ -30,10 +30,10 @@ SOFTWARE.
 #define ETL_TYPE_LOOKUP_INCLUDED
 
 #include "platform.h"
-#include "type_traits.h"
-#include "static_assert.h"
 #include "integral_limits.h"
 #include "null_type.h"
+#include "static_assert.h"
+#include "type_traits.h"
 
 #include <limits.h>
 
@@ -42,7 +42,7 @@ import cog
 cog.outl("#if 0")
 ]]]*/
 /*[[[end]]]*/
-#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+  #error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
 /*[[[cog
 import cog
 cog.outl("#endif")
@@ -85,7 +85,7 @@ namespace etl
 
 #if ETL_USING_CPP11 && !defined(ETL_TYPE_SELECT_FORCE_CPP03_IMPLEMENTATION)
   //***************************************************************************
-  // type_id_lookup 
+  // type_id_lookup
   //***************************************************************************
   template <typename... TTypes>
   struct type_id_lookup
@@ -93,7 +93,9 @@ namespace etl
   private:
 
     // The type for no match.
-    struct nulltype {};
+    struct nulltype
+    {
+    };
 
     // For N type pairs.
     template <size_t Id, typename T1, typename... TRest>
@@ -160,10 +162,10 @@ namespace etl
       static_assert(value != UNKNOWN, "Invalid type");
     };
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
     template <typename T>
     static constexpr size_t id_from_type_v = id_from_type<T>::value;
-#endif
+  #endif
 
     //************************************
     template <typename T>
@@ -171,7 +173,7 @@ namespace etl
     {
       return get_id_from_type<T>();
     }
-     
+
     //************************************
     template <typename T>
     static unsigned int get_id_from_type()
@@ -189,7 +191,9 @@ namespace etl
   private:
 
     // The type for no match.
-    struct nulltype {};
+    struct nulltype
+    {
+    };
 
     template <typename T, typename T1, typename... TRest>
     struct type_from_type_helper
@@ -227,14 +231,17 @@ namespace etl
 
 #else
 
-  /*[[[cog
+    /*[[[cog
   import cog
   cog.outl("//***************************************************************************")
   cog.outl("// For %s types." % int(NTypes))
   cog.outl("//***************************************************************************")
+  max_w = len(str(int(NTypes)))
   cog.outl("template <typename T1,")
   for n in range(2, int(NTypes)):
-      cog.outl("          typename T%s = etl::type_id_pair<etl::null_type<0>, -%s>," %(n, n))
+      pad = " " * (max_w - len(str(n)))
+      cog.outl("          typename T%s%s = etl::type_id_pair<etl::null_type<0>, -%s>," %(n, pad, n))
+
   cog.outl("          typename T%s = etl::type_id_pair<etl::null_type<0>, -%s> >" %(NTypes, NTypes))
   cog.outl("struct type_id_lookup")
   cog.outl("{")
@@ -244,7 +251,8 @@ namespace etl
   cog.outl("  template <int Id>")
   cog.outl("  struct type_from_id")
   cog.outl("  {")
-  cog.outl("    typedef ")
+  cog.outl("    // clang-format off")
+  cog.outl("    typedef")
   for n in range(1, int(NTypes) + 1):
       cog.outl("          typename etl::conditional<Id == T%s::Id, typename T%s::type," %(n, n))
   cog.out("          etl::null_type<0> >")
@@ -257,6 +265,7 @@ namespace etl
           if n != int(NTypes):
               cog.outl("")
               cog.out("                            ")
+  cog.outl("    // clang-format on")
   cog.outl("")
   cog.outl("    ETL_STATIC_ASSERT(!(etl::is_same<etl::null_type<0>, type>::value), \"Invalid id\");")
   cog.outl("  };")
@@ -272,10 +281,12 @@ namespace etl
   cog.outl("  {")
   cog.outl("    enum")
   cog.outl("    {")
-  cog.outl("      value =")
-  for n in range(1, int(NTypes) + 1) :
-      cog.outl("        (unsigned int) etl::is_same<T, typename T%s::type>::value ? (unsigned int)T%s::Id :" % (n, n))
-  cog.outl("        (unsigned int) UNKNOWN")
+  first_pad = " " * (max_w - 1 + 3)
+  cog.outl("      value = (unsigned int)etl::is_same<T, typename T1::type>::value%s? (unsigned int)T1::Id" % first_pad)
+  for n in range(2, int(NTypes) + 1) :
+      pad = " " * (max_w - len(str(n)) + 1)
+      cog.outl("              : (unsigned int)etl::is_same<T, typename T%s::type>::value%s? (unsigned int)T%s::Id" % (n, pad, n))
+  cog.outl("                                                                         : (unsigned int)UNKNOWN")
   cog.outl("    };")
   cog.outl("")
   cog.outl("    ETL_STATIC_ASSERT(((unsigned int)value != (unsigned int)UNKNOWN), \"Invalid type\");")
@@ -301,13 +312,15 @@ namespace etl
   cog.outl("//***************************************************************************")
   cog.outl("template <typename T1,")
   for n in range(2, int(NTypes)):
-      cog.outl("          typename T%s = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >," %n)
+      pad = " " * (max_w - len(str(n)))
+      cog.outl("          typename T%s%s = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >," %(n, pad))
   cog.outl("          typename T%s = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> > >" %NTypes)
   cog.outl("struct type_type_lookup")
   cog.outl("{")
   cog.outl("public:")
   cog.outl("")
   cog.outl("  //************************************")
+  cog.outl("  // clang-format off")
   cog.outl("  template <typename T>")
   cog.outl("  struct type_from_type")
   cog.outl("  {")
@@ -327,11 +340,12 @@ namespace etl
   cog.outl("")
   cog.outl("    ETL_STATIC_ASSERT(!(etl::is_same<etl::null_type<0>, type>::value), \"Invalid type\");")
   cog.outl("  };")
+  cog.outl("  // clang-format on")
   cog.outl("};")
   ]]]*/
-  /*[[[end]]]*/
+    /*[[[end]]]*/
 
 #endif
-}
+} // namespace etl
 
 #endif
diff --git a/include/etl/generators/type_select_generator.h b/include/etl/generators/type_select_generator.h
index aab2d0f3..ff37fc28 100644
--- a/include/etl/generators/type_select_generator.h
+++ b/include/etl/generators/type_select_generator.h
@@ -30,16 +30,16 @@ SOFTWARE.
 #define ETL_TYPE_SELECT_INCLUDED
 
 #include "platform.h"
+#include "null_type.h"
 #include "static_assert.h"
 #include "type_traits.h"
-#include "null_type.h"
 
 /*[[[cog
 import cog
 cog.outl("#if 0")
 ]]]*/
 /*[[[end]]]*/
-#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+  #error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
 /*[[[cog
 import cog
 cog.outl("#endif")
@@ -99,19 +99,22 @@ namespace etl
   // Select type alias
   //***************************************************************************
   template <size_t Index, typename... TTypes>
-  using type_select_t = typename etl::type_select<TTypes...>:: template select_t<Index>;
+  using type_select_t = typename etl::type_select<TTypes...>::template select_t<Index>;
 
 #else
 
-  /*[[[cog
+    /*[[[cog
   import cog
   cog.outl("//***************************************************************************")
   cog.outl("// For %s types." % int(NTypes))
   cog.outl("//***************************************************************************")
+  max_w = len(str(int(NTypes) - 1))
   cog.outl("template <typename T0,")
   for n in range(1, int(NTypes) - 1):
-      cog.outl("          typename T%s = void," % n)
-  cog.outl("          typename T%s = void>" %(int(NTypes) - 1))
+      pad = " " * (max_w - len(str(n)))
+      cog.outl("          typename T%s%s = void," % (n, pad))
+  pad = " " * (max_w - len(str(int(NTypes) - 1)))
+  cog.outl("          typename T%s%s = void>" %(int(NTypes) - 1, pad))
   cog.outl("struct type_select")
   cog.outl("{")
   cog.outl("public:")
@@ -119,6 +122,7 @@ namespace etl
   cog.outl("  template <size_t Id>")
   cog.outl("  struct select")
   cog.outl("  {")
+  cog.outl("    // clang-format off")
   cog.outl("    typedef typename etl::conditional<Id == 0, T0,")
   for n in range(1, int(NTypes)) :
       cog.outl("            typename etl::conditional<Id == %s, T%s," % (n, n))
@@ -130,6 +134,7 @@ namespace etl
           cog.outl("")
           cog.out("            ")
   cog.outl("::type type;")
+  cog.outl("    // clang-format on")
   cog.outl("");
   cog.outl("    ETL_STATIC_ASSERT(Id < %s, \"Invalid Id\");" % int(NTypes));
   cog.outl("  };")
@@ -142,7 +147,7 @@ namespace etl
       cog.outl("//***************************************************************************")
       cog.out("template <")
       for n in range(0, s - 1):
-          cog.outl("typename T%s, " % n)
+          cog.outl("typename T%s," % n)
           cog.out("          ")
       cog.outl("typename T%s>" % (s - 1))
       cog.out("struct type_select<")
@@ -151,9 +156,11 @@ namespace etl
       cog.outl("T%s>" % (s - 1))
       cog.outl("{")
       cog.outl("public:")
+      cog.outl("")
       cog.outl("  template <size_t Id>")
       cog.outl("  struct select")
       cog.outl("  {")
+      cog.outl("    // clang-format off")
       cog.outl("    typedef typename etl::conditional<Id == 0, T0,")
       for n in range(1, s) :
           cog.outl("            typename etl::conditional<Id == %s, T%s," % (n, n))
@@ -165,13 +172,14 @@ namespace etl
             cog.outl("")
             cog.out("            ")
       cog.outl("::type type;")
+      cog.outl("    // clang-format on")
       cog.outl("");
       cog.outl("    ETL_STATIC_ASSERT(Id < %s, \"Invalid Id\");" % s);
       cog.outl("  };")
       cog.outl("};")
   ]]]*/
-  /*[[[end]]]*/
+    /*[[[end]]]*/
 #endif
-}
+} // namespace etl
 
 #endif
diff --git a/include/etl/generators/type_traits_generator.h b/include/etl/generators/type_traits_generator.h
index 1588544f..1fd5b294 100644
--- a/include/etl/generators/type_traits_generator.h
+++ b/include/etl/generators/type_traits_generator.h
@@ -33,7 +33,7 @@ import cog
 cog.outl("#if 0")
 ]]]*/
 /*[[[end]]]*/
-#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+  #error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
 /*[[[cog
 import cog
 cog.outl("#endif")
@@ -63,32 +63,32 @@ cog.outl("//********************************************************************
 //***************************************************************************
 
 #ifndef ETL_TYPE_TRAITS_INCLUDED
-#define ETL_TYPE_TRAITS_INCLUDED
+  #define ETL_TYPE_TRAITS_INCLUDED
 
-#include "platform.h"
-#include "nullptr.h"
-#include "static_assert.h"
+  #include "platform.h"
+  #include "nullptr.h"
+  #include "static_assert.h"
 
-#include <stddef.h>
-#include <stdint.h>
+  #include <stddef.h>
+  #include <stdint.h>
 
 ///\defgroup type_traits type_traits
 /// A set of type traits definitions.
 /// Derived from either the standard or alternate definitions, dependent on whether or not ETL_NO_STL is defined.
 /// \ingroup utilities
 
-#if ETL_USING_STL && ETL_USING_CPP11
-  #include <type_traits>
-#endif
+  #if ETL_USING_STL && ETL_USING_CPP11
+    #include <type_traits>
+  #endif
 
 namespace etl
 {
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename...>
   using void_t = void;
-#endif
+  #endif
 
-#if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
+  #if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
 
   //*****************************************************************************
   // Traits are defined by the ETL
@@ -101,7 +101,7 @@ namespace etl
   {
     static const T value = VALUE;
 
-    typedef T value_type;
+    typedef T                           value_type;
     typedef integral_constant<T, VALUE> type;
 
     operator value_type() const
@@ -117,23 +117,25 @@ namespace etl
   template <typename T, T VALUE>
   const T integral_constant<T, VALUE>::value;
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T, T VALUE>
   inline constexpr T integral_constant_v = etl::integral_constant<T, VALUE>::value;
-#endif
+    #endif
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <bool BValue>
   using bool_constant = integral_constant<bool, BValue>;
-#else
+    #else
   template <bool BValue>
-  struct bool_constant : etl::integral_constant<bool, BValue> { };
-#endif
+  struct bool_constant : etl::integral_constant<bool, BValue>
+  {
+  };
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <bool BValue>
   inline constexpr bool bool_constant_v = bool_constant<BValue>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// negation
@@ -142,386 +144,749 @@ namespace etl
   {
   };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool negation_v = negation<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_reference
-  template <typename T> struct remove_reference { typedef T type; };
-  template <typename T> struct remove_reference<T&> { typedef T type; };
-#if ETL_USING_CPP11
-  template <typename T> struct remove_reference<T&&> { typedef T type; };
-#endif
+  template <typename T>
+  struct remove_reference
+  {
+    typedef T type;
+  };
+  template <typename T>
+  struct remove_reference<T&>
+  {
+    typedef T type;
+  };
+    #if ETL_USING_CPP11
+  template <typename T>
+  struct remove_reference<T&&>
+  {
+    typedef T type;
+  };
+    #endif
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_reference_t = typename remove_reference<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_pointer
-  template <typename T> struct remove_pointer { typedef T type; };
-  template <typename T> struct remove_pointer<T*> { typedef T type; };
-  template <typename T> struct remove_pointer<const T*> { typedef const T type; };
-  template <typename T> struct remove_pointer<volatile T*> { typedef volatile T type; };
-  template <typename T> struct remove_pointer<const volatile T*> { typedef const volatile T type; };
-  template <typename T> struct remove_pointer<T* const> { typedef T type; };
-  template <typename T> struct remove_pointer<const T* const> { typedef const T type; };
-  template <typename T> struct remove_pointer<volatile T* const> { typedef volatile T type; };
-  template <typename T> struct remove_pointer<const volatile T* const> { typedef const volatile T type; };
+  template <typename T>
+  struct remove_pointer
+  {
+    typedef T type;
+  };
+  template <typename T>
+  struct remove_pointer<T*>
+  {
+    typedef T type;
+  };
+  template <typename T>
+  struct remove_pointer<const T*>
+  {
+    typedef const T type;
+  };
+  template <typename T>
+  struct remove_pointer<volatile T*>
+  {
+    typedef volatile T type;
+  };
+  template <typename T>
+  struct remove_pointer<const volatile T*>
+  {
+    typedef const volatile T type;
+  };
+  template <typename T>
+  struct remove_pointer<T* const>
+  {
+    typedef T type;
+  };
+  template <typename T>
+  struct remove_pointer<const T* const>
+  {
+    typedef const T type;
+  };
+  template <typename T>
+  struct remove_pointer<volatile T* const>
+  {
+    typedef volatile T type;
+  };
+  template <typename T>
+  struct remove_pointer<const volatile T* const>
+  {
+    typedef const volatile T type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_pointer_t = typename remove_pointer<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_pointer
-  template <typename T> struct add_pointer { typedef typename remove_reference<T>::type* type; };
+  template <typename T>
+  struct add_pointer
+  {
+    typedef typename remove_reference<T>::type* type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_pointer_t = typename add_pointer<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_const
-  template <typename T> struct is_const : false_type {};
-  template <typename T> struct is_const<const T> : true_type {};
-  template <typename T> struct is_const<const volatile T> : true_type {};
+  template <typename T>
+  struct is_const : false_type
+  {
+  };
+  template <typename T>
+  struct is_const<const T> : true_type
+  {
+  };
+  template <typename T>
+  struct is_const<const volatile T> : true_type
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_const_v = is_const<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_const
-  template <typename T> struct remove_const { typedef T type; };
-  template <typename T> struct remove_const<const T> { typedef T type; };
+  template <typename T>
+  struct remove_const
+  {
+    typedef T type;
+  };
+  template <typename T>
+  struct remove_const<const T>
+  {
+    typedef T type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_const_t = typename remove_const<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_const
-  template <typename T> struct add_const { typedef const T type; };
-  template <typename T> struct add_const<const T> { typedef const T type; };
+  template <typename T>
+  struct add_const
+  {
+    typedef const T type;
+  };
+  template <typename T>
+  struct add_const<const T>
+  {
+    typedef const T type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_const_t = typename add_const<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_volatile
-  template <typename T> struct is_volatile : false_type {};
-  template <typename T> struct is_volatile<volatile T> : true_type {};
-  template <typename T> struct is_volatile<const volatile T> : true_type {};
+  template <typename T>
+  struct is_volatile : false_type
+  {
+  };
+  template <typename T>
+  struct is_volatile<volatile T> : true_type
+  {
+  };
+  template <typename T>
+  struct is_volatile<const volatile T> : true_type
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_volatile_v = is_volatile<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_volatile
-  template <typename T> struct remove_volatile { typedef T type; };
-  template <typename T> struct remove_volatile<volatile T> { typedef T type; };
+  template <typename T>
+  struct remove_volatile
+  {
+    typedef T type;
+  };
+  template <typename T>
+  struct remove_volatile<volatile T>
+  {
+    typedef T type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_volatile_t = typename remove_volatile<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_volatile
-  template <typename T> struct add_volatile { typedef volatile T type; };
-  template <typename T> struct add_volatile<volatile T> { typedef volatile T type; };
+  template <typename T>
+  struct add_volatile
+  {
+    typedef volatile T type;
+  };
+  template <typename T>
+  struct add_volatile<volatile T>
+  {
+    typedef volatile T type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_volatile_t = typename add_volatile<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_cv
-  template <typename T> struct remove_cv
+  template <typename T>
+  struct remove_cv
   {
     typedef typename remove_volatile<typename remove_const<T>::type>::type type;
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_cv_t = typename remove_cv<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_cv
-  template <typename T> struct add_cv
+  template <typename T>
+  struct add_cv
   {
     typedef typename add_volatile<typename add_const<T>::type>::type type;
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_cv_t = typename add_cv<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_cvref
-  template <typename T> struct remove_cvref
+  template <typename T>
+  struct remove_cvref
   {
     typedef typename remove_cv<typename remove_reference<T>::type>::type type;
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_cvref_t = typename remove_cvref<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_integral
-  template <typename T> struct is_integral : false_type {};
-  template <> struct is_integral<bool> : true_type {};
-  template <> struct is_integral<char> : true_type {};
-  template <> struct is_integral<unsigned char> : true_type {};
-  template <> struct is_integral<signed char> : true_type {};
-  template <> struct is_integral<wchar_t> : true_type {};
-  template <> struct is_integral<short> : true_type {};
-  template <> struct is_integral<unsigned short> : true_type {};
-  template <> struct is_integral<int> : true_type {};
-  template <> struct is_integral<unsigned int> : true_type {};
-  template <> struct is_integral<long> : true_type {};
-  template <> struct is_integral<unsigned long> : true_type {};
-  template <> struct is_integral<long long> : true_type {};
-  template <> struct is_integral<unsigned long long> : true_type {};
-#if ETL_HAS_NATIVE_CHAR8_T
-  template <> struct is_integral<char8_t> : true_type {};
-#endif
-#if ETL_HAS_NATIVE_CHAR16_T
-  template <> struct is_integral<char16_t> : true_type {};
-#endif
-#if ETL_HAS_NATIVE_CHAR32_T
-  template <> struct is_integral<char32_t> : true_type {};
-#endif
-  template <typename T> struct is_integral<const T> : is_integral<T> {};
-  template <typename T> struct is_integral<volatile T> : is_integral<T> {};
-  template <typename T> struct is_integral<const volatile T> : is_integral<T> {};
+  template <typename T>
+  struct is_integral : false_type
+  {
+  };
+  template <>
+  struct is_integral<bool> : true_type
+  {
+  };
+  template <>
+  struct is_integral<char> : true_type
+  {
+  };
+  template <>
+  struct is_integral<unsigned char> : true_type
+  {
+  };
+  template <>
+  struct is_integral<signed char> : true_type
+  {
+  };
+  template <>
+  struct is_integral<wchar_t> : true_type
+  {
+  };
+  template <>
+  struct is_integral<short> : true_type
+  {
+  };
+  template <>
+  struct is_integral<unsigned short> : true_type
+  {
+  };
+  template <>
+  struct is_integral<int> : true_type
+  {
+  };
+  template <>
+  struct is_integral<unsigned int> : true_type
+  {
+  };
+  template <>
+  struct is_integral<long> : true_type
+  {
+  };
+  template <>
+  struct is_integral<unsigned long> : true_type
+  {
+  };
+  template <>
+  struct is_integral<long long> : true_type
+  {
+  };
+  template <>
+  struct is_integral<unsigned long long> : true_type
+  {
+  };
+    #if ETL_HAS_NATIVE_CHAR8_T
+  template <>
+  struct is_integral<char8_t> : true_type
+  {
+  };
+    #endif
+    #if ETL_HAS_NATIVE_CHAR16_T
+  template <>
+  struct is_integral<char16_t> : true_type
+  {
+  };
+    #endif
+    #if ETL_HAS_NATIVE_CHAR32_T
+  template <>
+  struct is_integral<char32_t> : true_type
+  {
+  };
+    #endif
+  template <typename T>
+  struct is_integral<const T> : is_integral<T>
+  {
+  };
+  template <typename T>
+  struct is_integral<volatile T> : is_integral<T>
+  {
+  };
+  template <typename T>
+  struct is_integral<const volatile T> : is_integral<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_integral_v = is_integral<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_signed
-  template <typename T> struct is_signed : false_type {};
-  template <> struct is_signed<char> : etl::bool_constant<(char(255) < 0)> {};
-  template <> struct is_signed<wchar_t> : public etl::bool_constant<wchar_t(-1) < wchar_t(0)> {};
-  template <> struct is_signed<signed char> : true_type {};
-  template <> struct is_signed<short> : true_type {};
-  template <> struct is_signed<int> : true_type {};
-  template <> struct is_signed<long> : true_type {};
-  template <> struct is_signed<long long> : true_type {};
-  template <> struct is_signed<float> : true_type {};
-  template <> struct is_signed<double> : true_type {};
-  template <> struct is_signed<long double> : true_type {};
-#if ETL_HAS_NATIVE_CHAR8_T
-  template <> struct is_signed<char8_t> : true_type {};
-#endif
-#if ETL_HAS_NATIVE_CHAR16_T
-  template <> struct is_signed<char16_t> : true_type {};
-#endif
-#if ETL_HAS_NATIVE_CHAR32_T
-  template <> struct is_signed<char32_t> : true_type {};
-#endif
-  template <typename T> struct is_signed<const T> : is_signed<T> {};
-  template <typename T> struct is_signed<volatile T> : is_signed<T> {};
-  template <typename T> struct is_signed<const volatile T> : is_signed<T> {};
+  template <typename T>
+  struct is_signed : false_type
+  {
+  };
+  template <>
+  struct is_signed<char> : etl::bool_constant<(char(255) < 0)>
+  {
+  };
+  template <>
+  struct is_signed<wchar_t> : public etl::bool_constant<wchar_t(-1) < wchar_t(0)>
+  {
+  };
+  template <>
+  struct is_signed<signed char> : true_type
+  {
+  };
+  template <>
+  struct is_signed<short> : true_type
+  {
+  };
+  template <>
+  struct is_signed<int> : true_type
+  {
+  };
+  template <>
+  struct is_signed<long> : true_type
+  {
+  };
+  template <>
+  struct is_signed<long long> : true_type
+  {
+  };
+  template <>
+  struct is_signed<float> : true_type
+  {
+  };
+  template <>
+  struct is_signed<double> : true_type
+  {
+  };
+  template <>
+  struct is_signed<long double> : true_type
+  {
+  };
+    #if ETL_HAS_NATIVE_CHAR8_T
+  template <>
+  struct is_signed<char8_t> : true_type
+  {
+  };
+    #endif
+    #if ETL_HAS_NATIVE_CHAR16_T
+  template <>
+  struct is_signed<char16_t> : true_type
+  {
+  };
+    #endif
+    #if ETL_HAS_NATIVE_CHAR32_T
+  template <>
+  struct is_signed<char32_t> : true_type
+  {
+  };
+    #endif
+  template <typename T>
+  struct is_signed<const T> : is_signed<T>
+  {
+  };
+  template <typename T>
+  struct is_signed<volatile T> : is_signed<T>
+  {
+  };
+  template <typename T>
+  struct is_signed<const volatile T> : is_signed<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_signed_v = is_signed<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_unsigned
-  template <typename T> struct is_unsigned : false_type {};
-  template <> struct is_unsigned<bool> : true_type {};
-  template <> struct is_unsigned<char> : etl::bool_constant<(char(255) > 0)> {};
-  template <> struct is_unsigned<unsigned char> : true_type {};
-  template <> struct is_unsigned<wchar_t> : public etl::bool_constant<(wchar_t(-1) > wchar_t(0))> {};
-  template <> struct is_unsigned<unsigned short> : true_type {};
-  template <> struct is_unsigned<unsigned int> : true_type {};
-  template <> struct is_unsigned<unsigned long> : true_type {};
-  template <> struct is_unsigned<unsigned long long> : true_type {};
-  template <typename T> struct is_unsigned<const T> : is_unsigned<T> {};
-  template <typename T> struct is_unsigned<volatile T> : is_unsigned<T> {};
-  template <typename T> struct is_unsigned<const volatile T> : is_unsigned<T> {};
+  template <typename T>
+  struct is_unsigned : false_type
+  {
+  };
+  template <>
+  struct is_unsigned<bool> : true_type
+  {
+  };
+  template <>
+  struct is_unsigned<char> : etl::bool_constant<(char(255) > 0)>
+  {
+  };
+  template <>
+  struct is_unsigned<unsigned char> : true_type
+  {
+  };
+  template <>
+  struct is_unsigned<wchar_t> : public etl::bool_constant<(wchar_t(-1) > wchar_t(0))>{};
+  template <>
+  struct is_unsigned<unsigned short> : true_type
+  {
+  };
+  template <>
+  struct is_unsigned<unsigned int> : true_type
+  {
+  };
+  template <>
+  struct is_unsigned<unsigned long> : true_type
+  {
+  };
+  template <>
+  struct is_unsigned<unsigned long long> : true_type
+  {
+  };
+  template <typename T>
+  struct is_unsigned<const T> : is_unsigned<T>
+  {
+  };
+  template <typename T>
+  struct is_unsigned<volatile T> : is_unsigned<T>
+  {
+  };
+  template <typename T>
+  struct is_unsigned<const volatile T> : is_unsigned<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_unsigned_v = is_unsigned<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_floating_point
-  template <typename T> struct is_floating_point : false_type {};
-  template <> struct is_floating_point<float> : true_type {};
-  template <> struct is_floating_point<double> : true_type {};
-  template <> struct is_floating_point<long double> : true_type {};
-  template <typename T> struct is_floating_point<const T> : is_floating_point<T> {};
-  template <typename T> struct is_floating_point<volatile T> : is_floating_point<T> {};
-  template <typename T> struct is_floating_point<const volatile T> : is_floating_point<T> {};
+  template <typename T>
+  struct is_floating_point : false_type
+  {
+  };
+  template <>
+  struct is_floating_point<float> : true_type
+  {
+  };
+  template <>
+  struct is_floating_point<double> : true_type
+  {
+  };
+  template <>
+  struct is_floating_point<long double> : true_type
+  {
+  };
+  template <typename T>
+  struct is_floating_point<const T> : is_floating_point<T>
+  {
+  };
+  template <typename T>
+  struct is_floating_point<volatile T> : is_floating_point<T>
+  {
+  };
+  template <typename T>
+  struct is_floating_point<const volatile T> : is_floating_point<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_floating_point_v = is_floating_point<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_same
-  template <typename T1, typename T2> struct is_same : public false_type {};
-  template <typename T> struct is_same<T, T> : public true_type {};
+  template <typename T1, typename T2>
+  struct is_same : public false_type
+  {
+  };
+  template <typename T>
+  struct is_same<T, T> : public true_type
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T1, typename T2>
   inline constexpr bool is_same_v = is_same<T1, T2>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_void
-  template<typename T> struct is_void : false_type {};
-  template<> struct is_void<void> : true_type {};
+  template <typename T>
+  struct is_void : false_type
+  {
+  };
+  template <>
+  struct is_void<void> : true_type
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_void_v = is_void<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_arithmetic
-  template<typename T> struct is_arithmetic : etl::bool_constant<is_integral<T>::value || is_floating_point<T>::value> {};
+  template <typename T>
+  struct is_arithmetic : etl::bool_constant<is_integral<T>::value || is_floating_point<T>::value>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_arithmetic_v = is_arithmetic<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_fundamental
-  template <typename T> struct is_fundamental : etl::bool_constant<is_arithmetic<T>::value || is_void<T>::value> {};
+  template <typename T>
+  struct is_fundamental : etl::bool_constant<is_arithmetic<T>::value || is_void<T>::value>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_fundamental_v = is_fundamental<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_compound
-  template <typename T> struct is_compound : etl::bool_constant<!is_fundamental<T>::value> {};
+  template <typename T>
+  struct is_compound : etl::bool_constant<!is_fundamental<T>::value>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_compound_v = is_compound<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_array
-  template <typename T> struct is_array : false_type {};
-  template <typename T> struct is_array<T[]> : true_type {};
-  template <typename T, size_t Size> struct is_array<T[Size]> : true_type {};
+  template <typename T>
+  struct is_array : false_type
+  {
+  };
+  template <typename T>
+  struct is_array<T[]> : true_type
+  {
+  };
+  template <typename T, size_t Size>
+  struct is_array<T[Size]> : true_type
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_array_v = is_array<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_pointer
-  template<typename T> struct is_pointer_helper : false_type {};
-  template<typename T> struct is_pointer_helper<T*> : true_type {};
-  template<typename T> struct is_pointer_helper<const T*> : is_pointer_helper<T*> {};
-  template<typename T> struct is_pointer_helper<volatile T*> : is_pointer_helper<T*> {};
-  template<typename T> struct is_pointer_helper<const volatile T*> : is_pointer_helper<T*> {};
-  template<typename T> struct is_pointer : is_pointer_helper<typename remove_cv<T>::type> {};
+  template <typename T>
+  struct is_pointer_helper : false_type
+  {
+  };
+  template <typename T>
+  struct is_pointer_helper<T*> : true_type
+  {
+  };
+  template <typename T>
+  struct is_pointer_helper<const T*> : is_pointer_helper<T*>
+  {
+  };
+  template <typename T>
+  struct is_pointer_helper<volatile T*> : is_pointer_helper<T*>
+  {
+  };
+  template <typename T>
+  struct is_pointer_helper<const volatile T*> : is_pointer_helper<T*>
+  {
+  };
+  template <typename T>
+  struct is_pointer : is_pointer_helper<typename remove_cv<T>::type>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_pointer_v = is_pointer<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_lvalue_reference
-  template<typename T> struct is_lvalue_reference_helper : false_type {};
-  template<typename T> struct is_lvalue_reference_helper<T&> : true_type {};
-  template<typename T> struct is_lvalue_reference : is_lvalue_reference_helper<typename remove_cv<T>::type> {};
+  template <typename T>
+  struct is_lvalue_reference_helper : false_type
+  {
+  };
+  template <typename T>
+  struct is_lvalue_reference_helper<T&> : true_type
+  {
+  };
+  template <typename T>
+  struct is_lvalue_reference : is_lvalue_reference_helper<typename remove_cv<T>::type>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_lvalue_reference_v = etl::is_lvalue_reference<T>::value;
-#endif
+    #endif
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   //***************************************************************************
   /// is_rvalue_reference
-  template<typename T> struct is_rvalue_reference_helper : false_type {};
-  template<typename T> struct is_rvalue_reference_helper<T&&> : true_type {};
-  template<typename T> struct is_rvalue_reference : is_rvalue_reference_helper<typename remove_cv<T>::type> {};
+  template <typename T>
+  struct is_rvalue_reference_helper : false_type
+  {
+  };
+  template <typename T>
+  struct is_rvalue_reference_helper<T&&> : true_type
+  {
+  };
+  template <typename T>
+  struct is_rvalue_reference : is_rvalue_reference_helper<typename remove_cv<T>::type>
+  {
+  };
 
-#if ETL_USING_CPP17
+      #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_rvalue_reference_v = etl::is_rvalue_reference<T>::value;
-#endif
-#endif
+      #endif
+    #endif
 
   //***************************************************************************
   /// is_reference
   // Either lvalue or rvalue (for CPP11)
-  template<typename T> struct is_reference : integral_constant<bool,
-    is_lvalue_reference<T>::value
+  template <typename T>
+  struct is_reference : integral_constant<bool, is_lvalue_reference<T>::value
     #if ETL_USING_CPP11
-        || is_rvalue_reference<T>::value
+                                                  || is_rvalue_reference<T>::value
     #endif
-  >{};
+                                          >
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_reference_v = is_reference<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_pod
   /// Only fundamental and pointers types are recognised.
-  template <typename T> struct is_pod : etl::bool_constant<etl::is_fundamental<T>::value || etl::is_pointer<T>::value> {};
+  template <typename T>
+  struct is_pod : etl::bool_constant<etl::is_fundamental<T>::value || etl::is_pointer<T>::value>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_pod_v = etl::is_pod<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// conditional
-  template <bool BValue, typename T, typename F>  struct conditional { typedef T type; };
-  template <typename T, typename F> struct conditional<false, T, F> { typedef F type; };
+  template <bool BValue, typename T, typename F>
+  struct conditional
+  {
+    typedef T type;
+  };
+  template <typename T, typename F>
+  struct conditional<false, T, F>
+  {
+    typedef F type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <bool BValue, typename T, typename F>
   using conditional_t = typename conditional<BValue, T, F>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// make_signed
-  template <typename T> struct make_signed { typedef  T type; };
-  template <> struct make_signed<char> { typedef  signed char type; };
-  template <> struct make_signed<unsigned char> { typedef  signed char type; };
+  template <typename T>
+  struct make_signed
+  {
+    typedef T type;
+  };
+  template <>
+  struct make_signed<char>
+  {
+    typedef signed char type;
+  };
+  template <>
+  struct make_signed<unsigned char>
+  {
+    typedef signed char type;
+  };
 
-  template <> struct make_signed<wchar_t>
+  template <>
+  struct make_signed<wchar_t>
   {
     typedef etl::conditional<sizeof(wchar_t) == sizeof(int16_t),
                              int16_t,
@@ -530,27 +895,69 @@ namespace etl
                                               void>::type>::type type;
   };
 
-  template <> struct make_signed<unsigned short> { typedef  short type; };
-  template <> struct make_signed<unsigned int> { typedef int type; };
-  template <> struct make_signed<unsigned long> { typedef  long type; };
-  template <> struct make_signed<unsigned long long> { typedef long long type; };
-  template <typename T> struct make_signed<const T> : add_const<typename make_signed<T>::type> {};
-  template <typename T> struct make_signed<volatile T> : add_volatile<typename make_signed<T>::type> {};
-  template <typename T> struct make_signed<const volatile T> : add_const<typename add_volatile<typename make_signed<T>::type>::type> {};
+  template <>
+  struct make_signed<unsigned short>
+  {
+    typedef short type;
+  };
+  template <>
+  struct make_signed<unsigned int>
+  {
+    typedef int type;
+  };
+  template <>
+  struct make_signed<unsigned long>
+  {
+    typedef long type;
+  };
+  template <>
+  struct make_signed<unsigned long long>
+  {
+    typedef long long type;
+  };
+  template <typename T>
+  struct make_signed<const T> : add_const<typename make_signed<T>::type>
+  {
+  };
+  template <typename T>
+  struct make_signed<volatile T> : add_volatile<typename make_signed<T>::type>
+  {
+  };
+  template <typename T>
+  struct make_signed<const volatile T> : add_const<typename add_volatile<typename make_signed<T>::type>::type>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using make_signed_t = typename make_signed<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// make_unsigned
-  template <typename T> struct make_unsigned { typedef  T type; };
-  template <> struct make_unsigned<char> { typedef unsigned char type; };
-  template <> struct make_unsigned<signed char> { typedef unsigned char type; };
-  template <> struct make_unsigned<short> { typedef unsigned short type; };
+  template <typename T>
+  struct make_unsigned
+  {
+    typedef T type;
+  };
+  template <>
+  struct make_unsigned<char>
+  {
+    typedef unsigned char type;
+  };
+  template <>
+  struct make_unsigned<signed char>
+  {
+    typedef unsigned char type;
+  };
+  template <>
+  struct make_unsigned<short>
+  {
+    typedef unsigned short type;
+  };
 
-  template <> struct make_unsigned<wchar_t>
+  template <>
+  struct make_unsigned<wchar_t>
   {
     typedef etl::conditional<sizeof(wchar_t) == sizeof(uint16_t),
                              uint16_t,
@@ -559,150 +966,231 @@ namespace etl
                                               void>::type>::type type;
   };
 
-  template <> struct make_unsigned<int> { typedef unsigned int type; };
-  template <> struct make_unsigned<long> { typedef unsigned long type; };
-  template <> struct make_unsigned<long long> { typedef unsigned long long type; };
-  template <typename T> struct make_unsigned<const T> : add_const<typename make_unsigned<T>::type> {};
-  template <typename T> struct make_unsigned<volatile T> : add_volatile<typename make_unsigned<T>::type> {};
-  template <typename T> struct make_unsigned<const volatile T> : add_const<typename add_volatile<typename make_unsigned<T>::type>::type> {};
+  template <>
+  struct make_unsigned<int>
+  {
+    typedef unsigned int type;
+  };
+  template <>
+  struct make_unsigned<long>
+  {
+    typedef unsigned long type;
+  };
+  template <>
+  struct make_unsigned<long long>
+  {
+    typedef unsigned long long type;
+  };
+  template <typename T>
+  struct make_unsigned<const T> : add_const<typename make_unsigned<T>::type>
+  {
+  };
+  template <typename T>
+  struct make_unsigned<volatile T> : add_volatile<typename make_unsigned<T>::type>
+  {
+  };
+  template <typename T>
+  struct make_unsigned<const volatile T> : add_const<typename add_volatile<typename make_unsigned<T>::type>::type>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using make_unsigned_t = typename make_unsigned<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// enable_if
-  template <bool BValue, typename T = void> struct enable_if {};
-  template <typename T> struct enable_if<true, T> { typedef T type; };
+  template <bool BValue, typename T = void>
+  struct enable_if
+  {
+  };
+  template <typename T>
+  struct enable_if<true, T>
+  {
+    typedef T type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <bool BValue, typename T = void>
   using enable_if_t = typename enable_if<BValue, T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// extent
   template <typename T, unsigned Size = 0U>
-  struct extent : integral_constant<size_t, 0U> {};
+  struct extent : integral_constant<size_t, 0U>
+  {
+  };
 
   template <typename T>
-  struct extent<T[], 0> : integral_constant<size_t, 0U> {};
+  struct extent<T[], 0> : integral_constant<size_t, 0U>
+  {
+  };
 
   template <typename T, unsigned Size>
-  struct extent<T[], Size> : integral_constant<size_t, extent<T, Size - 1>::value> {};
+  struct extent<T[], Size> : integral_constant<size_t, extent<T, Size - 1>::value>
+  {
+  };
 
   template <typename T, unsigned Size>
-  struct extent<T[Size], 0> : integral_constant<size_t, Size> {};
+  struct extent<T[Size], 0> : integral_constant<size_t, Size>
+  {
+  };
 
   template <typename T, unsigned I, unsigned Size>
-  struct extent<T[I], Size> : integral_constant<size_t, extent<T, Size - 1>::value> {};
+  struct extent<T[I], Size> : integral_constant<size_t, extent<T, Size - 1>::value>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T, unsigned Size = 0U>
   inline constexpr size_t extent_v = extent<T, Size>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_extent
-  template <typename T> struct remove_extent { typedef T type; };
-  template <typename T> struct remove_extent<T[]> { typedef T type; };
-  template <typename T, size_t Size> struct remove_extent<T[Size]> { typedef T type; };
+  template <typename T>
+  struct remove_extent
+  {
+    typedef T type;
+  };
+  template <typename T>
+  struct remove_extent<T[]>
+  {
+    typedef T type;
+  };
+  template <typename T, size_t Size>
+  struct remove_extent<T[Size]>
+  {
+    typedef T type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_extent_t = typename remove_extent<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_all_extents
-  template <typename T> struct remove_all_extents { typedef T type; };
-  template <typename T> struct remove_all_extents<T[]> { typedef typename remove_all_extents<T>::type type; };
-  template <typename T, size_t Size> struct remove_all_extents<T[Size]> { typedef typename remove_all_extents<T>::type type; };
+  template <typename T>
+  struct remove_all_extents
+  {
+    typedef T type;
+  };
+  template <typename T>
+  struct remove_all_extents<T[]>
+  {
+    typedef typename remove_all_extents<T>::type type;
+  };
+  template <typename T, size_t Size>
+  struct remove_all_extents<T[Size]>
+  {
+    typedef typename remove_all_extents<T>::type type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_all_extents_t = typename remove_all_extents<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// rank
-  template <typename T>struct rank : integral_constant<size_t, 0> {};
-  template <typename T> struct rank<T[]> : public integral_constant<size_t, rank<T>::value + 1> {};
-  template <typename T, size_t Size> struct rank<T[Size]> : public integral_constant<size_t, rank<T>::value + 1> {};
+  template <typename T>
+  struct rank : integral_constant<size_t, 0>
+  {
+  };
+  template <typename T>
+  struct rank<T[]> : public integral_constant<size_t, rank<T>::value + 1>
+  {
+  };
+  template <typename T, size_t Size>
+  struct rank<T[Size]> : public integral_constant<size_t, rank<T>::value + 1>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr size_t rank_v = rank<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// decay
   template <typename T>
   struct decay
   {
-    typedef typename etl::remove_reference<T>::type U;
+    typedef typename etl::remove_reference<T>::type                           U;
     typedef typename etl::conditional<etl::is_array<U>::value,
                                       typename etl::remove_extent<U>::type*,
                                       typename etl::remove_cv<U>::type>::type type;
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using decay_t = typename decay<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_class
   namespace private_type_traits
   {
-    template <typename T> char test(int T::*); // Match for classes.
+    template <typename T>
+    char test(int T::*); // Match for classes.
 
-    struct dummy { char c[2]; };
-    template <typename T> dummy test(...);     // Match for non-classes.
-  }
+    struct dummy
+    {
+      char c[2];
+    };
+    template <typename T>
+    dummy test(...); // Match for non-classes.
+  } // namespace private_type_traits
 
   template <typename T>
-  struct is_class : etl::bool_constant<sizeof(private_type_traits::test<T>(0)) == 1U> {};
+  struct is_class : etl::bool_constant<sizeof(private_type_traits::test<T>(0)) == 1U>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_class_v = is_class<T>::value;
-#endif
+    #endif
 
-  //***************************************************************************
-  /// is_base_of
-#if ETL_USING_CPP11
+    //***************************************************************************
+    /// is_base_of
+    #if ETL_USING_CPP11
   namespace private_type_traits
   {
-    template<typename B>
+    template <typename B>
     etl::true_type test_ptr_conv(const volatile B*);
-    template<typename>
+    template <typename>
     etl::false_type test_ptr_conv(const volatile void*);
 
-    template<typename B, typename D>
+    template <typename B, typename D>
     auto test_is_base_of(int) -> decltype(test_ptr_conv<B>(static_cast<D*>(nullptr)));
-    template<typename, typename>
+    template <typename, typename>
     auto test_is_base_of(...) -> etl::true_type; // private or ambiguous base
-  }
+  } // namespace private_type_traits
 
-  template<typename TBase, typename TDerived>
-  struct is_base_of: etl::integral_constant<
-    bool,
-    etl::is_class<TBase>::value &&
-    etl::is_class<TDerived>::value &&
-    decltype(private_type_traits::test_is_base_of<TBase, TDerived>(0))::value
-    > {};
-#else
-  template<typename TBase,
-           typename TDerived,
-           const bool IsFundamental = (etl::is_fundamental<TBase>::value || etl::is_fundamental<TDerived>::value || etl::is_array<TDerived>::value)>
+  template <typename TBase, typename TDerived>
+  struct is_base_of : etl::integral_constant< bool, etl::is_class<TBase>::value && etl::is_class<TDerived>::value&& decltype(private_type_traits::test_is_base_of<TBase, TDerived>(0))::value >
+  {
+  };
+    #else
+  template <typename TBase,
+            typename TDerived,
+            const bool IsFundamental = (etl::is_fundamental<TBase>::value || etl::is_fundamental<TDerived>::value || etl::is_array<TDerived>::value)>
   struct is_base_of
   {
   private:
 
-    static TBase* check(TBase*) { return (TBase*)0; }
-    static char check(...) { return 0; }
+    static TBase* check(TBase*)
+    {
+      return (TBase*)0;
+    }
+    static char check(...)
+    {
+      return 0;
+    }
 
   public:
 
@@ -710,66 +1198,114 @@ namespace etl
   };
 
   // For when TBase or TDerived is a fundamental type.
-  template<typename TBase, typename TDerived>
+  template <typename TBase, typename TDerived>
   struct is_base_of<TBase, TDerived, true>
   {
     static const bool value = false;
   };
-#endif
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T1, typename T2>
   inline constexpr bool is_base_of_v = is_base_of<T1, T2>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_lvalue_reference
-  template <typename T> struct add_lvalue_reference { typedef T& type; };
-  template <typename T> struct add_lvalue_reference<T&> { typedef T& type; };
-  template <>           struct add_lvalue_reference<void> { typedef void type; };
-  template <>           struct add_lvalue_reference<const void> { typedef const void type; };
-  template <>           struct add_lvalue_reference<volatile void> { typedef volatile void type; };
-  template <>           struct add_lvalue_reference<const volatile void> { typedef const volatile void type; };
+  template <typename T>
+  struct add_lvalue_reference
+  {
+    typedef T& type;
+  };
+  template <typename T>
+  struct add_lvalue_reference<T&>
+  {
+    typedef T& type;
+  };
+  template <>
+  struct add_lvalue_reference<void>
+  {
+    typedef void type;
+  };
+  template <>
+  struct add_lvalue_reference<const void>
+  {
+    typedef const void type;
+  };
+  template <>
+  struct add_lvalue_reference<volatile void>
+  {
+    typedef volatile void type;
+  };
+  template <>
+  struct add_lvalue_reference<const volatile void>
+  {
+    typedef const volatile void type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_lvalue_reference_t = typename etl::add_lvalue_reference<T>::type;
-#endif
+    #endif
 
-  //***************************************************************************
-  /// add_rvalue_reference
-#if ETL_USING_CPP11
-  template <typename T> struct add_rvalue_reference { using type = T && ; };
-  template <typename T> struct add_rvalue_reference<T&> { using type = T & ; };
-  template <>           struct add_rvalue_reference<void> { using type = void; };
-  template <>           struct add_rvalue_reference<const void> { using type = const void; };
-  template <>           struct add_rvalue_reference<volatile void> { using type = volatile void; };
-  template <>           struct add_rvalue_reference<const volatile void> { using type = const volatile void; };
-#endif
+    //***************************************************************************
+    /// add_rvalue_reference
+    #if ETL_USING_CPP11
+  template <typename T>
+  struct add_rvalue_reference
+  {
+    using type = T&&;
+  };
+  template <typename T>
+  struct add_rvalue_reference<T&>
+  {
+    using type = T&;
+  };
+  template <>
+  struct add_rvalue_reference<void>
+  {
+    using type = void;
+  };
+  template <>
+  struct add_rvalue_reference<const void>
+  {
+    using type = const void;
+  };
+  template <>
+  struct add_rvalue_reference<volatile void>
+  {
+    using type = volatile void;
+  };
+  template <>
+  struct add_rvalue_reference<const volatile void>
+  {
+    using type = const volatile void;
+  };
+    #endif
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_rvalue_reference_t = typename etl::add_rvalue_reference<T>::type;
-#endif
+    #endif
 
-  //***************************************************************************
-  /// declval
-#if ETL_USING_CPP11
+    //***************************************************************************
+    /// declval
+    #if ETL_USING_CPP11
   template <typename T>
   typename etl::add_rvalue_reference<T>::type declval() ETL_NOEXCEPT;
-#endif
+    #endif
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   //***************************************************************************
   /// is_enum
   ///\ingroup type_traits
   /// Implemented by checking if type is convertible to an integer through static_cast
 
-  namespace private_type_traits 
+  namespace private_type_traits
   {
     // Base case
     template <typename T, typename = int>
-    struct is_convertible_to_int 
+    struct is_convertible_to_int
       : false_type
     {
     };
@@ -778,86 +1314,82 @@ namespace etl
     // 2nd template argument of base case defaults to int to ensure that this partial specialization is always tried first
     template <typename T>
     struct is_convertible_to_int<T, decltype(static_cast<int>(declval<T>()))>
-      : true_type 
+      : true_type
     {
     };
-  }
+  } // namespace private_type_traits
 
   template <typename T>
   struct is_enum
-    : integral_constant<bool, private_type_traits::is_convertible_to_int<T>::value &&
-                              !is_class<T>::value &&
-                              !is_arithmetic<T>::value &&
-                              !is_reference<T>::value> 
+    : integral_constant<bool, private_type_traits::is_convertible_to_int<T>::value && !is_class<T>::value && !is_arithmetic<T>::value && !is_reference<T>::value>
   {
   };
 
-#if ETL_USING_CPP17
+      #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_enum_v = etl::is_enum<T>::value;
-#endif
-#else
+      #endif
+    #else
   namespace private_type_traits
   {
     // Helper to detect if a type is convertible to an integer
     template <typename T>
     struct is_convertible_to_int
     {
-      static char test(int);   // Match if T is convertible to int
+      static char   test(int); // Match if T is convertible to int
       static double test(...); // Fallback for other types
 
       static const bool value = sizeof(test(static_cast<T>(0))) == sizeof(char);
     };
-  }
+  } // namespace private_type_traits
 
   // Implementation of is_enum
   template <typename T>
   struct is_enum
   {
-    static const bool value = private_type_traits::is_convertible_to_int<T>::value &&
-                              !is_class<T>::value &&
-                              !is_arithmetic<T>::value &&
-                              !is_reference<T>::value;
+    static const bool value = private_type_traits::is_convertible_to_int<T>::value && !is_class<T>::value && !is_arithmetic<T>::value && !is_reference<T>::value;
   };
-#endif
+    #endif
 
-  //***************************************************************************
-  /// is_convertible
-  ///\ingroup type_traits
-#if ETL_USING_CPP11
+    //***************************************************************************
+    /// is_convertible
+    ///\ingroup type_traits
+    #if ETL_USING_CPP11
   namespace private_type_traits
   {
     template <typename>
     using true_type_for = etl::true_type;
 
     template <typename T>
-    auto returnable(int)->true_type_for<T()>;
+    auto returnable(int) -> true_type_for<T()>;
 
     template <typename>
-    auto returnable(...)->etl::false_type;
+    auto returnable(...) -> etl::false_type;
 
     template <typename TFrom, typename TTo>
-    auto nonvoid_convertible(int)->true_type_for<decltype(etl::declval<void(&)(TTo)>()(etl::declval<TFrom>()))
-    >;
+    auto nonvoid_convertible(int) -> true_type_for<decltype(etl::declval<void (&)(TTo)>()(etl::declval<TFrom>())) >;
     template <typename, typename>
-    auto nonvoid_convertible(...)->etl::false_type;
-  }
+    auto nonvoid_convertible(...) -> etl::false_type;
+  } // namespace private_type_traits
 
-#if defined(ETL_COMPILER_ARM5)
+      #if defined(ETL_COMPILER_ARM5)
   template <typename TFrom, typename TTo>
-  struct is_convertible : etl::bool_constant<__is_convertible_to(TFrom, TTo)> {};
-#else
+  struct is_convertible : etl::bool_constant<__is_convertible_to(TFrom, TTo)>
+  {
+  };
+      #else
   template <typename TFrom, typename TTo>
-  struct is_convertible : etl::bool_constant<(decltype(private_type_traits::returnable<TTo>(0))::value &&
-                                              decltype(private_type_traits::nonvoid_convertible<TFrom, TTo>(0))::value) ||
-                                              (etl::is_void<TFrom>::value && etl::is_void<TTo>::value)> {};
-#endif
+  struct is_convertible : etl::bool_constant<(decltype(private_type_traits::returnable<TTo>(0))::value && decltype(private_type_traits::nonvoid_convertible<TFrom, TTo>(0))::value) || (etl::is_void<TFrom>::value && etl::is_void<TTo>::value)>
+  {
+  };
+      #endif
 
   // Is convertible and the conversion is noexcept.
   template <typename TFrom, typename TTo>
   struct is_nothrow_convertible
   {
   private:
+
     // Helper: a function taking TTo to require the conversion.
     static void sink(TTo) noexcept;
 
@@ -870,515 +1402,659 @@ namespace etl
     static etl::false_type test(...);
 
   public:
+
     static ETL_CONSTANT bool value = decltype(test<TFrom>(0))::value;
   };
-#endif
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename TFrom, typename TTo >
   inline constexpr bool is_convertible_v = etl::is_convertible<TFrom, TTo>::value;
 
   template <typename TFrom, typename TTo >
   inline constexpr bool is_nothrow_convertible_v = etl::is_nothrow_convertible<TFrom, TTo>::value;
-#endif
+    #endif
 
-  //***************************************************************************
-  /// Alignment templates.
-  /// These require compiler specific intrinsics.
-#if ETL_USING_CPP11 && !defined(ETL_COMPILER_ARM5)
-  template <typename T> struct alignment_of : integral_constant<size_t, alignof(T)> { };
-#elif defined(ETL_COMPILER_MICROSOFT)
-  template <typename T> struct alignment_of : integral_constant<size_t, size_t(__alignof(T))> {};
-#elif defined(ETL_COMPILER_IAR) || defined(ETL_COMPILER_TI)
-  template <typename T> struct alignment_of : integral_constant<size_t, size_t(__ALIGNOF__(T))> {};
-#else
-  template <typename T> struct alignment_of : integral_constant<size_t, size_t(__alignof__(T))> {};
-#endif
+    //***************************************************************************
+    /// Alignment templates.
+    /// These require compiler specific intrinsics.
+    #if ETL_USING_CPP11 && !defined(ETL_COMPILER_ARM5)
+  template <typename T>
+  struct alignment_of : integral_constant<size_t, alignof(T)>
+  {
+  };
+    #elif defined(ETL_COMPILER_MICROSOFT)
+  template <typename T>
+  struct alignment_of : integral_constant<size_t, size_t(__alignof(T))>
+  {
+  };
+    #elif defined(ETL_COMPILER_IAR) || defined(ETL_COMPILER_TI)
+  template <typename T>
+  struct alignment_of : integral_constant<size_t, size_t(__ALIGNOF__(T))>
+  {
+  };
+    #else
+  template <typename T>
+  struct alignment_of : integral_constant<size_t, size_t(__alignof__(T))>
+  {
+  };
+    #endif
 
   /// Specialisation of 'alignment_of' for 'void'.
   ///\ingroup type_traits
-  template <> struct alignment_of<void> : integral_constant <size_t, 0> {};
-  template <> struct alignment_of<const void> : integral_constant <size_t, 0> {};
+  template <>
+  struct alignment_of<void> : integral_constant<size_t, 0>
+  {
+  };
+  template <>
+  struct alignment_of<const void> : integral_constant<size_t, 0>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr size_t alignment_of_v = etl::alignment_of<T>::value;
-#endif
+    #endif
 
-#else // Condition = ETL_USING_STL && ETL_USING_CPP11
+  #else // Condition = ETL_USING_STL && ETL_USING_CPP11
 
-//*****************************************************************************
-// Traits are derived from the STL
-//*****************************************************************************
+  //*****************************************************************************
+  // Traits are derived from the STL
+  //*****************************************************************************
 
   //***************************************************************************
   /// integral_constant
   ///\ingroup type_traits
   template <typename T, T VALUE>
-  struct integral_constant : std::integral_constant<T, VALUE> {};
+  struct integral_constant : std::integral_constant<T, VALUE>
+  {
+  };
 
-/// integral_constant specialisations
-///\ingroup type_traits
-typedef integral_constant<bool, false> false_type;
-typedef integral_constant<bool, true>  true_type;
+  /// integral_constant specialisations
+  ///\ingroup type_traits
+  typedef integral_constant<bool, false> false_type;
+  typedef integral_constant<bool, true>  true_type;
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T, T VALUE>
   inline constexpr T integral_constant_v = std::integral_constant<T, VALUE>::value;
-#endif
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <bool BValue>
   using bool_constant = std::bool_constant<BValue>;
-#else
+    #else
   template <bool BValue>
-  struct bool_constant : std::integral_constant<bool, BValue> { };
-#endif
+  struct bool_constant : std::integral_constant<bool, BValue>
+  {
+  };
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <bool BValue>
   inline constexpr bool bool_constant_v = bool_constant<BValue>::value;
-#endif
+    #endif
 
-  //***************************************************************************
-  /// negation
-  ///\ingroup type_traits
-#if ETL_USING_CPP17
+    //***************************************************************************
+    /// negation
+    ///\ingroup type_traits
+    #if ETL_USING_CPP17
   template <typename T>
   using negation = std::negation<T>;
-#else
+    #else
   template <typename T>
   struct negation : etl::bool_constant<!bool(T::value)>
   {
   };
-#endif
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool negation_v = std::negation_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_reference
   ///\ingroup type_traits
-  template <typename T> struct remove_reference : std::remove_reference<T> {};
+  template <typename T>
+  struct remove_reference : std::remove_reference<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_reference_t = typename std::remove_reference<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_pointer
   ///\ingroup type_traits
-  template <typename T> struct remove_pointer : std::remove_pointer<T> {};
+  template <typename T>
+  struct remove_pointer : std::remove_pointer<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_pointer_t = typename std::remove_pointer<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_pointer
   ///\ingroup type_traits
-  template <typename T> struct add_pointer : std::add_pointer<T> {};
+  template <typename T>
+  struct add_pointer : std::add_pointer<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_pointer_t = typename std::add_pointer<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_const
   ///\ingroup type_traits
-  template <typename T> struct is_const : std::is_const<T> {};
+  template <typename T>
+  struct is_const : std::is_const<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_const_v = std::is_const_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_const
   ///\ingroup type_traits
-  template <typename T> struct remove_const : std::remove_const<T> {};
+  template <typename T>
+  struct remove_const : std::remove_const<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_const_t = typename std::remove_const<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_const
   ///\ingroup type_traits
-  template <typename T> struct add_const : std::add_const<T> {};
+  template <typename T>
+  struct add_const : std::add_const<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_const_t = typename std::add_const<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_volatile
   ///\ingroup type_traits
-  template <typename T> struct is_volatile : std::is_volatile<T> {};
+  template <typename T>
+  struct is_volatile : std::is_volatile<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_volatile_v = std::is_volatile_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_volatile
   ///\ingroup type_traits
-  template <typename T> struct remove_volatile : std::remove_volatile<T> {};
+  template <typename T>
+  struct remove_volatile : std::remove_volatile<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_volatile_t = typename std::remove_volatile<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_volatile
   ///\ingroup type_traits
-  template <typename T> struct add_volatile : std::add_volatile<T> {};
+  template <typename T>
+  struct add_volatile : std::add_volatile<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_volatile_t = typename std::add_volatile<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_cv
   ///\ingroup type_traits
-  template <typename T> struct remove_cv : std::remove_cv<T> {};
+  template <typename T>
+  struct remove_cv : std::remove_cv<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_cv_t = typename std::remove_cv<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_cv
   ///\ingroup type_traits
-  template <typename T> struct add_cv : std::add_cv<T> {};
+  template <typename T>
+  struct add_cv : std::add_cv<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_cv_t = typename std::add_cv<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_cvref
   ///\ingroup type_traits
-  template <typename T> struct remove_cvref
+  template <typename T>
+  struct remove_cvref
   {
     typedef typename std::remove_cv<typename std::remove_reference<T>::type>::type type;
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_cvref_t = typename etl::remove_cvref<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_integral
   ///\ingroup type_traits
-  template <typename T> struct is_integral : std::is_integral<T> {};
+  template <typename T>
+  struct is_integral : std::is_integral<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_integral_v = std::is_integral_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_signed
   ///\ingroup type_traits
-  template <typename T> struct is_signed : std::is_signed<T> {};
+  template <typename T>
+  struct is_signed : std::is_signed<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_signed_v = std::is_signed_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_unsigned
   ///\ingroup type_traits
-  template <typename T> struct is_unsigned : std::is_unsigned<T> {};
+  template <typename T>
+  struct is_unsigned : std::is_unsigned<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_unsigned_v = std::is_unsigned_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_floating_point
   ///\ingroup type_traits
-  template <typename T> struct is_floating_point : std::is_floating_point<T> {};
+  template <typename T>
+  struct is_floating_point : std::is_floating_point<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_floating_point_v = std::is_floating_point_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_same
   ///\ingroup type_traits
-  template <typename T1, typename T2> struct is_same : std::is_same<T1, T2> {};
+  template <typename T1, typename T2>
+  struct is_same : std::is_same<T1, T2>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T1, typename T2>
   inline constexpr bool is_same_v = std::is_same_v<T1, T2>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_void
   ///\ingroup type_traits
-  template<typename T> struct is_void : std::is_void<T> {};
+  template <typename T>
+  struct is_void : std::is_void<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_void_v = std::is_void_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_arithmetic
   ///\ingroup type_traits
-  template<typename T> struct is_arithmetic : std::is_arithmetic<T> {};
+  template <typename T>
+  struct is_arithmetic : std::is_arithmetic<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_arithmetic_v = std::is_arithmetic_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_fundamental
   ///\ingroup type_traits
-  template <typename T> struct is_fundamental : std::is_fundamental<T> {};
+  template <typename T>
+  struct is_fundamental : std::is_fundamental<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_fundamental_v = std::is_fundamental_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_compound
   ///\ingroup type_traits
-  template <typename T> struct is_compound : std::is_compound<T> {};
+  template <typename T>
+  struct is_compound : std::is_compound<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_compound_v = std::is_compound_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_array
   ///\ingroup type_traits
-  template <typename T> struct is_array : std::is_array<T> {};
+  template <typename T>
+  struct is_array : std::is_array<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_array_v = std::is_array_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_pointer
   ///\ingroup type_traits
-  template<typename T> struct is_pointer : std::is_pointer<T> {};
+  template <typename T>
+  struct is_pointer : std::is_pointer<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_pointer_v = std::is_pointer_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_reference
   ///\ingroup type_traits
-  template<typename T> struct is_reference : std::is_reference<T> {};
+  template <typename T>
+  struct is_reference : std::is_reference<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_reference_v = std::is_reference_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_lvalue_reference
   ///\ingroup type_traits
-  template<typename T> struct is_lvalue_reference : std::is_lvalue_reference<T> {};
+  template <typename T>
+  struct is_lvalue_reference : std::is_lvalue_reference<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_lvalue_reference_v = std::is_lvalue_reference_v<T>;
-#endif
+    #endif
 
-  //***************************************************************************
-  /// is_rvalue_reference
-  ///\ingroup type_traits
-#if ETL_USING_CPP11
-  template<typename T> struct is_rvalue_reference : std::is_rvalue_reference<T> {};
+    //***************************************************************************
+    /// is_rvalue_reference
+    ///\ingroup type_traits
+    #if ETL_USING_CPP11
+  template <typename T>
+  struct is_rvalue_reference : std::is_rvalue_reference<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+      #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_rvalue_reference_v = std::is_rvalue_reference_v<T>;
-#endif
-#endif
+      #endif
+    #endif
 
   //***************************************************************************
   /// is_pod
   ///\ingroup type_traits
   template <typename T>
-  struct is_pod : std::integral_constant<bool, std::is_standard_layout<T>::value && std::is_trivially_default_constructible<T>::value && std::is_trivially_copyable<T>::value> {};
+  struct is_pod : std::integral_constant<bool, std::is_standard_layout<T>::value && std::is_trivially_default_constructible<T>::value && std::is_trivially_copyable<T>::value>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_pod_v = std::is_standard_layout_v<T> && std::is_trivially_default_constructible_v<T> && std::is_trivially_copyable_v<T>;
-#endif
+    #endif
 
-#if defined(ETL_COMPILER_GCC)
-  #if ETL_COMPILER_VERSION >= 5
-    #define ETL_GCC_V5_TYPE_TRAITS_SUPPORTED
-  #endif
-#endif
+    #if defined(ETL_COMPILER_GCC)
+      #if ETL_COMPILER_VERSION >= 5
+        #define ETL_GCC_V5_TYPE_TRAITS_SUPPORTED
+      #endif
+    #endif
 
   //***************************************************************************
   /// conditional
   ///\ingroup type_traits
-  template <bool BValue, typename T, typename F>  struct conditional { typedef T type; };
-  template <typename T, typename F> struct conditional<false, T, F> { typedef F type; };
+  template <bool BValue, typename T, typename F>
+  struct conditional
+  {
+    typedef T type;
+  };
+  template <typename T, typename F>
+  struct conditional<false, T, F>
+  {
+    typedef F type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <bool BValue, typename T, typename F>
   using conditional_t = typename conditional<BValue, T, F>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// make_signed
   ///\ingroup type_traits
-  template <typename T> struct make_signed : std::make_signed<T> {};
+  template <typename T>
+  struct make_signed : std::make_signed<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using make_signed_t = typename std::make_signed<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// make_unsigned
   ///\ingroup type_traits
-  template <typename T> struct make_unsigned : std::make_unsigned<T> {};
+  template <typename T>
+  struct make_unsigned : std::make_unsigned<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using make_unsigned_t = typename std::make_unsigned<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// enable_if
   ///\ingroup type_traits
-  template <bool BValue, typename T = void> struct enable_if : std::enable_if<BValue, T> {};
+  template <bool BValue, typename T = void>
+  struct enable_if : std::enable_if<BValue, T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <bool BValue, typename T = void>
   using enable_if_t = typename std::enable_if<BValue, T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// extent
   ///\ingroup type_traits
   template <typename T, unsigned Size = 0U>
-  struct extent : std::extent<T, Size> {};
+  struct extent : std::extent<T, Size>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T, unsigned Size = 0U>
   inline constexpr size_t extent_v = std::extent_v<T, Size>;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_extent
   ///\ingroup type_traits
-  template <typename T> struct remove_extent : std::remove_extent<T> { };
+  template <typename T>
+  struct remove_extent : std::remove_extent<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_extent_t = typename std::remove_extent<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_all_extents
   ///\ingroup type_traits
-  template <typename T> struct remove_all_extents : std::remove_all_extents<T> { };
+  template <typename T>
+  struct remove_all_extents : std::remove_all_extents<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_all_extents_t = typename std::remove_all_extents<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// rank
   ///\ingroup type_traits
-  template <typename T>struct rank : std::rank<T> {};
+  template <typename T>
+  struct rank : std::rank<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr size_t rank_v = std::rank_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// decay
   ///\ingroup type_traits
-  template <typename T> struct decay : std::decay<T> {};
+  template <typename T>
+  struct decay : std::decay<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using decay_t = typename std::decay<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_base_of
   ///\ingroup type_traits
-  template<typename TBase, typename TDerived> struct is_base_of : std::is_base_of<TBase, TDerived> {};
+  template <typename TBase, typename TDerived>
+  struct is_base_of : std::is_base_of<TBase, TDerived>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename TBase, typename TDerived>
   inline constexpr bool is_base_of_v = std::is_base_of_v<TBase, TDerived>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_class
-  template <typename T> struct is_class : std::is_class<T>{};
+  template <typename T>
+  struct is_class : std::is_class<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_class_v = is_class<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_lvalue_reference
-  template <typename T> struct add_lvalue_reference : std::add_lvalue_reference<T> {};
+  template <typename T>
+  struct add_lvalue_reference : std::add_lvalue_reference<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_lvalue_reference_t = typename std::add_lvalue_reference<T>::type;
-#endif
+    #endif
 
-  //***************************************************************************
-  /// add_rvalue_reference
-#if ETL_USING_CPP11
-  template <typename T> struct add_rvalue_reference : std::add_rvalue_reference<T> {};
-#endif
+    //***************************************************************************
+    /// add_rvalue_reference
+    #if ETL_USING_CPP11
+  template <typename T>
+  struct add_rvalue_reference : std::add_rvalue_reference<T>
+  {
+  };
+    #endif
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_rvalue_reference_t = typename std::add_rvalue_reference<T>::type;
-#endif
+    #endif
 
-  //***************************************************************************
-  /// declval
-#if ETL_USING_CPP11
+    //***************************************************************************
+    /// declval
+    #if ETL_USING_CPP11
   template <typename T>
   typename std::add_rvalue_reference<T>::type declval() ETL_NOEXCEPT;
-#endif
+    #endif
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   //***************************************************************************
   /// is_enum
   ///\ingroup type_traits
@@ -1387,25 +2063,28 @@ typedef integral_constant<bool, true>  true_type;
   {
   };
 
-#if ETL_USING_CPP17
+      #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_enum_v = etl::is_enum<T>::value;
-#endif
+      #endif
 
-#endif
+    #endif
 
-  //***************************************************************************
-  /// is_convertible
-  ///\ingroup type_traits
-#if ETL_USING_CPP11
+    //***************************************************************************
+    /// is_convertible
+    ///\ingroup type_traits
+    #if ETL_USING_CPP11
   template <typename TFrom, typename TTo>
-  struct is_convertible : std::is_convertible<TFrom, TTo> {};
+  struct is_convertible : std::is_convertible<TFrom, TTo>
+  {
+  };
 
   // Is convertible and the conversion is noexcept.
   template <typename TFrom, typename TTo>
   struct is_nothrow_convertible
   {
   private:
+
     // Helper: a function taking TTo to require the conversion.
     static void sink(TTo) noexcept;
 
@@ -1418,40 +2097,50 @@ typedef integral_constant<bool, true>  true_type;
     static etl::false_type test(...);
 
   public:
+
     static ETL_CONSTANT bool value = decltype(test<TFrom>(0))::value;
   };
-#endif
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename TFrom, typename TTo>
   inline constexpr bool is_convertible_v = std::is_convertible_v<TFrom, TTo>;
 
   template <typename TFrom, typename TTo >
   inline constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<TFrom, TTo>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// Alignment templates.
   ///\ingroup type_traits
-  template <typename T> struct alignment_of : std::alignment_of<T> {};
-  template <> struct alignment_of<void> : std::integral_constant<size_t, 0> {};
-  template <> struct alignment_of<const void> : std::integral_constant <size_t, 0> {};
+  template <typename T>
+  struct alignment_of : std::alignment_of<T>
+  {
+  };
+  template <>
+  struct alignment_of<void> : std::integral_constant<size_t, 0>
+  {
+  };
+  template <>
+  struct alignment_of<const void> : std::integral_constant<size_t, 0>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr size_t alignment_of_v = std::alignment_of_v<T>;
-#endif
+    #endif
 
-#endif // Condition = ETL_USING_STL && ETL_USING_CPP11
+  #endif // Condition = ETL_USING_STL && ETL_USING_CPP11
 
   //***************************************************************************
   // ETL extended type traits.
   //***************************************************************************
 
-#if ETL_USING_CPP11
-  //***************************************************************************
-  /// conjunction
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
+    //***************************************************************************
+    /// conjunction
+    #if ETL_USING_CPP11
   template <typename...>
   struct conjunction : public etl::true_type
   {
@@ -1466,16 +2155,16 @@ typedef integral_constant<bool, true>  true_type;
   struct conjunction<T> : public T
   {
   };
-#endif
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename... T>
   inline constexpr bool conjunction_v = conjunction<T...>::value;
-#endif
+    #endif
 
-  //***************************************************************************
-  /// disjunction
-#if ETL_USING_CPP11
+    //***************************************************************************
+    /// disjunction
+    #if ETL_USING_CPP11
   template <typename...>
   struct disjunction : public etl::false_type
   {
@@ -1486,21 +2175,22 @@ typedef integral_constant<bool, true>  true_type;
   {
   };
 
-  template <typename T1> struct disjunction<T1> : public T1
+  template <typename T1>
+  struct disjunction<T1> : public T1
   {
   };
-#endif
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename... T>
   inline constexpr bool disjunction_v = etl::disjunction<T...>::value;
-#endif
+    #endif
 
-#endif
+  #endif
 
   //***************************************************************************
   /// exclusive_disjunction
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename... TTypes>
   struct exclusive_disjunction;
 
@@ -1514,12 +2204,12 @@ typedef integral_constant<bool, true>  true_type;
   struct exclusive_disjunction<T1, T2, TRest...> : public etl::exclusive_disjunction<etl::integral_constant<bool, etl::disjunction<T1, T2>::value && !etl::conjunction<T1, T2>::value>, TRest...>
   {
   };
-#endif
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename... T>
   inline constexpr bool exclusive_disjunction_v = etl::exclusive_disjunction<T...>::value;
-#endif
+  #endif
 
   //***************************************************************************
   /// conditional_integral_constant
@@ -1541,7 +2231,7 @@ typedef integral_constant<bool, true>  true_type;
     static const T value = FALSE_VALUE;
   };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //***************************************************************************
   /// Template to determine if a type is a base of all types in a specified list.
   ///\ingroup types
@@ -1549,71 +2239,76 @@ typedef integral_constant<bool, true>  true_type;
   struct is_one_of : etl::disjunction<etl::is_same<T, TRest>...>
   {
   };
-#else
-  /*[[[cog
+  #else
+    /*[[[cog
   import cog
   cog.outl("//***************************************************************************")
   cog.outl("/// Template to determine if a type is one of a specified list.")
   cog.outl("///\\ingroup types")
   cog.outl("template <typename T,")
-  cog.out("          ")
-  cog.out("typename T1, ")
+  cog.out("         ")
+  cog.out(" typename T1,")
   for n in range(2, int(IsOneOf)):
-      cog.out("typename T%s = void, " % n)
+      cog.out(" typename T%s = void," % n)
       if n % 4 == 0:
           cog.outl("")
-          cog.out("          ")
-  cog.outl("typename T%s = void>" % IsOneOf)
+          cog.out("         ")
+  cog.outl(" typename T%s = void>" % IsOneOf)
   cog.outl("struct is_one_of")
   cog.outl("{")
-  cog.outl("  static const bool value = ")
-  for n in range(1, int(IsOneOf)):
-      cog.outl("      etl::is_same<T, T%s>::value ||" % n)
-  cog.outl("      etl::is_same<T, T%s>::value;" % IsOneOf)
+  cog.out("  static const bool value = etl::is_same<T, T1>::value")
+  for n in range(2, int(IsOneOf) + 1):
+      if n == int(IsOneOf):
+          cog.outl(" || etl::is_same<T, T%s>::value;" % n)
+      elif (n - 1) % 4 == 0:
+          cog.outl("")
+          cog.out("                            || etl::is_same<T, T%s>::value" % n)
+      else:
+          cog.out(" || etl::is_same<T, T%s>::value" % n)
   cog.outl("};")
   ]]]*/
-  /*[[[end]]]*/
-#endif
+    /*[[[end]]]*/
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T, typename... TRest>
   inline constexpr bool is_one_of_v = etl::is_one_of<T, TRest...>::value;
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   namespace private_type_traits
   {
     //***************************************************************************
     // Helper to count occurrences of a type in a list of types
-    template<typename T, typename... TTypes>
+    template <typename T, typename... TTypes>
     struct count_type;
 
     // Base case: zero occurrences
-    template<typename T>
+    template <typename T>
     struct count_type<T> : etl::integral_constant<size_t, 0>
     {
     };
 
     // Recursive case: increment count if head is the same as T, otherwise continue with tail
-    template<typename T, typename THead, typename... TTail>
+    template <typename T, typename THead, typename... TTail>
     struct count_type<T, THead, TTail...> : etl::integral_constant<size_t, (etl::is_same<T, THead>::value ? 1 : 0) + count_type<T, TTail...>::value>
     {
     };
-  }
+  } // namespace private_type_traits
 
-  template<typename T, typename... TTypes>
+  template <typename T, typename... TTypes>
   struct has_duplicates_of
     : etl::integral_constant<bool, (private_type_traits::count_type<T, TTypes...>::value > 1)>
   {
   };
-#endif
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T, typename... TRest>
   inline constexpr bool has_duplicates_of_v = etl::has_duplicates_of<T, TRest...>::value;
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //***************************************************************************
   /// Template to determine if a type is a base of all types in a specified list.
   ///\ingroup types
@@ -1621,14 +2316,14 @@ typedef integral_constant<bool, true>  true_type;
   struct is_base_of_all : etl::conjunction<etl::is_base_of<TBase, TDerived>...>
   {
   };
-#endif
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T, typename... TRest>
   inline constexpr bool is_base_of_all_v = etl::is_base_of_all<T, TRest...>::value;
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //***************************************************************************
   /// Template to determine if a type is a base of any type in a specified list.
   ///\ingroup types
@@ -1637,17 +2332,17 @@ typedef integral_constant<bool, true>  true_type;
   {
   };
 
-#endif
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T, typename... TRest>
   inline constexpr bool is_base_of_any_v = etl::is_base_of_any<T, TRest...>::value;
-#endif
+  #endif
 
   //***************************************************************************
   /// Get the Nth base of a recursively inherited type.
   /// Requires that the class has defined 'base_type'.
-  //*************************************************************************** 
+  //***************************************************************************
   // Recursive definition of the type.
   template <size_t Index, typename TType>
   struct nth_base
@@ -1661,10 +2356,10 @@ typedef integral_constant<bool, true>  true_type;
     typedef TType type;
   };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <size_t Index, typename TType>
   using nth_base_t = typename nth_base<Index, TType>::type;
-#endif
+  #endif
 
   //***************************************************************************
   /// A set of templates to allow related types to be derived.
@@ -1687,9 +2382,9 @@ typedef integral_constant<bool, true>  true_type;
     typedef const type_t*       const_pointer;
     typedef const type_t* const const_pointer_const;
 
-#if ETL_USING_CPP11
-    typedef type_t&&            rvalue_reference;
-#endif
+  #if ETL_USING_CPP11
+    typedef type_t&& rvalue_reference;
+  #endif
   };
 
   // Pointers.
@@ -1709,9 +2404,9 @@ typedef integral_constant<bool, true>  true_type;
     typedef const type_t*       const_pointer;
     typedef const type_t* const const_pointer_const;
 
-#if ETL_USING_CPP11
-    typedef type_t&&            rvalue_reference;
-#endif
+  #if ETL_USING_CPP11
+    typedef type_t&& rvalue_reference;
+  #endif
   };
 
   // Pointers.
@@ -1728,12 +2423,12 @@ typedef integral_constant<bool, true>  true_type;
     typedef type_t&             reference;
     typedef const type_t&       const_reference;
     typedef type_t*             pointer;
-    typedef const type_t* const_pointer;
+    typedef const type_t*       const_pointer;
     typedef const type_t* const const_pointer_const;
 
-#if ETL_USING_CPP11
-    typedef type_t&&            rvalue_reference;
-#endif
+  #if ETL_USING_CPP11
+    typedef type_t&& rvalue_reference;
+  #endif
   };
 
   // References.
@@ -1753,12 +2448,12 @@ typedef integral_constant<bool, true>  true_type;
     typedef const type_t*       const_pointer;
     typedef const type_t* const const_pointer_const;
 
-#if ETL_USING_CPP11
-    typedef type_t&&            rvalue_reference;
-#endif
+  #if ETL_USING_CPP11
+    typedef type_t&& rvalue_reference;
+  #endif
   };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   // rvalue References.
   template <typename T>
   struct types<T&&>
@@ -1776,13 +2471,13 @@ typedef integral_constant<bool, true>  true_type;
     typedef const type_t*       const_pointer;
     typedef const type_t* const const_pointer_const;
 
-#if ETL_USING_CPP11
-    typedef type_t&&            rvalue_reference;
-#endif
+    #if ETL_USING_CPP11
+    typedef type_t&& rvalue_reference;
+    #endif
   };
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename T>
   using types_t = typename types<T>::type;
 
@@ -1803,35 +2498,41 @@ typedef integral_constant<bool, true>  true_type;
 
   template <typename T>
   using types_cpc = typename types<T>::const_pointer_const;
-#endif
+  #endif
 
   //***************************************************************************
   /// size_of
   ///\ingroup types
-  template <typename T> struct size_of : etl::integral_constant<size_t, sizeof(T)> {};
-  template <> struct size_of<void> : etl::integral_constant<size_t, 1U> {};
+  template <typename T>
+  struct size_of : etl::integral_constant<size_t, sizeof(T)>
+  {
+  };
+  template <>
+  struct size_of<void> : etl::integral_constant<size_t, 1U>
+  {
+  };
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T>
   inline constexpr size_t size_of_v = etl::size_of<T>::value;
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //***************************************************************************
   /// are_all_same
   template <typename T, typename... TRest>
   struct are_all_same : etl::conjunction<etl::is_same<T, TRest>...>
   {
   };
-#endif
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T, typename... TRest>
   inline constexpr bool are_all_same_v = are_all_same<T, TRest...>::value;
-#endif
+  #endif
 
   //***************************************************************************
-#if ETL_USING_STL && ETL_USING_CPP11 && !defined(ETL_USE_TYPE_TRAITS_BUILTINS) && !defined(ETL_USER_DEFINED_TYPE_TRAITS) && ((!defined(ARDUINO) && ETL_NOT_USING_STLPORT) || defined(ETL_GCC_V5_TYPE_TRAITS_SUPPORTED))
+  #if ETL_USING_STL && ETL_USING_CPP11 && !defined(ETL_USE_TYPE_TRAITS_BUILTINS) && !defined(ETL_USER_DEFINED_TYPE_TRAITS) && ((!defined(ARDUINO) && ETL_NOT_USING_STLPORT) || defined(ETL_GCC_V5_TYPE_TRAITS_SUPPORTED))
 
   //*********************************************
   // Use the STL's definitions.
@@ -1839,12 +2540,12 @@ typedef integral_constant<bool, true>  true_type;
 
   //*********************************************
   // is_assignable
-  template<typename T1, typename T2>
+  template <typename T1, typename T2>
   using is_assignable = std::is_assignable<T1, T2>;
 
   //*********************************************
   // is_constructible
-  template<typename T, typename... TArgs>
+  template <typename T, typename... TArgs>
   using is_constructible = std::is_constructible<T, TArgs...>;
 
   //*********************************************
@@ -1857,57 +2558,57 @@ typedef integral_constant<bool, true>  true_type;
   template <typename T>
   using is_move_constructible = std::is_move_constructible<T>;
 
-  //*********************************************
-  // is_trivially_constructible
-#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
+    //*********************************************
+    // is_trivially_constructible
+    #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
   using is_trivially_constructible = std::is_trivially_constructible<T>;
-#else
+    #else
   template <typename T>
   using is_trivially_constructible = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
-#endif
+    #endif
 
-  //*********************************************
-  // is_trivially_copy_constructible
-#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
+    //*********************************************
+    // is_trivially_copy_constructible
+    #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
   using is_trivially_copy_constructible = std::is_trivially_copy_constructible<T>;
-#else
+    #else
   template <typename T>
   using is_trivially_copy_constructible = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
-#endif
+    #endif
 
-  //*********************************************
-  // is_trivially_destructible
-#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
+    //*********************************************
+    // is_trivially_destructible
+    #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
   using is_trivially_destructible = std::is_trivially_destructible<T>;
-#else
+    #else
   template <typename T>
   using is_trivially_destructible = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
-#endif
+    #endif
 
-  //*********************************************
-  // is_trivially_copy_assignable
-#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
+    //*********************************************
+    // is_trivially_copy_assignable
+    #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
   using is_trivially_copy_assignable = std::is_trivially_copy_assignable<T>;
-#else
+    #else
   template <typename T>
   using is_trivially_copy_assignable = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
-#endif
+    #endif
 
-  //*********************************************
-  // is_trivially_copyable
-#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
+    //*********************************************
+    // is_trivially_copyable
+    #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
   using is_trivially_copyable = std::is_trivially_copyable<T>;
-#else
+    #else
   template <typename T>
   using is_trivially_copyable = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
-#endif
+    #endif
 
-#elif defined(ETL_USE_TYPE_TRAITS_BUILTINS) && !defined(ETL_USER_DEFINED_TYPE_TRAITS)
+  #elif defined(ETL_USE_TYPE_TRAITS_BUILTINS) && !defined(ETL_USER_DEFINED_TYPE_TRAITS)
 
   //*********************************************
   // Use the compiler's builtins.
@@ -1915,24 +2616,24 @@ typedef integral_constant<bool, true>  true_type;
 
   //*********************************************
   // is_assignable
-  template<typename T1, typename T2>
+  template <typename T1, typename T2>
   struct is_assignable
   {
     static ETL_CONSTANT bool value = __is_assignable(T1, T2);
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   //*********************************************
   // is_constructible
-  template<typename T, typename... TArgs>
+  template <typename T, typename... TArgs>
   struct is_constructible
   {
     static ETL_CONSTANT bool value = __is_constructible(T, TArgs...);
   };
-#else
+    #else
   //*********************************************
   // is_constructible
-  template<typename T, typename TArgs = void>
+  template <typename T, typename TArgs = void>
   struct is_constructible
   {
     static ETL_CONSTANT bool value = __is_constructible(T, TArgs);
@@ -1940,12 +2641,12 @@ typedef integral_constant<bool, true>  true_type;
 
   //*********************************************
   // is_constructible
-  template<typename T>
+  template <typename T>
   struct is_constructible<T, void>
   {
     static ETL_CONSTANT bool value = __is_constructible(T);
   };
-#endif
+    #endif
 
   //*********************************************
   // is_copy_constructible
@@ -1961,29 +2662,29 @@ typedef integral_constant<bool, true>  true_type;
   {
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   //*********************************************
   // is_trivially_constructible
   template <typename T, typename... TArgs>
   struct is_trivially_constructible
   {
-#if defined(ETL_COMPILER_GCC)
+      #if defined(ETL_COMPILER_GCC)
     static ETL_CONSTANT bool value = __has_trivial_constructor(T);
-#else
+      #else
     static ETL_CONSTANT bool value = __is_trivially_constructible(T, TArgs...);
-#endif
+      #endif
   };
-#else
+    #else
   //*********************************************
   // is_trivially_constructible
   template <typename T, typename TArgs = void>
   struct is_trivially_constructible
   {
-#if defined(ETL_COMPILER_GCC)
+      #if defined(ETL_COMPILER_GCC)
     static ETL_CONSTANT bool value = __has_trivial_constructor(T);
-#else
+      #else
     static ETL_CONSTANT bool value = __is_trivially_constructible(T, TArgs);
-#endif
+      #endif
   };
 
   //*********************************************
@@ -1991,13 +2692,13 @@ typedef integral_constant<bool, true>  true_type;
   template <typename T>
   struct is_trivially_constructible<T, void>
   {
-#if defined(ETL_COMPILER_GCC)
+      #if defined(ETL_COMPILER_GCC)
     static ETL_CONSTANT bool value = __has_trivial_constructor(T);
-#else
+      #else
     static ETL_CONSTANT bool value = __is_trivially_constructible(T);
-#endif
+      #endif
   };
-#endif
+    #endif
 
   //*********************************************
   // is_trivially_copy_constructible
@@ -2011,11 +2712,11 @@ typedef integral_constant<bool, true>  true_type;
   template <typename T>
   struct is_trivially_destructible
   {
-#if defined(ETL_COMPILER_GCC)
+    #if defined(ETL_COMPILER_GCC)
     static ETL_CONSTANT bool value = __has_trivial_destructor(T);
-#else
+    #else
     static ETL_CONSTANT bool value = __is_trivially_destructible(T);
-#endif
+    #endif
   };
 
   //*********************************************
@@ -2023,11 +2724,11 @@ typedef integral_constant<bool, true>  true_type;
   template <typename T>
   struct is_trivially_copy_assignable
   {
-#if defined(ETL_COMPILER_GCC)
+    #if defined(ETL_COMPILER_GCC)
     static ETL_CONSTANT bool value = __has_trivial_copy(T);
-#else
+    #else
     static ETL_CONSTANT bool value = __is_trivially_copyable(T);
-#endif
+    #endif
   };
 
   //*********************************************
@@ -2035,14 +2736,14 @@ typedef integral_constant<bool, true>  true_type;
   template <typename T>
   struct is_trivially_copyable
   {
-#if defined(ETL_COMPILER_GCC)
+    #if defined(ETL_COMPILER_GCC)
     static ETL_CONSTANT bool value = __has_trivial_copy(T);
-#else
+    #else
     static ETL_CONSTANT bool value = __is_trivially_copyable(T);
-#endif
+    #endif
   };
 
-#elif defined(ETL_USER_DEFINED_TYPE_TRAITS) && !defined(ETL_USE_TYPE_TRAITS_BUILTINS)
+  #elif defined(ETL_USER_DEFINED_TYPE_TRAITS) && !defined(ETL_USE_TYPE_TRAITS_BUILTINS)
 
   //*********************************************
   // Force the user to provide specialisations for
@@ -2064,7 +2765,7 @@ typedef integral_constant<bool, true>  true_type;
   template <typename T1, typename T2>
   struct is_assignable<T1, T2, false>;
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   //*********************************************
   // is_constructible
   template <typename T, bool BValue, typename... TArgs>
@@ -2082,7 +2783,7 @@ typedef integral_constant<bool, true>  true_type;
   struct is_constructible : public is_constructible_helper<T, etl::is_arithmetic<T>::value || etl::is_pointer<T>::value, TArgs...>
   {
   };
-#endif
+    #endif
 
   //*********************************************
   // is_copy_constructible
@@ -2175,7 +2876,7 @@ typedef integral_constant<bool, true>  true_type;
   template <typename T>
   struct is_trivially_copyable<T, false>;
 
-#else
+  #else
 
   //*********************************************
   // Assume that anything other than arithmetics
@@ -2189,17 +2890,21 @@ typedef integral_constant<bool, true>  true_type;
   {
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   //***************************************************************************
   /// is_constructible
-  namespace private_type_traits 
+  namespace private_type_traits
   {
     template <class, class T, class... TArgs>
-    struct is_constructible_ : etl::false_type {};
+    struct is_constructible_ : etl::false_type
+    {
+    };
 
     template <class T, class... TArgs>
-    struct is_constructible_<void_t<decltype(T(etl::declval<TArgs>()...))>, T, TArgs...> : etl::true_type {};
-  }
+    struct is_constructible_<void_t<decltype(T(etl::declval<TArgs>()...))>, T, TArgs...> : etl::true_type
+    {
+    };
+  } // namespace private_type_traits
 
   //*********************************************
   // is_constructible
@@ -2208,21 +2913,51 @@ typedef integral_constant<bool, true>  true_type;
 
   //*********************************************
   // is_copy_constructible
-  template <class T> struct is_copy_constructible : public is_constructible<T,  typename etl::add_lvalue_reference<typename etl::add_const<T>::type>::type>{};
-  template <> struct is_copy_constructible<void> : public false_type{};
-  template <> struct is_copy_constructible<void const> : public false_type{};
-  template <> struct is_copy_constructible<void volatile> : public false_type{};
-  template <> struct is_copy_constructible<void const volatile> : public false_type{};
+  template <class T>
+  struct is_copy_constructible : public is_constructible<T, typename etl::add_lvalue_reference<typename etl::add_const<T>::type>::type>
+  {
+  };
+  template <>
+  struct is_copy_constructible<void> : public false_type
+  {
+  };
+  template <>
+  struct is_copy_constructible<void const> : public false_type
+  {
+  };
+  template <>
+  struct is_copy_constructible<void volatile> : public false_type
+  {
+  };
+  template <>
+  struct is_copy_constructible<void const volatile> : public false_type
+  {
+  };
 
   //*********************************************
   // is_move_constructible
-  template <typename T> struct is_move_constructible: public is_constructible<T, typename etl::add_rvalue_reference<T>::type>{};
-  template <> struct is_move_constructible<void> : public false_type{};
-  template <> struct is_move_constructible<void const> : public false_type{};
-  template <> struct is_move_constructible<void volatile> : public false_type{};
-  template <> struct is_move_constructible<void const volatile> : public false_type{};
+  template <typename T>
+  struct is_move_constructible : public is_constructible<T, typename etl::add_rvalue_reference<T>::type>
+  {
+  };
+  template <>
+  struct is_move_constructible<void> : public false_type
+  {
+  };
+  template <>
+  struct is_move_constructible<void const> : public false_type
+  {
+  };
+  template <>
+  struct is_move_constructible<void volatile> : public false_type
+  {
+  };
+  template <>
+  struct is_move_constructible<void const volatile> : public false_type
+  {
+  };
 
-#else
+    #else
 
   //*********************************************
   // is_copy_constructible
@@ -2237,7 +2972,7 @@ typedef integral_constant<bool, true>  true_type;
   struct is_move_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
   {
   };
-#endif
+    #endif
 
   //*********************************************
   // is_trivially_constructible
@@ -2274,30 +3009,33 @@ typedef integral_constant<bool, true>  true_type;
   {
   };
 
-#endif
+  #endif
 
   template <typename T1, typename T2>
-  struct is_lvalue_assignable : public etl::is_assignable<typename etl::add_lvalue_reference<T1>::type,
-                                                          typename etl::add_lvalue_reference<typename etl::add_const<T2>::type>::type>
+  struct is_lvalue_assignable : public etl::is_assignable<typename etl::add_lvalue_reference<T1>::type, typename etl::add_lvalue_reference<typename etl::add_const<T2>::type>::type>
   {
   };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //*********************************************
   // is_default_constructible
-  template<typename T, typename = void>
-  struct is_default_constructible : etl::false_type { };
+  template <typename T, typename = void>
+  struct is_default_constructible : etl::false_type
+  {
+  };
 
-  template<typename T>
-  struct is_default_constructible<T, etl::void_t<decltype(T())>> : etl::true_type { };
-#else
+  template <typename T>
+  struct is_default_constructible<T, etl::void_t<decltype(T())>> : etl::true_type
+  {
+  };
+  #else
   template <typename T>
   struct is_default_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
   {
   };
-#endif
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
 
   template <typename T1, typename T2>
   inline constexpr bool is_assignable_v = etl::is_assignable<T1, T2>::value;
@@ -2305,16 +3043,16 @@ typedef integral_constant<bool, true>  true_type;
   template <typename T1, typename T2>
   inline constexpr bool is_lvalue_assignable_v = etl::is_lvalue_assignable<T1, T2>::value;
 
-  template<typename T, typename... TArgs>
+  template <typename T, typename... TArgs>
   inline constexpr bool is_constructible_v = etl::is_constructible<T, TArgs...>::value;
 
-  template<typename T, typename... TArgs>
+  template <typename T, typename... TArgs>
   inline constexpr bool is_default_constructible_v = etl::is_default_constructible<T, TArgs...>::value;
 
-  template<typename T>
+  template <typename T>
   inline constexpr bool is_copy_constructible_v = etl::is_copy_constructible<T>::value;
 
-  template<typename T>
+  template <typename T>
   inline constexpr bool is_move_constructible_v = etl::is_move_constructible<T>::value;
 
   template <typename T>
@@ -2332,9 +3070,9 @@ typedef integral_constant<bool, true>  true_type;
   template <typename T>
   inline constexpr bool is_trivially_copyable_v = etl::is_trivially_copyable<T>::value;
 
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //*********************************************
   // common_type
   // Based on the sample implementation detailed on
@@ -2342,7 +3080,7 @@ typedef integral_constant<bool, true>  true_type;
   //*********************************************
   //***********************************
   // Primary template
-  template<typename...>
+  template <typename...>
   struct common_type
   {
   };
@@ -2371,7 +3109,7 @@ typedef integral_constant<bool, true>  true_type;
     };
 
     template <typename T1, typename T2, typename = void>
-    struct common_type_2_impl 
+    struct common_type_2_impl
       : decay_conditional_result<const T1&, const T2&>
     {
     };
@@ -2381,16 +3119,16 @@ typedef integral_constant<bool, true>  true_type;
       : decay_conditional_result<T1, T2>
     {
     };
-  }
+  } // namespace private_common_type
 
   //***********************************
   // Two types
   template <typename T1, typename T2>
   struct common_type<T1, T2>
-    : etl::conditional<etl::is_same<T1, typename etl::decay<T1>::type>::value&& etl::is_same<T2, typename etl::decay<T2>::type>::value,
+    : etl::conditional<etl::is_same<T1, typename etl::decay<T1>::type>::value && etl::is_same<T2, typename etl::decay<T2>::type>::value,
                        private_common_type::common_type_2_impl<T1, T2>,
                        common_type<typename etl::decay<T2>::type,
-                       typename etl::decay<T2>::type>>::type
+                                   typename etl::decay<T2>::type>>::type
   {
   };
 
@@ -2408,9 +3146,9 @@ typedef integral_constant<bool, true>  true_type;
       : common_type<typename common_type<T1, T2>::type, TRest...>
     {
     };
-  }
+  } // namespace private_common_type
 
-  template<typename T1, typename T2, typename... TRest>
+  template <typename T1, typename T2, typename... TRest>
   struct common_type<T1, T2, TRest...>
     : private_common_type::common_type_multi_impl<void, T1, T2, TRest...>
   {
@@ -2418,7 +3156,7 @@ typedef integral_constant<bool, true>  true_type;
 
   template <typename... T>
   using common_type_t = typename common_type<T...>::type;
-#endif
+  #endif
 
   //***************************************************************************
   /// Defines one of five unsigned types that has the same size as T.
@@ -2427,16 +3165,16 @@ typedef integral_constant<bool, true>  true_type;
   struct unsigned_type
   {
     typedef typename etl::conditional<sizeof(T) == sizeof(unsigned char), unsigned char,
-      typename etl::conditional<sizeof(T) == sizeof(unsigned short), unsigned short,
-        typename etl::conditional<sizeof(T) == sizeof(unsigned int), unsigned int,
-          typename etl::conditional<sizeof(T) == sizeof(unsigned long), unsigned long,
-            unsigned long long>::type>::type>::type>::type type;
+                                      typename etl::conditional<sizeof(T) == sizeof(unsigned short), unsigned short,
+                                                                typename etl::conditional<sizeof(T) == sizeof(unsigned int), unsigned int,
+                                                                                          typename etl::conditional<sizeof(T) == sizeof(unsigned long), unsigned long,
+                                                                                                                    unsigned long long>::type>::type>::type>::type type;
   };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename T>
   using unsigned_type_t = typename unsigned_type<T>::type;
-#endif
+  #endif
 
   //***************************************************************************
   /// Defines one of five signed types that has the same size as T.
@@ -2445,31 +3183,34 @@ typedef integral_constant<bool, true>  true_type;
   struct signed_type
   {
     typedef typename etl::conditional<sizeof(T) == sizeof(char), char,
-      typename etl::conditional<sizeof(T) == sizeof(short), short,
-        typename etl::conditional<sizeof(T) == sizeof(int), int,
-          typename etl::conditional<sizeof(T) == sizeof(long), long,
-            long long>::type>::type>::type>::type type;
+                                      typename etl::conditional<sizeof(T) == sizeof(short), short,
+                                                                typename etl::conditional<sizeof(T) == sizeof(int), int,
+                                                                                          typename etl::conditional<sizeof(T) == sizeof(long), long,
+                                                                                                                    long long>::type>::type>::type>::type type;
   };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename T>
   using signed_type_t = typename signed_type<T>::type;
-#endif
+  #endif
 
   //*********************************************
   // type_identity
 
   template <typename T>
-  struct type_identity { typedef T type; };
+  struct type_identity
+  {
+    typedef T type;
+  };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename T>
   using type_identity_t = typename type_identity<T>::type;
-#endif
+  #endif
 
   //*********************************************
   // underlying_type
-#if ETL_USING_BUILTIN_UNDERLYING_TYPE
+  #if ETL_USING_BUILTIN_UNDERLYING_TYPE
   // Primary template for etl::underlying_type
   template <typename T, bool = etl::is_enum<T>::value>
   struct underlying_type;
@@ -2487,7 +3228,7 @@ typedef integral_constant<bool, true>  true_type;
   {
     typedef __underlying_type(T) type;
   };
-#else
+  #else
   /// Primary template for etl::underlying_type
   /// Users must specialise this template for their enumerations.
   template <typename T>
@@ -2495,76 +3236,86 @@ typedef integral_constant<bool, true>  true_type;
   {
     typedef int type;
   };
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename T>
   using underlying_type_t = typename underlying_type<T>::type;
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //*********************************************
   // has_duplicates
   template <typename... TTypes>
   struct has_duplicates;
 
   template <typename TFirst, typename... TRest>
-  struct has_duplicates<TFirst, TRest...> : etl::conditional_t<etl::is_one_of<TFirst, TRest...>::value,
-                                                               etl::true_type,
-                                                               has_duplicates<TRest...>> {};
+  struct has_duplicates<TFirst, TRest...> : etl::conditional_t<etl::is_one_of<TFirst, TRest...>::value, etl::true_type, has_duplicates<TRest...>>
+  {
+  };
 
   template <typename T>
-  struct has_duplicates<T> : etl::false_type {};
+  struct has_duplicates<T> : etl::false_type
+  {
+  };
 
   template <>
-  struct has_duplicates<> : etl::false_type {};
-#endif
+  struct has_duplicates<> : etl::false_type
+  {
+  };
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename... TTypes>
   inline constexpr bool has_duplicates_v = etl::has_duplicates<TTypes...>::value;
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //*********************************************
   // count_of
   template <typename T, typename... TTypes>
   struct count_of;
 
   template <typename T, typename U, typename... URest>
-  struct count_of<T, U, URest...> : etl::integral_constant<size_t,
-                                                            etl::is_same<T, U>::value +
-                                                              count_of<T, URest...>::value> {};
+  struct count_of<T, U, URest...> : etl::integral_constant<size_t, etl::is_same<T, U>::value + count_of<T, URest...>::value>
+  {
+  };
 
   template <typename T>
-  struct count_of<T> : etl::integral_constant<size_t, 0> {};
-#endif
+  struct count_of<T> : etl::integral_constant<size_t, 0>
+  {
+  };
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T, typename... TTypes>
   inline constexpr size_t count_of_v = etl::count_of<T, TTypes...>::value;
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //*********************************************
   /// is_specialization
   template <typename T, template <typename...> class Template>
-  struct is_specialization : etl::false_type {};
+  struct is_specialization : etl::false_type
+  {
+  };
 
   template <template <typename...> class Template, typename... TArgs>
-  struct is_specialization<Template<TArgs...>, Template> : etl::true_type {};
-#endif
+  struct is_specialization<Template<TArgs...>, Template> : etl::true_type
+  {
+  };
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T, template <typename...> class Template>
   inline constexpr bool is_specialization_v = etl::is_specialization<T, Template>::value;
-#endif
+  #endif
 
   //*********************************************
   // is_constant_evaluated
   ETL_CONSTEXPR inline bool is_constant_evaluated() ETL_NOEXCEPT
   {
-#if ETL_USING_CPP23
+  #if ETL_USING_CPP23
     if consteval
     {
       return true;
@@ -2573,85 +3324,116 @@ typedef integral_constant<bool, true>  true_type;
     {
       return false;
     }
-#elif ETL_USING_BUILTIN_IS_CONSTANT_EVALUATED == 1
+  #elif ETL_USING_BUILTIN_IS_CONSTANT_EVALUATED == 1
     // Fallback for C++20 on supported compilers
     return __builtin_is_constant_evaluated();
-#else
+  #else
     // default if unsupported
     return false;
-#endif
+  #endif
   }
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //*********************************
   /// Check if T is a function type
   //*********************************
-  template<typename T>
+  template <typename T>
   struct is_function : etl::false_type
   {
   };
 
   // Plain / cv-qualified
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs...)> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs...)> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs...) const> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs...) const> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs...) volatile> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs...) volatile> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs...) const volatile> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs...) const volatile> : etl::true_type
+  {
+  };
 
   // Variadic
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs..., ...)> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs..., ...)> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs..., ...) const> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs..., ...) const> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs..., ...) volatile> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs..., ...) volatile> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs..., ...) const volatile> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs..., ...) const volatile> : etl::true_type
+  {
+  };
 
-  // noexcept variants (if supported)
-#if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs...) noexcept> : etl::true_type {};
+    // noexcept variants (if supported)
+    #if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs...) noexcept> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs...) const noexcept> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs...) const noexcept> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs...) volatile noexcept> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs...) volatile noexcept> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs...) const volatile noexcept> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs...) const volatile noexcept> : etl::true_type
+  {
+  };
 
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs..., ...) noexcept> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs..., ...) noexcept> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs..., ...) const noexcept> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs..., ...) const noexcept> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs..., ...) volatile noexcept> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs..., ...) volatile noexcept> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs..., ...) const volatile noexcept> : etl::true_type
+  {
+  };
+    #endif
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs..., ...) const volatile noexcept> : etl::true_type {};
-#endif
-
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_function_v = etl::is_function<T>::value;
-#endif
-#endif
+    #endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //*********************************
   /// Check for the presence of operator()
   //*********************************
@@ -2667,13 +3449,13 @@ typedef integral_constant<bool, true>  true_type;
     static const bool value = etl::is_same<decltype(test<T>(0)), etl::true_type>::value;
   };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool has_call_operator_v = etl::has_call_operator<T>::value;
-#endif
-#endif
+    #endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //***************************************************************************
   /// Check that there is only one operator()
   //***************************************************************************
@@ -2698,133 +3480,293 @@ typedef integral_constant<bool, true>  true_type;
     static constexpr bool value = decltype(test<etl::decay_t<T>>(0))::value;
   };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool has_unique_call_operator_v = etl::has_unique_call_operator<T>::value;
-#endif
-#endif
+    #endif
+  #endif
 
   //***************************************************************************
   /// Is T a member pointer
   //***************************************************************************
   namespace private_type_traits
   {
-    template<typename T>
-    struct is_member_pointer_helper : etl::false_type {};
+    template <typename T>
+    struct is_member_pointer_helper : etl::false_type
+    {
+    };
 
-    template<typename T, typename TObject>
-    struct is_member_pointer_helper<T TObject::*> : etl::true_type {};
-  }
+    template <typename T, typename TObject>
+    struct is_member_pointer_helper<T TObject::*> : etl::true_type
+    {
+    };
+  } // namespace private_type_traits
 
-  template<typename T> 
-  struct is_member_pointer : private_type_traits::is_member_pointer_helper<typename etl::remove_cv<T>::type> {};
+  template <typename T>
+  struct is_member_pointer : private_type_traits::is_member_pointer_helper<typename etl::remove_cv<T>::type>
+  {
+  };
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_member_pointer_v = etl::is_member_pointer<T>::value;
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //***************************************************************************
   /// Is T a member function pointer
   //***************************************************************************
-  template <typename T> struct is_member_function_pointer : etl::false_type {};
+  template <typename T>
+  struct is_member_function_pointer : etl::false_type
+  {
+  };
 
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...)> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) volatile> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const volatile> : etl::true_type {};
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...)> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) volatile> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const volatile> : etl::true_type
+  {
+  };
 
-#if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) noexcept> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const noexcept> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) volatile noexcept> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const volatile noexcept> : etl::true_type {};
-#endif
+    #if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) volatile noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const volatile noexcept> : etl::true_type
+  {
+  };
+    #endif
 
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) &>                : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const &>          : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) volatile &>       : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const volatile &> : etl::true_type {};
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...)&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) volatile&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const volatile&> : etl::true_type
+  {
+  };
 
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) &&>               : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const &&>         : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) volatile &&>      : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const volatile &&>: etl::true_type {};
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) &&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const&&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) volatile&&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const volatile&&> : etl::true_type
+  {
+  };
 
-#if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) & noexcept>                : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const & noexcept>          : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) volatile & noexcept>       : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const volatile & noexcept> : etl::true_type {};
+    #if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) & noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const & noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) volatile & noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const volatile & noexcept> : etl::true_type
+  {
+  };
 
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) && noexcept>               : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const && noexcept>         : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) volatile && noexcept>      : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const volatile && noexcept>: etl::true_type {};
-#endif
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) && noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const && noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) volatile && noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const volatile && noexcept> : etl::true_type
+  {
+  };
+    #endif
 
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...)> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) volatile> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const volatile> : etl::true_type {};
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...)> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) volatile> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const volatile> : etl::true_type
+  {
+  };
 
-#if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) noexcept> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const noexcept> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) volatile noexcept> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const volatile noexcept> : etl::true_type {};
-#endif
+    #if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) volatile noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const volatile noexcept> : etl::true_type
+  {
+  };
+    #endif
 
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) &>                : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const &>          : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) volatile &>       : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const volatile &> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) &&>               : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const &&>         : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) volatile &&>      : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const volatile &&>: etl::true_type {};
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...)&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) volatile&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const volatile&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) &&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const&&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) volatile&&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const volatile&&> : etl::true_type
+  {
+  };
 
-#if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) & noexcept>                : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const & noexcept>          : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) volatile & noexcept>       : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const volatile & noexcept> : etl::true_type {};
+    #if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) & noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const & noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) volatile & noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const volatile & noexcept> : etl::true_type
+  {
+  };
 
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) && noexcept>               : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const && noexcept>         : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) volatile && noexcept>      : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const volatile && noexcept>: etl::true_type {};
-#endif
-#endif
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) && noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const && noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) volatile && noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const volatile && noexcept> : etl::true_type
+  {
+  };
+    #endif
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_member_function_pointer_v = etl::is_member_function_pointer<T>::value;
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //***************************************************************************
   /// Is T a member object pointer
   //***************************************************************************
   namespace private_type_traits
   {
-    template<typename> 
-    struct is_member_object_pointer_helper : public etl::false_type {};
+    template <typename>
+    struct is_member_object_pointer_helper : public etl::false_type
+    {
+    };
 
-    template<typename T, typename TObject> 
-    struct is_member_object_pointer_helper<T TObject::*> : public etl::negation<etl::is_function<T>> {};
-  }
+    template <typename T, typename TObject>
+    struct is_member_object_pointer_helper<T TObject::*> : public etl::negation<etl::is_function<T>>
+    {
+    };
+  } // namespace private_type_traits
 
-  template<typename T> struct is_member_object_pointer : public private_type_traits::is_member_object_pointer_helper<etl::remove_cv_t<T>>::type {};
-#endif
+  template <typename T>
+  struct is_member_object_pointer : public private_type_traits::is_member_object_pointer_helper<etl::remove_cv_t<T>>::type
+  {
+  };
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_member_object_pointer_v = etl::is_member_object_pointer<T>::value;
-#endif
+  #endif
 
-#if ETL_USING_CPP20
+  #if ETL_USING_CPP20
   template <class... TArgs>
   struct common_reference;
 
@@ -2926,8 +3868,7 @@ typedef integral_constant<bool, true>  true_type;
     using cv_cond_res = cond_res<copy_cv_t<T1, T2>&, copy_cv_t<T2, T1>&>;
 
     template <class T1, class T2, class T1_RR, class T2_RR>
-      requires requires { typename cv_cond_res<T1_RR, T2_RR>; } &&
-        is_reference_v<cv_cond_res<T1_RR, T2_RR>>
+      requires requires { typename cv_cond_res<T1_RR, T2_RR>; } && is_reference_v<cv_cond_res<T1_RR, T2_RR>>
     struct common_ref<T1&, T2&, T1_RR, T2_RR>
     {
       using type = cv_cond_res<T1_RR, T2_RR>;
@@ -2937,9 +3878,7 @@ typedef integral_constant<bool, true>  true_type;
     using common_ref_rr = remove_reference_t<common_ref_t<T1&, T2&>>&&;
 
     template <class T1, class T2, class T1_R, class T2_R>
-      requires requires { typename common_ref_rr<T1_R, T2_R>; } &&
-        is_convertible_v<T1&&, common_ref_rr<T1_R, T2_R>> &&
-        is_convertible_v<T2&&, common_ref_rr<T1_R, T2_R>>
+      requires requires { typename common_ref_rr<T1_R, T2_R>; } && is_convertible_v<T1&&, common_ref_rr<T1_R, T2_R>> && is_convertible_v<T2&&, common_ref_rr<T1_R, T2_R>>
     struct common_ref<T1&&, T2&&, T1_R, T2_R>
     {
       using type = common_ref_rr<T1_R, T2_R>;
@@ -2949,15 +3888,14 @@ typedef integral_constant<bool, true>  true_type;
     using common_ref_cr = common_ref_t<const T1&, T2&>;
 
     template <class T1, class T2, class T3, class T4>
-      requires requires { typename common_ref_cr<T3, T4>; } &&
-        is_convertible_v<T1&&, common_ref_cr<T3, T4>>
+      requires requires { typename common_ref_cr<T3, T4>; } && is_convertible_v<T1&&, common_ref_cr<T3, T4>>
     struct common_ref<T1&&, T2&, T3, T4>
     {
       using type = common_ref_cr<T3, T4>;
     };
 
     template <class T1, class T2, class T3, class T4>
-    struct common_ref<T1&, T2&&, T3, T4>: common_ref<T2&&, T1&>
+    struct common_ref<T1&, T2&&, T3, T4> : common_ref<T2&&, T1&>
     {
     };
 
@@ -2970,28 +3908,26 @@ typedef integral_constant<bool, true>  true_type;
     struct common_reference_impl3;
 
     template <class T1, class T2>
-    struct common_reference_impl2: common_reference_impl3<T1, T2>
+    struct common_reference_impl2 : common_reference_impl3<T1, T2>
     {
     };
 
     template <class T1, class T2>
-    struct common_reference_impl1: common_reference_impl2<T1, T2>
+    struct common_reference_impl1 : common_reference_impl2<T1, T2>
     {
     };
-  }
+  } // namespace private_type_traits
 
   // If sizeof...(T) is 2
   template <class T1, class T2>
-  struct common_reference<T1, T2>: private_type_traits::common_reference_impl1<T1, T2>
+  struct common_reference<T1, T2> : private_type_traits::common_reference_impl1<T1, T2>
   {
   };
 
   namespace private_type_traits
   {
     template <class T1, class T2>
-      requires is_reference_v<T1> && is_reference_v<T2> && requires { typename common_ref_t<T1, T2>; } &&
-               is_convertible_v<add_pointer_t<T1>, add_pointer_t<common_ref_t<T1, T2>>> &&
-               is_convertible_v<add_pointer_t<T2>, add_pointer_t<common_ref_t<T1, T2>>>
+      requires is_reference_v<T1> && is_reference_v<T2> && requires { typename common_ref_t<T1, T2>; } && is_convertible_v<add_pointer_t<T1>, add_pointer_t<common_ref_t<T1, T2>>> && is_convertible_v<add_pointer_t<T2>, add_pointer_t<common_ref_t<T1, T2>>>
     struct common_reference_impl1<T1, T2>
     {
       using type = common_ref_t<T1, T2>;
@@ -3019,31 +3955,33 @@ typedef integral_constant<bool, true>  true_type;
     };
 
     template <class T1, class T2>
-    struct common_reference_impl3: common_type<T1, T2>
+    struct common_reference_impl3 : common_type<T1, T2>
     {
     };
-  }
+  } // namespace private_type_traits
 
   template <class T1, class T2, class T3, class... TArgs>
     requires requires { typename common_reference_t<T1, T2>; }
-  struct common_reference<T1, T2, T3, TArgs...> : common_reference<common_reference_t<T1, T2>, T3, TArgs...> {};
+  struct common_reference<T1, T2, T3, TArgs...> : common_reference<common_reference_t<T1, T2>, T3, TArgs...>
+  {
+  };
 
-  template<class... TArgs>
+  template <class... TArgs>
   struct common_reference
   {
   };
 
-#endif
-}
+  #endif
+} // namespace etl
 
-// Helper macros
-#define ETL_IS_CHAR_TYPE(type)        (etl::is_same<char, type>::value || etl::is_same<signed char, type>::value || etl::is_same<unsigned char, type>::value)
-#define ETL_IS_NOT_CHAR_TYPE(type)    (!ETL_IS_CHAR_TYPE(type))
+  // Helper macros
+  #define ETL_IS_CHAR_TYPE(type)     (etl::is_same<char, type>::value || etl::is_same<signed char, type>::value || etl::is_same<unsigned char, type>::value)
+  #define ETL_IS_NOT_CHAR_TYPE(type) (!ETL_IS_CHAR_TYPE(type))
 
-#define ETL_IS_POINTER_TYPE(type)     (etl::is_pointer<type>::value)
-#define ETL_IS_NOT_POINTER_TYPE(type) (!ETL_IS_POINTER_TYPE(type))
+  #define ETL_IS_POINTER_TYPE(type)     (etl::is_pointer<type>::value)
+  #define ETL_IS_NOT_POINTER_TYPE(type) (!ETL_IS_POINTER_TYPE(type))
 
-#define ETL_TARGET_IS_TRIVIALLY_COPYABLE(type)     (etl::is_trivially_copyable<typename etl::iterator_traits<type>::value_type>::value)
-#define ETL_TARGET_IS_NOT_TRIVIALLY_COPYABLE(type) (!ETL_TARGET_IS_TRIVIALLY_COPYABLE(type))
+  #define ETL_TARGET_IS_TRIVIALLY_COPYABLE(type)     (etl::is_trivially_copyable<typename etl::iterator_traits<type>::value_type>::value)
+  #define ETL_TARGET_IS_NOT_TRIVIALLY_COPYABLE(type) (!ETL_TARGET_IS_TRIVIALLY_COPYABLE(type))
 
 #endif // ETL_TYPE_TRAITS_INCLUDED
diff --git a/include/etl/generators/variant_pool_generator.h b/include/etl/generators/variant_pool_generator.h
index 25718949..f3c688ca 100644
--- a/include/etl/generators/variant_pool_generator.h
+++ b/include/etl/generators/variant_pool_generator.h
@@ -31,7 +31,7 @@ import cog
 cog.outl("#if 0")
 ]]]*/
 /*[[[end]]]*/
-#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+  #error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
 /*[[[cog
 import cog
 cog.outl("#endif")
@@ -61,21 +61,21 @@ cog.outl("//********************************************************************
 //***************************************************************************
 
 #ifndef ETL_VARIANT_POOL_INCLUDED
-#define ETL_VARIANT_POOL_INCLUDED
+  #define ETL_VARIANT_POOL_INCLUDED
 
-#include "platform.h"
-#include "pool.h"
-#include "type_traits.h"
-#include "static_assert.h"
-#include "largest.h"
+  #include "platform.h"
+  #include "largest.h"
+  #include "pool.h"
+  #include "static_assert.h"
+  #include "type_traits.h"
 
-#include <stdint.h>
+  #include <stdint.h>
 
 namespace etl
 {
-#if ETL_USING_CPP11 && !defined(ETL_VARIANT_POOL_FORCE_CPP03_IMPLEMENTATION)
+  #if ETL_USING_CPP11 && !defined(ETL_VARIANT_POOL_FORCE_CPP03_IMPLEMENTATION)
   //***************************************************************************
-  template <size_t MAX_SIZE_, typename ... Ts>
+  template <size_t MAX_SIZE_, typename... Ts>
   class variant_pool
     : public etl::generic_pool<etl::largest<Ts...>::size,
                                etl::largest<Ts...>::alignment,
@@ -85,7 +85,8 @@ namespace etl
 
     typedef etl::generic_pool<etl::largest<Ts...>::size,
                               etl::largest<Ts...>::alignment,
-                              MAX_SIZE_> base_t;
+                              MAX_SIZE_>
+      base_t;
 
     static const size_t MAX_SIZE = MAX_SIZE_;
 
@@ -129,11 +130,11 @@ namespace etl
   private:
 
     variant_pool(const variant_pool&) ETL_DELETE;
-    variant_pool& operator =(const variant_pool&) ETL_DELETE;
+    variant_pool& operator=(const variant_pool&) ETL_DELETE;
   };
 
   //***************************************************************************
-  template <typename ... Ts>
+  template <typename... Ts>
   class variant_pool_ext
     : public etl::generic_pool_ext<etl::largest<Ts...>::size,
                                    etl::largest<Ts...>::alignment>
@@ -141,7 +142,8 @@ namespace etl
   public:
 
     typedef etl::generic_pool_ext<etl::largest<Ts...>::size,
-                                  etl::largest<Ts...>::alignment> base_t;
+                                  etl::largest<Ts...>::alignment>
+      base_t;
 
     //*************************************************************************
     /// Default constructor.
@@ -184,16 +186,18 @@ namespace etl
   private:
 
     variant_pool_ext(const variant_pool_ext&) ETL_DELETE;
-    variant_pool_ext& operator =(const variant_pool_ext&) ETL_DELETE;
+    variant_pool_ext& operator=(const variant_pool_ext&) ETL_DELETE;
   };
-#else
+  #else
   //***************************************************************************
   /*[[[cog
   import cog
+  max_w = len(str(int(NTypes)))
   cog.outl("template <size_t MAX_SIZE_,")
   cog.outl("          typename T1,")
   for n in range(2, int(NTypes)):
-      cog.outl("          typename T%s = void," % n)
+      pad = " " * (max_w - len(str(n)))
+      cog.outl("          typename T%s%s = void," % (n, pad))
   cog.outl("          typename T%s = void>" % int(NTypes))
   cog.outl("class variant_pool")
   cog.out("  : public etl::generic_pool<")
@@ -222,7 +226,8 @@ namespace etl
     for n in range(1, int(NTypes)):
         cog.out("T%s, " % n)
     cog.outl("T%s>::alignment," % int(NTypes))
-    cog.outl("                          MAX_SIZE_> base_t;")
+    cog.outl("                          MAX_SIZE_>")
+    cog.outl("  base_t;")
     ]]]*/
     /*[[[end]]]*/
 
@@ -235,7 +240,7 @@ namespace etl
     {
     }
 
-#if ETL_CPP11_NOT_SUPPORTED || ETL_USING_STLPORT
+    #if ETL_CPP11_NOT_SUPPORTED || ETL_USING_STLPORT
     //*************************************************************************
     /// Creates the object. Default constructor.
     //*************************************************************************
@@ -340,7 +345,7 @@ namespace etl
 
       return base_t::template create<T>(p1, p2, p3, p4);
     }
-#else
+    #else
     //*************************************************************************
     /// Creates the object from a type. Variadic parameter constructor.
     //*************************************************************************
@@ -361,7 +366,7 @@ namespace etl
 
       return base_t::template create<T>(etl::forward<Args>(args)...);
     }
-#endif
+    #endif
 
     //*************************************************************************
     /// Destroys the object.
@@ -374,15 +379,17 @@ namespace etl
       cog.out("ETL_STATIC_ASSERT((etl::is_one_of<T, ")
       for n in range(1, int(NTypes)):
           cog.out("T%s, " % n)
-          if n % 16 == 0:
+      cog.outl("T%s>::value" % int(NTypes))
+      for n in range(1, int(NTypes) + 1):
+          if (n - 1) % 4 == 0:
+              cog.out("                   || etl::is_base_of<T, T%s>::value" % n)
+          else:
+              cog.out(" || etl::is_base_of<T, T%s>::value" % n)
+          if n == int(NTypes):
+              cog.outl("),")
+          elif n % 4 == 0:
               cog.outl("")
-              cog.out("                              ")
-      cog.outl("T%s>::value ||" % int(NTypes))
-
-      for n in range(1, int(NTypes)):
-          cog.outl("                   etl::is_base_of<T, T%s>::value ||" % n)
-      cog.outl("                   etl::is_base_of<T, T%s>::value), \"Invalid type\");" % int(NTypes))
-
+      cog.outl('                  "Invalid type");')
       ]]]*/
       /*[[[end]]]*/
 
@@ -400,7 +407,7 @@ namespace etl
   private:
 
     variant_pool(const variant_pool&) ETL_DELETE;
-    variant_pool& operator =(const variant_pool&) ETL_DELETE;
+    variant_pool& operator=(const variant_pool&) ETL_DELETE;
   };
 
   //***************************************************************************
@@ -408,7 +415,8 @@ namespace etl
   import cog
   cog.outl("template <typename T1,")
   for n in range(2, int(NTypes)):
-      cog.outl("          typename T%s = void," % n)
+      pad = " " * (max_w - len(str(n)))
+      cog.outl("          typename T%s%s = void," % (n, pad))
   cog.outl("          typename T%s = void>" % int(NTypes))
   cog.outl("class variant_pool_ext")
   cog.out("  : public etl::generic_pool_ext<")
@@ -435,7 +443,8 @@ namespace etl
     cog.out("                              etl::largest<")
     for n in range(1, int(NTypes)):
         cog.out("T%s, " % n)
-    cog.outl("T%s>::alignment> base_t;" % int(NTypes))
+    cog.outl("T%s>::alignment>" % int(NTypes))
+    cog.outl("  base_t;")
     ]]]*/
     /*[[[end]]]*/
 
@@ -443,11 +452,11 @@ namespace etl
     /// Default constructor.
     //*************************************************************************
     variant_pool_ext(typename base_t::element* buffer, size_t size)
-      : base_t(buffer, size) 
+      : base_t(buffer, size)
     {
     }
 
-#if ETL_CPP11_NOT_SUPPORTED || ETL_USING_STLPORT
+    #if ETL_CPP11_NOT_SUPPORTED || ETL_USING_STLPORT
     //*************************************************************************
     /// Creates the object. Default constructor.
     //*************************************************************************
@@ -552,7 +561,7 @@ namespace etl
 
       return base_t::template create<T>(p1, p2, p3, p4);
     }
-#else
+    #else
     //*************************************************************************
     /// Creates the object from a type. Variadic parameter constructor.
     //*************************************************************************
@@ -573,7 +582,7 @@ namespace etl
 
       return base_t::template create<T>(etl::forward<Args>(args)...);
     }
-#endif
+    #endif
 
     //*************************************************************************
     /// Destroys the object.
@@ -586,15 +595,17 @@ namespace etl
       cog.out("ETL_STATIC_ASSERT((etl::is_one_of<T, ")
       for n in range(1, int(NTypes)):
           cog.out("T%s, " % n)
-          if n % 16 == 0:
+      cog.outl("T%s>::value" % int(NTypes))
+      for n in range(1, int(NTypes) + 1):
+          if (n - 1) % 4 == 0:
+              cog.out("                   || etl::is_base_of<T, T%s>::value" % n)
+          else:
+              cog.out(" || etl::is_base_of<T, T%s>::value" % n)
+          if n == int(NTypes):
+              cog.outl("),")
+          elif n % 4 == 0:
               cog.outl("")
-              cog.out("                              ")
-      cog.outl("T%s>::value ||" % int(NTypes))
-
-      for n in range(1, int(NTypes)):
-          cog.outl("                   etl::is_base_of<T, T%s>::value ||" % n)
-      cog.outl("                   etl::is_base_of<T, T%s>::value), \"Invalid type\");" % int(NTypes))
-
+      cog.outl('                  "Invalid type");')
       ]]]*/
       /*[[[end]]]*/
 
@@ -604,17 +615,17 @@ namespace etl
     //*************************************************************************
     /// Returns the maximum number of items in the variant_pool.
     //*************************************************************************
-    size_t max_size() const 
-    { 
-      return base_t::max_size(); 
+    size_t max_size() const
+    {
+      return base_t::max_size();
     }
 
   private:
 
     variant_pool_ext(const variant_pool_ext&) ETL_DELETE;
-    variant_pool_ext& operator =(const variant_pool_ext&) ETL_DELETE;
+    variant_pool_ext& operator=(const variant_pool_ext&) ETL_DELETE;
   };
-#endif
-}
+  #endif
+} // namespace etl
 
 #endif
diff --git a/include/etl/largest.h b/include/etl/largest.h
index a3a96487..e9f1d1e9 100644
--- a/include/etl/largest.h
+++ b/include/etl/largest.h
@@ -29,7 +29,7 @@ SOFTWARE.
 ******************************************************************************/
 
 #if 0
-#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+  #error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
 #endif
 
 //***************************************************************************
@@ -51,19 +51,19 @@ SOFTWARE.
 //***************************************************************************
 
 #ifndef ETL_LARGEST_INCLUDED
-#define ETL_LARGEST_INCLUDED
+  #define ETL_LARGEST_INCLUDED
 
 ///\defgroup largest largest
 ///\ingroup utilities
 
-#include "platform.h"
-#include "type_traits.h"
-#include "smallest.h"
-#include "static_assert.h"
+  #include "platform.h"
+  #include "smallest.h"
+  #include "static_assert.h"
+  #include "type_traits.h"
 
 namespace etl
 {
-#if ETL_USING_CPP11 && !defined(ETL_LARGEST_TYPE_FORCE_CPP03_IMPLEMENTATION)
+  #if ETL_USING_CPP11 && !defined(ETL_LARGEST_TYPE_FORCE_CPP03_IMPLEMENTATION)
   //***************************************************************************
   /// Template to determine the largest type and size.
   /// Defines 'value_type' which is the type of the largest parameter.
@@ -82,10 +82,10 @@ namespace etl
 
     // Set 'type' to be the largest of the first parameter and any of the others.
     // This is recursive.
-    using type = typename etl::conditional<(etl::size_of<T1>::value > etl::size_of<largest_other>::value),  // Boolean
-                                            T1,                                                             // TrueType
-                                            largest_other>                                                  // FalseType
-                                            ::type;                                                         // The largest type of the two.
+    using type = typename etl::conditional<(etl::size_of<T1>::value > etl::size_of<largest_other>::value), // Boolean
+                                           T1,                                                             // TrueType
+                                           largest_other>                                                  // FalseType
+      ::type;                                                                                              // The largest type of the two.
 
     // The size of the largest type.
     enum
@@ -110,17 +110,17 @@ namespace etl
     };
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename... T>
   using largest_type_t = typename largest_type<T...>::type;
-#endif
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename... T>
   constexpr size_t largest_type_v = largest_type<T...>::size;
-#endif
+    #endif
 
-#else
+  #else
   //***************************************************************************
   /// Template to determine the largest type and size.
   /// Supports up to 16 types.
@@ -128,21 +128,21 @@ namespace etl
   /// Defines 'size' which is the size of the largest parameter.
   ///\ingroup largest
   //***************************************************************************
-  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, 
+  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>
   struct largest_type
   {
-    // Define 'largest_other' as 'largest_type' with all but the first parameter. 
+    // Define 'largest_other' as 'largest_type' with all but the first parameter.
     typedef typename largest_type<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::type largest_other;
 
     // Set 'type' to be the largest of the first parameter and any of the others.
     // This is recursive.
     typedef typename etl::conditional<(sizeof(T1) > sizeof(largest_other)), // Boolean
-                                       T1,                                  // TrueType
-                                       largest_other>                       // FalseType
-                                       ::type type;                         // The largest type of the two.
+                                      T1,                                   // TrueType
+                                      largest_other>                        // FalseType
+      ::type type;                                                          // The largest type of the two.
 
     // The size of the largest type.
     enum
@@ -155,7 +155,7 @@ namespace etl
   // Specialisation for one template parameter.
   //***************************************************************************
   template <typename T1>
-  struct largest_type<T1,   void, void, void, void, void, void, void, 
+  struct largest_type<T1, void, void, void, void, void, void, void,
                       void, void, void, void, void, void, void, void>
   {
     typedef T1 type;
@@ -165,9 +165,9 @@ namespace etl
       size = sizeof(type)
     };
   };
-#endif
+  #endif
 
-#if ETL_USING_CPP11 && !defined(ETL_LARGEST_ALIGNMENT_FORCE_CPP03_IMPLEMENTATION)
+  #if ETL_USING_CPP11 && !defined(ETL_LARGEST_ALIGNMENT_FORCE_CPP03_IMPLEMENTATION)
   //***************************************************************************
   /// Template to determine the largest alignment.
   /// Defines <b>value</b> which is the largest alignment of all the parameters.
@@ -182,9 +182,9 @@ namespace etl
     // Set 'type' to be the largest of the first parameter and any of the others.
     // This is recursive.
     using type = typename etl::conditional<(etl::alignment_of<T1>::value > etl::alignment_of<largest_other>::value), // Boolean
-                                            T1,                                                                      // TrueType
-                                            largest_other>                                                           // FalseType
-                                            ::type;                                                                  // The largest type of the two.
+                                           T1,                                                                       // TrueType
+                                           largest_other>                                                            // FalseType
+      ::type;                                                                                                        // The largest type of the two.
 
     // The largest alignment.
     enum
@@ -207,33 +207,33 @@ namespace etl
     };
   };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename... T>
   inline constexpr size_t largest_alignment_v = largest_alignment<T...>::value;
-#endif
+    #endif
 
-#else
+  #else
   //***************************************************************************
   /// Template to determine the largest alignment.
   /// Supports up to 16 types.
   /// Defines <b>value</b> which is the largest alignment of all the parameters.
   ///\ingroup largest
   //***************************************************************************
-  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, 
+  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>
   struct largest_alignment
   {
-    // Define 'largest_other' as 'largest_type' with all but the first parameter. 
+    // Define 'largest_other' as 'largest_type' with all but the first parameter.
     typedef typename largest_alignment<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::type largest_other;
 
     // Set 'type' to be the largest of the first parameter and any of the others.
     // This is recursive.
     typedef typename etl::conditional<(etl::alignment_of<T1>::value > etl::alignment_of<largest_other>::value), // Boolean
-                                       T1,                                                                      // TrueType
-                                       largest_other>                                                           // FalseType
-                                       ::type type;                                                             // The largest type of the two.
+                                      T1,                                                                       // TrueType
+                                      largest_other>                                                            // FalseType
+      ::type type;                                                                                              // The largest type of the two.
 
     // The largest alignment.
     enum
@@ -246,7 +246,7 @@ namespace etl
   // Specialisation for one template parameter.
   //***************************************************************************
   template <typename T1>
-  struct largest_alignment<T1,   void, void, void, void, void, void, void, 
+  struct largest_alignment<T1, void, void, void, void, void, void, void,
                            void, void, void, void, void, void, void, void>
   {
     typedef T1 type;
@@ -256,7 +256,7 @@ namespace etl
       value = etl::alignment_of<type>::value
     };
   };
-#endif
+  #endif
 
   //***************************************************************************
   /// Defines a type that is as larger or larger than the specified type.
@@ -271,10 +271,10 @@ namespace etl
     typedef typename etl::smallest_int_for_bits<etl::integral_limits<typename etl::make_signed<T>::type>::bits + 1>::type type;
   };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename T>
   using larger_int_type_t = typename larger_int_type<T>::type;
-#endif
+  #endif
 
   //***************************************************************************
   /// Defines a type that is as larger or larger than the specified type.
@@ -289,10 +289,10 @@ namespace etl
     typedef typename etl::smallest_uint_for_bits<etl::integral_limits<typename etl::make_unsigned<T>::type>::bits + 1>::type type;
   };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename T>
   using larger_uint_type_t = typename larger_uint_type<T>::type;
-#endif
+  #endif
 
   //***************************************************************************
   /// Defines a type that is as larger or larger than the specified type.
@@ -319,12 +319,12 @@ namespace etl
     typedef typename etl::smallest_int_for_bits<etl::integral_limits<T>::bits + 1>::type type;
   };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename T>
   using larger_type_t = typename larger_type<T>::type;
-#endif
+  #endif
 
-#if ETL_USING_CPP11 && !defined(ETL_LARGEST_FORCE_CPP03_IMPLEMENTATION)
+  #if ETL_USING_CPP11 && !defined(ETL_LARGEST_FORCE_CPP03_IMPLEMENTATION)
   //***************************************************************************
   /// Template to determine the largest type, size and alignment.
   /// Defines <b>value</b> which is the largest type, size and alignment of all the parameters.
@@ -342,26 +342,26 @@ namespace etl
     };
   };
 
-#if ETL_USING_CPP11
-    template <typename... T>
-    using largest_t = typename largest<T...>::type;
-#endif
+    #if ETL_USING_CPP11
+  template <typename... T>
+  using largest_t = typename largest<T...>::type;
+    #endif
 
-#if ETL_USING_CPP17
-    template <typename... T>
-    inline constexpr size_t largest_size = largest<T...>::size;
-#endif
+    #if ETL_USING_CPP17
+  template <typename... T>
+  inline constexpr size_t largest_size = largest<T...>::size;
+    #endif
 
-#else
+  #else
   //***************************************************************************
   /// Template to determine the largest type, size and alignment.
   /// Supports up to 16 types.
   /// Defines <b>value</b> which is the largest type, size and alignment of all the parameters.
   ///\ingroup largest
   //***************************************************************************
-  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, 
+  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>
   struct largest
   {
@@ -373,7 +373,7 @@ namespace etl
       alignment = etl::largest_alignment<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value
     };
   };
-#endif
-}
+  #endif
+} // namespace etl
 
 #endif
diff --git a/include/etl/message_packet.h b/include/etl/message_packet.h
index 24f1e157..23685363 100644
--- a/include/etl/message_packet.h
+++ b/include/etl/message_packet.h
@@ -27,7 +27,7 @@ SOFTWARE.
 ******************************************************************************/
 
 #if 0
-#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+  #error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
 #endif
 
 //***************************************************************************
@@ -49,30 +49,29 @@ SOFTWARE.
 //***************************************************************************
 
 #ifndef ETL_MESSAGE_PACKET_INCLUDED
-#define ETL_MESSAGE_PACKET_INCLUDED
+  #define ETL_MESSAGE_PACKET_INCLUDED
 
-#include "platform.h"
+  #include "platform.h"
 
-#include "message.h"
-#include "error_handler.h"
-#include "static_assert.h"
-#include "largest.h"
-#include "alignment.h"
-#include "utility.h"
-#include "type_list.h"
+  #include "alignment.h"
+  #include "error_handler.h"
+  #include "largest.h"
+  #include "message.h"
+  #include "static_assert.h"
+  #include "type_list.h"
+  #include "utility.h"
 
-#include <stdint.h>
+  #include <stdint.h>
 
 namespace etl
 {
-#if ETL_USING_CPP17 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+  #if ETL_USING_CPP17 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
   //***************************************************************************
   // The definition for all message types.
   //***************************************************************************
   template <typename... TMessageTypes>
   class message_packet
   {
-
   private:
 
     template <typename T>
@@ -88,18 +87,18 @@ namespace etl
 
     using message_types = etl::type_list<TMessageTypes...>;
 
-    //********************************************
-#include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     constexpr message_packet() noexcept
       : valid(false)
     {
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //********************************************
-    ///
-    //********************************************
-#include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+      ///
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     template <typename T, typename = typename etl::enable_if<IsIMessage<T> || IsInMessageList<T>, int>::type>
     explicit message_packet(T&& msg)
       : valid(true)
@@ -127,7 +126,7 @@ namespace etl
         ETL_STATIC_ASSERT(IsInMessageList<T>, "Message not in packet type list");
       }
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
     //**********************************************
     message_packet(const message_packet& other)
@@ -140,7 +139,7 @@ namespace etl
       }
     }
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     //**********************************************
     message_packet(message_packet&& other)
     {
@@ -151,7 +150,7 @@ namespace etl
         add_new_message(etl::move(other.get()));
       }
     }
-#endif
+    #endif
 
     //**********************************************
     void copy(const message_packet& other)
@@ -175,9 +174,9 @@ namespace etl
       }
     }
 
-    //**********************************************
-#include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -188,11 +187,11 @@ namespace etl
 
       return *this;
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //**********************************************
-#include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -203,7 +202,7 @@ namespace etl
 
       return *this;
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
     //********************************************
     ~message_packet()
@@ -251,7 +250,7 @@ namespace etl
     //**********************************************
     template <typename TMessage>
     static ETL_CONSTEXPR
-    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
+      typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
       accepts()
     {
       return accepts<TMessage::ID>();
@@ -259,7 +258,7 @@ namespace etl
 
     enum
     {
-      SIZE = etl::largest<TMessageTypes...>::size,
+      SIZE      = etl::largest<TMessageTypes...>::size,
       ALIGNMENT = etl::largest<TMessageTypes...>::alignment
     };
 
@@ -279,24 +278,24 @@ namespace etl
       return Id1 == id2;
     }
 
-    //********************************************
-#include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     void delete_current_message()
     {
       if (valid)
       {
         etl::imessage* pmsg = static_cast<etl::imessage*>(data);
 
-#if ETL_HAS_VIRTUAL_MESSAGES
+    #if ETL_HAS_VIRTUAL_MESSAGES
         pmsg->~imessage();
-#else
+    #else
         delete_message(pmsg);
-#endif
+    #endif
       }
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-#if !ETL_HAS_VIRTUAL_MESSAGES
+    #if !ETL_HAS_VIRTUAL_MESSAGES
     //********************************************
     void delete_message(etl::imessage* pmsg)
     {
@@ -318,7 +317,7 @@ namespace etl
         return false;
       }
     }
-#endif
+    #endif
 
     //********************************************
     void add_new_message(const etl::imessage& msg)
@@ -332,7 +331,7 @@ namespace etl
       (add_new_message_type<TMessageTypes>(etl::move(msg)) || ...);
     }
 
-#include "private/diagnostic_uninitialized_push.h"
+    #include "private/diagnostic_uninitialized_push.h"
     //********************************************
     /// Only enabled for types that are in the typelist.
     //********************************************
@@ -343,9 +342,9 @@ namespace etl
       void* p = data;
       new (p) etl::remove_reference_t<TMessage>((etl::forward<TMessage>(msg)));
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-#include "private/diagnostic_uninitialized_push.h"
+    #include "private/diagnostic_uninitialized_push.h"
     //********************************************
     template <typename TType>
     bool add_new_message_type(const etl::imessage& msg)
@@ -361,7 +360,7 @@ namespace etl
         return false;
       }
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
     //********************************************
     template <typename TType>
@@ -380,7 +379,7 @@ namespace etl
     }
 
     typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    bool valid;
+    bool                                                 valid;
   };
 
   //***************************************************************************
@@ -404,24 +403,24 @@ namespace etl
 
     using message_types = etl::type_list<>;
 
-    //********************************************
-#include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     constexpr message_packet() noexcept
     {
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
     //**********************************************
     message_packet(const message_packet& /*other*/)
     {
     }
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     //**********************************************
     message_packet(message_packet&& /*other*/)
     {
     }
-#endif
+    #endif
 
     //**********************************************
     void copy(const message_packet& /*other*/)
@@ -433,21 +432,21 @@ namespace etl
     {
     }
 
-    //**********************************************
-#include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& /*rhs*/)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& /*rhs*/)
     {
       return *this;
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //**********************************************
-#include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& /*rhs*/)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& /*rhs*/)
     {
       return *this;
     }
-#include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
     //********************************************
     ~message_packet()
@@ -490,7 +489,7 @@ namespace etl
 
     enum
     {
-      SIZE = 0,
+      SIZE      = 0,
       ALIGNMENT = 1
     };
   };
@@ -509,33 +508,33 @@ namespace etl
   template <typename TTypeList>
   using message_packet_from_type_list_t = typename message_packet_from_type_list<TTypeList>::type;
 
-#else
+  #else
 
   //***************************************************************************
   // The definition for all 16 message types.
   //***************************************************************************
-  template <typename T1 = void, 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, 
+  template <typename T1 = void, 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:
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>;
-  #endif
+    #endif
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     ETL_CONSTEXPR message_packet() ETL_NOEXCEPT
       : valid(false)
     {
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(const etl::imessage& msg)
     {
       if (accepts(msg))
@@ -550,11 +549,11 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(etl::imessage&& msg)
     {
       if (accepts(msg))
@@ -569,47 +568,49 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> >::value &&
-                                                                    !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                    !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value, int>::type>
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> >::value
+                                                                      && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                      && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value,
+                                                                    int>::type>
     explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> >::value &&
-                                       !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                       etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value);
+      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> >::value
+                                       && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                       && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #else
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      #include "private/diagnostic_pop.h"
+    #else
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     template <typename TMessage>
-    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> >::value &&
-                                                                         !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                         !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value, int>::type = 0)
+    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> >::value
+                                                                               && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                               && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value,
+                                                                             int>::type = 0)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> >::value &&
-                                   !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                   etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value);
+      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> >::value
+                                   && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                   && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     message_packet(const message_packet& other)
       : valid(other.is_valid())
     {
@@ -618,11 +619,11 @@ namespace etl
         add_new_message(other.get());
       }
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     message_packet(message_packet&& other)
       : valid(other.is_valid())
     {
@@ -631,12 +632,12 @@ namespace etl
         add_new_message(etl::move(other.get()));
       }
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -647,12 +648,12 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& rhs)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -663,8 +664,8 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
     //********************************************
     ~message_packet()
@@ -693,10 +694,10 @@ namespace etl
     //**********************************************
     static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
     {
-      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
-             T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id ||
-             T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id ||
-             T13::ID == id || T14::ID == id || T15::ID == id || T16::ID == id;
+      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id
+             || T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id
+             || T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id
+             || T13::ID == id || T14::ID == id || T15::ID == id || T16::ID == id;
     }
 
     //**********************************************
@@ -709,22 +710,22 @@ namespace etl
     template <etl::message_id_t Id>
     static ETL_CONSTEXPR bool accepts()
     {
-      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
-             T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id ||
-             T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id ||
-             T13::ID == Id || T14::ID == Id || T15::ID == Id || T16::ID == Id;
+      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id
+             || T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id
+             || T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id
+             || T13::ID == Id || T14::ID == Id || T15::ID == Id || T16::ID == Id;
     }
 
     //**********************************************
     template <typename TMessage>
     static ETL_CONSTEXPR
-    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
+      typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
       accepts()
     {
-      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
-             T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID ||
-             T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID ||
-             T13::ID == TMessage::ID || T14::ID == TMessage::ID || T15::ID == TMessage::ID || T16::ID == TMessage::ID;
+      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID
+             || T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID
+             || T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID
+             || T13::ID == TMessage::ID || T14::ID == TMessage::ID || T15::ID == TMessage::ID || T16::ID == TMessage::ID;
     }
 
     enum
@@ -743,11 +744,11 @@ namespace etl
       {
         etl::imessage* pmsg = static_cast<etl::imessage*>(data);
 
-  #if ETL_HAS_VIRTUAL_MESSAGES
+    #if ETL_HAS_VIRTUAL_MESSAGES
         pmsg->~imessage();
-  #else
+    #else
         delete_message(pmsg);
-  #endif
+    #endif
       }
     }
     #include "private/diagnostic_pop.h"
@@ -781,7 +782,7 @@ namespace etl
     void add_new_message(const etl::imessage& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -805,12 +806,12 @@ namespace etl
       }
     }
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
     //********************************************
     void add_new_message(etl::imessage&& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -833,37 +834,37 @@ namespace etl
         default: ETL_ASSERT_FAIL(ETL_ERROR(unhandled_message_exception)); break;
       }
     }
-  #endif
+    #endif
 
     typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    bool valid;
+    bool                                                 valid;
   };
 
   //***************************************************************************
   // 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, 
+  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:
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>;
-  #endif
+    #endif
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     ETL_CONSTEXPR message_packet() ETL_NOEXCEPT
       : valid(false)
     {
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(const etl::imessage& msg)
     {
       if (accepts(msg))
@@ -878,11 +879,11 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(etl::imessage&& msg)
     {
       if (accepts(msg))
@@ -897,47 +898,49 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::value &&
-                                                                    !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                    !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value, int>::type>
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::value
+                                                                      && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                      && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value,
+                                                                    int>::type>
     explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::value &&
-                                       !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                       etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value);
+      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::value
+                                       && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                       && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #else
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      #include "private/diagnostic_pop.h"
+    #else
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     template <typename TMessage>
-    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::value &&
-                                                                         !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                         !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value, int>::type = 0)
+    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::value
+                                                                               && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                               && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value,
+                                                                             int>::type = 0)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::value &&
-                                   !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                   etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value);
+      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::value
+                                   && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                   && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     message_packet(const message_packet& other)
       : valid(other.is_valid())
     {
@@ -946,11 +949,11 @@ namespace etl
         add_new_message(other.get());
       }
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     message_packet(message_packet&& other)
       : valid(other.is_valid())
     {
@@ -959,12 +962,12 @@ namespace etl
         add_new_message(etl::move(other.get()));
       }
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -975,12 +978,12 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& rhs)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -991,8 +994,8 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
     //********************************************
     ~message_packet()
@@ -1021,10 +1024,10 @@ namespace etl
     //**********************************************
     static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
     {
-      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
-             T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id ||
-             T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id ||
-             T13::ID == id || T14::ID == id || T15::ID == id;
+      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id
+             || T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id
+             || T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id
+             || T13::ID == id || T14::ID == id || T15::ID == id;
     }
 
     //**********************************************
@@ -1037,22 +1040,22 @@ namespace etl
     template <etl::message_id_t Id>
     static ETL_CONSTEXPR bool accepts()
     {
-      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
-             T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id ||
-             T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id ||
-             T13::ID == Id || T14::ID == Id || T15::ID == Id;
+      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id
+             || T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id
+             || T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id
+             || T13::ID == Id || T14::ID == Id || T15::ID == Id;
     }
 
     //**********************************************
     template <typename TMessage>
     static ETL_CONSTEXPR
-    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
+      typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
       accepts()
     {
-      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
-             T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID ||
-             T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID ||
-             T13::ID == TMessage::ID || T14::ID == TMessage::ID || T15::ID == TMessage::ID;
+      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID
+             || T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID
+             || T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID
+             || T13::ID == TMessage::ID || T14::ID == TMessage::ID || T15::ID == TMessage::ID;
     }
 
     enum
@@ -1071,12 +1074,11 @@ namespace etl
       {
         etl::imessage* pmsg = static_cast<etl::imessage*>(data);
 
-
-  #if ETL_HAS_VIRTUAL_MESSAGES
+    #if ETL_HAS_VIRTUAL_MESSAGES
         pmsg->~imessage();
-  #else
+    #else
         delete_message(pmsg);
-  #endif
+    #endif
       }
     }
     #include "private/diagnostic_pop.h"
@@ -1109,7 +1111,7 @@ namespace etl
     void add_new_message(const etl::imessage& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -1132,12 +1134,12 @@ namespace etl
       }
     }
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
     //********************************************
     void add_new_message(etl::imessage&& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -1159,37 +1161,37 @@ namespace etl
         default: break;
       }
     }
-  #endif
+    #endif
 
     typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    bool valid;
+    bool                                                 valid;
   };
 
   //***************************************************************************
   // 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, 
+  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:
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>;
-  #endif
+    #endif
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     ETL_CONSTEXPR message_packet() ETL_NOEXCEPT
       : valid(false)
     {
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(const etl::imessage& msg)
     {
       if (accepts(msg))
@@ -1204,11 +1206,11 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(etl::imessage&& msg)
     {
       if (accepts(msg))
@@ -1223,47 +1225,49 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> >::value &&
-                                                                    !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                    !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value, int>::type>
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> >::value
+                                                                      && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                      && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value,
+                                                                    int>::type>
     explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> >::value &&
-                                       !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                       etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value);
+      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> >::value
+                                       && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                       && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #else
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      #include "private/diagnostic_pop.h"
+    #else
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     template <typename TMessage>
-    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> >::value &&
-                                                                         !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                         !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value, int>::type = 0)
+    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> >::value
+                                                                               && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                               && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value,
+                                                                             int>::type = 0)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> >::value &&
-                                   !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                   etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value);
+      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> >::value
+                                   && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                   && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     message_packet(const message_packet& other)
       : valid(other.is_valid())
     {
@@ -1272,11 +1276,11 @@ namespace etl
         add_new_message(other.get());
       }
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     message_packet(message_packet&& other)
       : valid(other.is_valid())
     {
@@ -1285,12 +1289,12 @@ namespace etl
         add_new_message(etl::move(other.get()));
       }
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -1301,12 +1305,12 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& rhs)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -1317,8 +1321,8 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
     //********************************************
     ~message_packet()
@@ -1347,10 +1351,10 @@ namespace etl
     //**********************************************
     static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
     {
-      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
-             T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id ||
-             T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id ||
-             T13::ID == id || T14::ID == id;
+      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id
+             || T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id
+             || T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id
+             || T13::ID == id || T14::ID == id;
     }
 
     //**********************************************
@@ -1363,22 +1367,22 @@ namespace etl
     template <etl::message_id_t Id>
     static ETL_CONSTEXPR bool accepts()
     {
-      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
-             T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id ||
-             T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id ||
-             T13::ID == Id || T14::ID == Id;
+      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id
+             || T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id
+             || T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id
+             || T13::ID == Id || T14::ID == Id;
     }
 
     //**********************************************
     template <typename TMessage>
     static ETL_CONSTEXPR
-    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
+      typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
       accepts()
     {
-      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
-             T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID ||
-             T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID ||
-             T13::ID == TMessage::ID || T14::ID == TMessage::ID;
+      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID
+             || T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID
+             || T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID
+             || T13::ID == TMessage::ID || T14::ID == TMessage::ID;
     }
 
     enum
@@ -1397,12 +1401,11 @@ namespace etl
       {
         etl::imessage* pmsg = static_cast<etl::imessage*>(data);
 
-
-  #if ETL_HAS_VIRTUAL_MESSAGES
+    #if ETL_HAS_VIRTUAL_MESSAGES
         pmsg->~imessage();
-  #else
+    #else
         delete_message(pmsg);
-  #endif
+    #endif
       }
     }
     #include "private/diagnostic_pop.h"
@@ -1434,7 +1437,7 @@ namespace etl
     void add_new_message(const etl::imessage& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -1456,12 +1459,12 @@ namespace etl
       }
     }
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
     //********************************************
     void add_new_message(etl::imessage&& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -1482,37 +1485,37 @@ namespace etl
         default: break;
       }
     }
-  #endif
+    #endif
 
     typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    bool valid;
+    bool                                                 valid;
   };
 
   //***************************************************************************
   // 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, 
+  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:
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>;
-  #endif
+    #endif
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     ETL_CONSTEXPR message_packet() ETL_NOEXCEPT
       : valid(false)
     {
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(const etl::imessage& msg)
     {
       if (accepts(msg))
@@ -1527,11 +1530,11 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(etl::imessage&& msg)
     {
       if (accepts(msg))
@@ -1546,47 +1549,49 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> >::value &&
-                                                                    !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                    !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value, int>::type>
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> >::value
+                                                                      && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                      && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value,
+                                                                    int>::type>
     explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> >::value &&
-                                       !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                       etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value);
+      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> >::value
+                                       && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                       && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #else
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      #include "private/diagnostic_pop.h"
+    #else
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     template <typename TMessage>
-    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> >::value &&
-                                                                         !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                         !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value, int>::type = 0)
+    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> >::value
+                                                                               && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                               && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value,
+                                                                             int>::type = 0)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> >::value &&
-                                   !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                   etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value);
+      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> >::value
+                                   && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                   && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     message_packet(const message_packet& other)
       : valid(other.is_valid())
     {
@@ -1595,11 +1600,11 @@ namespace etl
         add_new_message(other.get());
       }
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     message_packet(message_packet&& other)
       : valid(other.is_valid())
     {
@@ -1608,12 +1613,12 @@ namespace etl
         add_new_message(etl::move(other.get()));
       }
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -1624,12 +1629,12 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& rhs)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -1640,8 +1645,8 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
     //********************************************
     ~message_packet()
@@ -1670,10 +1675,10 @@ namespace etl
     //**********************************************
     static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
     {
-      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
-             T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id ||
-             T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id ||
-             T13::ID == id;
+      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id
+             || T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id
+             || T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id
+             || T13::ID == id;
     }
 
     //**********************************************
@@ -1686,22 +1691,22 @@ namespace etl
     template <etl::message_id_t Id>
     static ETL_CONSTEXPR bool accepts()
     {
-      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
-             T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id ||
-             T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id ||
-             T13::ID == Id;
+      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id
+             || T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id
+             || T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id
+             || T13::ID == Id;
     }
 
     //**********************************************
     template <typename TMessage>
     static ETL_CONSTEXPR
-    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
+      typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
       accepts()
     {
-      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
-             T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID ||
-             T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID ||
-             T13::ID == TMessage::ID;
+      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID
+             || T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID
+             || T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID
+             || T13::ID == TMessage::ID;
     }
 
     enum
@@ -1720,12 +1725,11 @@ namespace etl
       {
         etl::imessage* pmsg = static_cast<etl::imessage*>(data);
 
-
-  #if ETL_HAS_VIRTUAL_MESSAGES
+    #if ETL_HAS_VIRTUAL_MESSAGES
         pmsg->~imessage();
-  #else
+    #else
         delete_message(pmsg);
-  #endif
+    #endif
       }
     }
     #include "private/diagnostic_pop.h"
@@ -1756,7 +1760,7 @@ namespace etl
     void add_new_message(const etl::imessage& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -1777,12 +1781,12 @@ namespace etl
       }
     }
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
     //********************************************
     void add_new_message(etl::imessage&& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -1802,36 +1806,36 @@ namespace etl
         default: break;
       }
     }
-  #endif
+    #endif
 
     typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    bool valid;
+    bool                                                 valid;
   };
 
   //***************************************************************************
   // Specialisation for 12 message types.
   //***************************************************************************
-  template <typename T1, typename T2, typename T3, typename T4, 
-            typename T5, typename T6, typename T7, typename T8, 
+  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:
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>;
-  #endif
+    #endif
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     ETL_CONSTEXPR message_packet() ETL_NOEXCEPT
       : valid(false)
     {
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(const etl::imessage& msg)
     {
       if (accepts(msg))
@@ -1846,11 +1850,11 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(etl::imessage&& msg)
     {
       if (accepts(msg))
@@ -1865,47 +1869,49 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> >::value &&
-                                                                    !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                    !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value, int>::type>
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> >::value
+                                                                      && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                      && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value,
+                                                                    int>::type>
     explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> >::value &&
-                                       !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                       etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value);
+      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> >::value
+                                       && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                       && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #else
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      #include "private/diagnostic_pop.h"
+    #else
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     template <typename TMessage>
-    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> >::value &&
-                                                                         !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                         !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value, int>::type = 0)
+    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> >::value
+                                                                               && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                               && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value,
+                                                                             int>::type = 0)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> >::value &&
-                                   !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                   etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value);
+      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> >::value
+                                   && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                   && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     message_packet(const message_packet& other)
       : valid(other.is_valid())
     {
@@ -1914,11 +1920,11 @@ namespace etl
         add_new_message(other.get());
       }
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     message_packet(message_packet&& other)
       : valid(other.is_valid())
     {
@@ -1927,12 +1933,12 @@ namespace etl
         add_new_message(etl::move(other.get()));
       }
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -1943,12 +1949,12 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& rhs)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -1959,8 +1965,8 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
     //********************************************
     ~message_packet()
@@ -1989,9 +1995,9 @@ namespace etl
     //**********************************************
     static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
     {
-      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
-             T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id ||
-             T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id;
+      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id
+             || T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id
+             || T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id;
     }
 
     //**********************************************
@@ -2004,20 +2010,20 @@ namespace etl
     template <etl::message_id_t Id>
     static ETL_CONSTEXPR bool accepts()
     {
-      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
-             T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id ||
-             T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id;
+      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id
+             || T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id
+             || T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id;
     }
 
     //**********************************************
     template <typename TMessage>
     static ETL_CONSTEXPR
-    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
+      typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
       accepts()
     {
-      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
-             T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID ||
-             T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID;
+      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID
+             || T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID
+             || T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID;
     }
 
     enum
@@ -2036,12 +2042,11 @@ namespace etl
       {
         etl::imessage* pmsg = static_cast<etl::imessage*>(data);
 
-
-  #if ETL_HAS_VIRTUAL_MESSAGES
+    #if ETL_HAS_VIRTUAL_MESSAGES
         pmsg->~imessage();
-  #else
+    #else
         delete_message(pmsg);
-  #endif
+    #endif
       }
     }
     #include "private/diagnostic_pop.h"
@@ -2071,7 +2076,7 @@ namespace etl
     void add_new_message(const etl::imessage& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -2091,12 +2096,12 @@ namespace etl
       }
     }
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
     //********************************************
     void add_new_message(etl::imessage&& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -2115,36 +2120,36 @@ namespace etl
         default: break;
       }
     }
-  #endif
+    #endif
 
     typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    bool valid;
+    bool                                                 valid;
   };
 
   //***************************************************************************
   // Specialisation for 11 message types.
   //***************************************************************************
-  template <typename T1, typename T2, typename T3, typename T4, 
-            typename T5, typename T6, typename T7, typename T8, 
+  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:
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>;
-  #endif
+    #endif
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     ETL_CONSTEXPR message_packet() ETL_NOEXCEPT
       : valid(false)
     {
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(const etl::imessage& msg)
     {
       if (accepts(msg))
@@ -2159,11 +2164,11 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(etl::imessage&& msg)
     {
       if (accepts(msg))
@@ -2178,47 +2183,49 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> >::value &&
-                                                                    !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                    !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value, int>::type>
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> >::value
+                                                                      && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                      && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value,
+                                                                    int>::type>
     explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> >::value &&
-                                       !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                       etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value);
+      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> >::value
+                                       && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                       && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #else
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      #include "private/diagnostic_pop.h"
+    #else
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     template <typename TMessage>
-    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> >::value &&
-                                                                         !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                         !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value, int>::type = 0)
+    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> >::value
+                                                                               && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                               && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value,
+                                                                             int>::type = 0)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> >::value &&
-                                   !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                   etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value);
+      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> >::value
+                                   && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                   && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     message_packet(const message_packet& other)
       : valid(other.is_valid())
     {
@@ -2227,11 +2234,11 @@ namespace etl
         add_new_message(other.get());
       }
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     message_packet(message_packet&& other)
       : valid(other.is_valid())
     {
@@ -2240,12 +2247,12 @@ namespace etl
         add_new_message(etl::move(other.get()));
       }
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -2256,12 +2263,12 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& rhs)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -2272,8 +2279,8 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
     //********************************************
     ~message_packet()
@@ -2302,9 +2309,9 @@ namespace etl
     //**********************************************
     static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
     {
-      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
-             T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id ||
-             T9::ID == id || T10::ID == id || T11::ID == id;
+      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id
+             || T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id
+             || T9::ID == id || T10::ID == id || T11::ID == id;
     }
 
     //**********************************************
@@ -2317,20 +2324,20 @@ namespace etl
     template <etl::message_id_t Id>
     static ETL_CONSTEXPR bool accepts()
     {
-      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
-             T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id ||
-             T9::ID == Id || T10::ID == Id || T11::ID == Id;
+      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id
+             || T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id
+             || T9::ID == Id || T10::ID == Id || T11::ID == Id;
     }
 
     //**********************************************
     template <typename TMessage>
     static ETL_CONSTEXPR
-    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
+      typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
       accepts()
     {
-      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
-             T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID ||
-             T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID;
+      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID
+             || T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID
+             || T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID;
     }
 
     enum
@@ -2349,12 +2356,11 @@ namespace etl
       {
         etl::imessage* pmsg = static_cast<etl::imessage*>(data);
 
-
-  #if ETL_HAS_VIRTUAL_MESSAGES
+    #if ETL_HAS_VIRTUAL_MESSAGES
         pmsg->~imessage();
-  #else
+    #else
         delete_message(pmsg);
-  #endif
+    #endif
       }
     }
     #include "private/diagnostic_pop.h"
@@ -2383,7 +2389,7 @@ namespace etl
     void add_new_message(const etl::imessage& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -2402,12 +2408,12 @@ namespace etl
       }
     }
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
     //********************************************
     void add_new_message(etl::imessage&& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -2425,36 +2431,36 @@ namespace etl
         default: break;
       }
     }
-  #endif
+    #endif
 
     typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    bool valid;
+    bool                                                 valid;
   };
 
   //***************************************************************************
   // Specialisation for 10 message types.
   //***************************************************************************
-  template <typename T1, typename T2, typename T3, typename T4, 
-            typename T5, typename T6, typename T7, typename T8, 
+  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:
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>;
-  #endif
+    #endif
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     ETL_CONSTEXPR message_packet() ETL_NOEXCEPT
       : valid(false)
     {
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(const etl::imessage& msg)
     {
       if (accepts(msg))
@@ -2469,11 +2475,11 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(etl::imessage&& msg)
     {
       if (accepts(msg))
@@ -2488,47 +2494,49 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >::value &&
-                                                                    !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                    !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value, int>::type>
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >::value
+                                                                      && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                      && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value,
+                                                                    int>::type>
     explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >::value &&
-                                       !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                       etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value);
+      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >::value
+                                       && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                       && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #else
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      #include "private/diagnostic_pop.h"
+    #else
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     template <typename TMessage>
-    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >::value &&
-                                                                         !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                         !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value, int>::type = 0)
+    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >::value
+                                                                               && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                               && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value,
+                                                                             int>::type = 0)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >::value &&
-                                   !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                   etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value);
+      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >::value
+                                   && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                   && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     message_packet(const message_packet& other)
       : valid(other.is_valid())
     {
@@ -2537,11 +2545,11 @@ namespace etl
         add_new_message(other.get());
       }
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     message_packet(message_packet&& other)
       : valid(other.is_valid())
     {
@@ -2550,12 +2558,12 @@ namespace etl
         add_new_message(etl::move(other.get()));
       }
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -2566,12 +2574,12 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& rhs)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -2582,8 +2590,8 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
     //********************************************
     ~message_packet()
@@ -2612,9 +2620,9 @@ namespace etl
     //**********************************************
     static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
     {
-      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
-             T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id ||
-             T9::ID == id || T10::ID == id;
+      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id
+             || T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id
+             || T9::ID == id || T10::ID == id;
     }
 
     //**********************************************
@@ -2627,20 +2635,20 @@ namespace etl
     template <etl::message_id_t Id>
     static ETL_CONSTEXPR bool accepts()
     {
-      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
-             T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id ||
-             T9::ID == Id || T10::ID == Id;
+      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id
+             || T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id
+             || T9::ID == Id || T10::ID == Id;
     }
 
     //**********************************************
     template <typename TMessage>
     static ETL_CONSTEXPR
-    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
+      typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
       accepts()
     {
-      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
-             T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID ||
-             T9::ID == TMessage::ID || T10::ID == TMessage::ID;
+      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID
+             || T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID
+             || T9::ID == TMessage::ID || T10::ID == TMessage::ID;
     }
 
     enum
@@ -2659,12 +2667,11 @@ namespace etl
       {
         etl::imessage* pmsg = static_cast<etl::imessage*>(data);
 
-
-  #if ETL_HAS_VIRTUAL_MESSAGES
+    #if ETL_HAS_VIRTUAL_MESSAGES
         pmsg->~imessage();
-  #else
+    #else
         delete_message(pmsg);
-  #endif
+    #endif
       }
     }
     #include "private/diagnostic_pop.h"
@@ -2692,7 +2699,7 @@ namespace etl
     void add_new_message(const etl::imessage& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -2710,12 +2717,12 @@ namespace etl
       }
     }
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
     //********************************************
     void add_new_message(etl::imessage&& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -2732,36 +2739,36 @@ namespace etl
         default: break;
       }
     }
-  #endif
+    #endif
 
     typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    bool valid;
+    bool                                                 valid;
   };
 
   //***************************************************************************
   // Specialisation for 9 message types.
   //***************************************************************************
-  template <typename T1, typename T2, typename T3, typename T4, 
-            typename T5, typename T6, typename T7, typename T8, 
+  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:
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7, T8, T9>;
-  #endif
+    #endif
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     ETL_CONSTEXPR message_packet() ETL_NOEXCEPT
       : valid(false)
     {
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(const etl::imessage& msg)
     {
       if (accepts(msg))
@@ -2776,11 +2783,11 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(etl::imessage&& msg)
     {
       if (accepts(msg))
@@ -2795,47 +2802,49 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9> >::value &&
-                                                                    !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                    !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9>::value, int>::type>
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9> >::value
+                                                                      && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                      && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9>::value,
+                                                                    int>::type>
     explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9> >::value &&
-                                       !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                       etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9>::value);
+      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9> >::value
+                                       && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                       && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #else
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      #include "private/diagnostic_pop.h"
+    #else
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     template <typename TMessage>
-    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9> >::value &&
-                                                                         !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                         !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9>::value, int>::type = 0)
+    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9> >::value
+                                                                               && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                               && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9>::value,
+                                                                             int>::type = 0)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9> >::value &&
-                                   !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                   etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9>::value);
+      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9> >::value
+                                   && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                   && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     message_packet(const message_packet& other)
       : valid(other.is_valid())
     {
@@ -2844,11 +2853,11 @@ namespace etl
         add_new_message(other.get());
       }
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     message_packet(message_packet&& other)
       : valid(other.is_valid())
     {
@@ -2857,12 +2866,12 @@ namespace etl
         add_new_message(etl::move(other.get()));
       }
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -2873,12 +2882,12 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& rhs)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -2889,8 +2898,8 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
     //********************************************
     ~message_packet()
@@ -2919,9 +2928,9 @@ namespace etl
     //**********************************************
     static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
     {
-      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
-             T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id ||
-             T9::ID == id;
+      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id
+             || T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id
+             || T9::ID == id;
     }
 
     //**********************************************
@@ -2934,20 +2943,20 @@ namespace etl
     template <etl::message_id_t Id>
     static ETL_CONSTEXPR bool accepts()
     {
-      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
-             T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id ||
-             T9::ID == Id;
+      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id
+             || T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id
+             || T9::ID == Id;
     }
 
     //**********************************************
     template <typename TMessage>
     static ETL_CONSTEXPR
-    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
+      typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
       accepts()
     {
-      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
-             T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID ||
-             T9::ID == TMessage::ID;
+      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID
+             || T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID
+             || T9::ID == TMessage::ID;
     }
 
     enum
@@ -2966,12 +2975,11 @@ namespace etl
       {
         etl::imessage* pmsg = static_cast<etl::imessage*>(data);
 
-
-  #if ETL_HAS_VIRTUAL_MESSAGES
+    #if ETL_HAS_VIRTUAL_MESSAGES
         pmsg->~imessage();
-  #else
+    #else
         delete_message(pmsg);
-  #endif
+    #endif
       }
     }
     #include "private/diagnostic_pop.h"
@@ -2998,7 +3006,7 @@ namespace etl
     void add_new_message(const etl::imessage& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -3015,12 +3023,12 @@ namespace etl
       }
     }
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
     //********************************************
     void add_new_message(etl::imessage&& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -3036,35 +3044,35 @@ namespace etl
         default: break;
       }
     }
-  #endif
+    #endif
 
     typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    bool valid;
+    bool                                                 valid;
   };
 
   //***************************************************************************
   // Specialisation for 8 message types.
   //***************************************************************************
-  template <typename T1, typename T2, typename T3, typename T4, 
+  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:
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7, T8>;
-  #endif
+    #endif
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     ETL_CONSTEXPR message_packet() ETL_NOEXCEPT
       : valid(false)
     {
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(const etl::imessage& msg)
     {
       if (accepts(msg))
@@ -3079,11 +3087,11 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(etl::imessage&& msg)
     {
       if (accepts(msg))
@@ -3098,47 +3106,49 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8> >::value &&
-                                                                    !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                    !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8>::value, int>::type>
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8> >::value
+                                                                      && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                      && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8>::value,
+                                                                    int>::type>
     explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8> >::value &&
-                                       !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                       etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8>::value);
+      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8> >::value
+                                       && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                       && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #else
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      #include "private/diagnostic_pop.h"
+    #else
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     template <typename TMessage>
-    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8> >::value &&
-                                                                         !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                         !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8>::value, int>::type = 0)
+    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8> >::value
+                                                                               && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                               && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8>::value,
+                                                                             int>::type = 0)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8> >::value &&
-                                   !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                   etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8>::value);
+      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8> >::value
+                                   && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                   && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     message_packet(const message_packet& other)
       : valid(other.is_valid())
     {
@@ -3147,11 +3157,11 @@ namespace etl
         add_new_message(other.get());
       }
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     message_packet(message_packet&& other)
       : valid(other.is_valid())
     {
@@ -3160,12 +3170,12 @@ namespace etl
         add_new_message(etl::move(other.get()));
       }
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -3176,12 +3186,12 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& rhs)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -3192,8 +3202,8 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
     //********************************************
     ~message_packet()
@@ -3222,8 +3232,8 @@ namespace etl
     //**********************************************
     static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
     {
-      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
-             T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id;
+      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id
+             || T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id;
     }
 
     //**********************************************
@@ -3236,18 +3246,18 @@ namespace etl
     template <etl::message_id_t Id>
     static ETL_CONSTEXPR bool accepts()
     {
-      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
-             T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id;
+      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id
+             || T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id;
     }
 
     //**********************************************
     template <typename TMessage>
     static ETL_CONSTEXPR
-    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
+      typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
       accepts()
     {
-      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
-             T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID;
+      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID
+             || T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID;
     }
 
     enum
@@ -3266,12 +3276,11 @@ namespace etl
       {
         etl::imessage* pmsg = static_cast<etl::imessage*>(data);
 
-
-  #if ETL_HAS_VIRTUAL_MESSAGES
+    #if ETL_HAS_VIRTUAL_MESSAGES
         pmsg->~imessage();
-  #else
+    #else
         delete_message(pmsg);
-  #endif
+    #endif
       }
     }
     #include "private/diagnostic_pop.h"
@@ -3297,7 +3306,7 @@ namespace etl
     void add_new_message(const etl::imessage& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -3313,12 +3322,12 @@ namespace etl
       }
     }
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
     //********************************************
     void add_new_message(etl::imessage&& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -3333,35 +3342,35 @@ namespace etl
         default: break;
       }
     }
-  #endif
+    #endif
 
     typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    bool valid;
+    bool                                                 valid;
   };
 
   //***************************************************************************
   // Specialisation for 7 message types.
   //***************************************************************************
-  template <typename T1, typename T2, typename T3, typename T4, 
+  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:
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7>;
-  #endif
+    #endif
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     ETL_CONSTEXPR message_packet() ETL_NOEXCEPT
       : valid(false)
     {
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(const etl::imessage& msg)
     {
       if (accepts(msg))
@@ -3376,11 +3385,11 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(etl::imessage&& msg)
     {
       if (accepts(msg))
@@ -3395,47 +3404,49 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7> >::value &&
-                                                                    !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                    !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7>::value, int>::type>
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7> >::value
+                                                                      && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                      && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7>::value,
+                                                                    int>::type>
     explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7> >::value &&
-                                       !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                       etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7>::value);
+      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7> >::value
+                                       && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                       && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #else
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      #include "private/diagnostic_pop.h"
+    #else
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     template <typename TMessage>
-    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7> >::value &&
-                                                                         !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                         !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7>::value, int>::type = 0)
+    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7> >::value
+                                                                               && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                               && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7>::value,
+                                                                             int>::type = 0)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7> >::value &&
-                                   !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                   etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7>::value);
+      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7> >::value
+                                   && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                   && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     message_packet(const message_packet& other)
       : valid(other.is_valid())
     {
@@ -3444,11 +3455,11 @@ namespace etl
         add_new_message(other.get());
       }
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     message_packet(message_packet&& other)
       : valid(other.is_valid())
     {
@@ -3457,12 +3468,12 @@ namespace etl
         add_new_message(etl::move(other.get()));
       }
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -3473,12 +3484,12 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& rhs)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -3489,8 +3500,8 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
     //********************************************
     ~message_packet()
@@ -3519,8 +3530,8 @@ namespace etl
     //**********************************************
     static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
     {
-      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
-             T5::ID == id || T6::ID == id || T7::ID == id;
+      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id
+             || T5::ID == id || T6::ID == id || T7::ID == id;
     }
 
     //**********************************************
@@ -3533,18 +3544,18 @@ namespace etl
     template <etl::message_id_t Id>
     static ETL_CONSTEXPR bool accepts()
     {
-      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
-             T5::ID == Id || T6::ID == Id || T7::ID == Id;
+      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id
+             || T5::ID == Id || T6::ID == Id || T7::ID == Id;
     }
 
     //**********************************************
     template <typename TMessage>
     static ETL_CONSTEXPR
-    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
+      typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
       accepts()
     {
-      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
-             T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID;
+      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID
+             || T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID;
     }
 
     enum
@@ -3563,12 +3574,11 @@ namespace etl
       {
         etl::imessage* pmsg = static_cast<etl::imessage*>(data);
 
-
-  #if ETL_HAS_VIRTUAL_MESSAGES
+    #if ETL_HAS_VIRTUAL_MESSAGES
         pmsg->~imessage();
-  #else
+    #else
         delete_message(pmsg);
-  #endif
+    #endif
       }
     }
     #include "private/diagnostic_pop.h"
@@ -3593,7 +3603,7 @@ namespace etl
     void add_new_message(const etl::imessage& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -3608,12 +3618,12 @@ namespace etl
       }
     }
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
     //********************************************
     void add_new_message(etl::imessage&& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -3627,35 +3637,35 @@ namespace etl
         default: break;
       }
     }
-  #endif
+    #endif
 
     typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    bool valid;
+    bool                                                 valid;
   };
 
   //***************************************************************************
   // Specialisation for 6 message types.
   //***************************************************************************
-  template <typename T1, typename T2, typename T3, typename T4, 
+  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:
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6>;
-  #endif
+    #endif
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     ETL_CONSTEXPR message_packet() ETL_NOEXCEPT
       : valid(false)
     {
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(const etl::imessage& msg)
     {
       if (accepts(msg))
@@ -3670,11 +3680,11 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(etl::imessage&& msg)
     {
       if (accepts(msg))
@@ -3689,47 +3699,49 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6> >::value &&
-                                                                    !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                    !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6>::value, int>::type>
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6> >::value
+                                                                      && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                      && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6>::value,
+                                                                    int>::type>
     explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6> >::value &&
-                                       !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                       etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6>::value);
+      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6> >::value
+                                       && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                       && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #else
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      #include "private/diagnostic_pop.h"
+    #else
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     template <typename TMessage>
-    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6> >::value &&
-                                                                         !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                         !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6>::value, int>::type = 0)
+    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6> >::value
+                                                                               && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                               && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6>::value,
+                                                                             int>::type = 0)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6> >::value &&
-                                   !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                   etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6>::value);
+      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6> >::value
+                                   && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                   && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     message_packet(const message_packet& other)
       : valid(other.is_valid())
     {
@@ -3738,11 +3750,11 @@ namespace etl
         add_new_message(other.get());
       }
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     message_packet(message_packet&& other)
       : valid(other.is_valid())
     {
@@ -3751,12 +3763,12 @@ namespace etl
         add_new_message(etl::move(other.get()));
       }
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -3767,12 +3779,12 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& rhs)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -3783,8 +3795,8 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
     //********************************************
     ~message_packet()
@@ -3813,8 +3825,8 @@ namespace etl
     //**********************************************
     static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
     {
-      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
-             T5::ID == id || T6::ID == id;
+      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id
+             || T5::ID == id || T6::ID == id;
     }
 
     //**********************************************
@@ -3827,18 +3839,18 @@ namespace etl
     template <etl::message_id_t Id>
     static ETL_CONSTEXPR bool accepts()
     {
-      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
-             T5::ID == Id || T6::ID == Id;
+      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id
+             || T5::ID == Id || T6::ID == Id;
     }
 
     //**********************************************
     template <typename TMessage>
     static ETL_CONSTEXPR
-    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
+      typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
       accepts()
     {
-      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
-             T5::ID == TMessage::ID || T6::ID == TMessage::ID;
+      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID
+             || T5::ID == TMessage::ID || T6::ID == TMessage::ID;
     }
 
     enum
@@ -3857,12 +3869,11 @@ namespace etl
       {
         etl::imessage* pmsg = static_cast<etl::imessage*>(data);
 
-
-  #if ETL_HAS_VIRTUAL_MESSAGES
+    #if ETL_HAS_VIRTUAL_MESSAGES
         pmsg->~imessage();
-  #else
+    #else
         delete_message(pmsg);
-  #endif
+    #endif
       }
     }
     #include "private/diagnostic_pop.h"
@@ -3886,7 +3897,7 @@ namespace etl
     void add_new_message(const etl::imessage& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -3900,12 +3911,12 @@ namespace etl
       }
     }
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
     //********************************************
     void add_new_message(etl::imessage&& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -3918,35 +3929,35 @@ namespace etl
         default: break;
       }
     }
-  #endif
+    #endif
 
     typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    bool valid;
+    bool                                                 valid;
   };
 
   //***************************************************************************
   // Specialisation for 5 message types.
   //***************************************************************************
-  template <typename T1, typename T2, typename T3, typename T4, 
+  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:
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5>;
-  #endif
+    #endif
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     ETL_CONSTEXPR message_packet() ETL_NOEXCEPT
       : valid(false)
     {
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(const etl::imessage& msg)
     {
       if (accepts(msg))
@@ -3961,11 +3972,11 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(etl::imessage&& msg)
     {
       if (accepts(msg))
@@ -3980,47 +3991,49 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5> >::value &&
-                                                                    !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                    !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5>::value, int>::type>
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5> >::value
+                                                                      && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                      && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5>::value,
+                                                                    int>::type>
     explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5> >::value &&
-                                       !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                       etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5>::value);
+      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5> >::value
+                                       && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                       && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #else
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      #include "private/diagnostic_pop.h"
+    #else
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     template <typename TMessage>
-    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5> >::value &&
-                                                                         !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                         !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5>::value, int>::type = 0)
+    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5> >::value
+                                                                               && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                               && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5>::value,
+                                                                             int>::type = 0)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5> >::value &&
-                                   !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                   etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5>::value);
+      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5> >::value
+                                   && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                   && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     message_packet(const message_packet& other)
       : valid(other.is_valid())
     {
@@ -4029,11 +4042,11 @@ namespace etl
         add_new_message(other.get());
       }
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     message_packet(message_packet&& other)
       : valid(other.is_valid())
     {
@@ -4042,12 +4055,12 @@ namespace etl
         add_new_message(etl::move(other.get()));
       }
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -4058,12 +4071,12 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& rhs)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -4074,8 +4087,8 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
     //********************************************
     ~message_packet()
@@ -4104,8 +4117,8 @@ namespace etl
     //**********************************************
     static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
     {
-      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
-             T5::ID == id;
+      return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id
+             || T5::ID == id;
     }
 
     //**********************************************
@@ -4118,18 +4131,18 @@ namespace etl
     template <etl::message_id_t Id>
     static ETL_CONSTEXPR bool accepts()
     {
-      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
-             T5::ID == Id;
+      return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id
+             || T5::ID == Id;
     }
 
     //**********************************************
     template <typename TMessage>
     static ETL_CONSTEXPR
-    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
+      typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
       accepts()
     {
-      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
-             T5::ID == TMessage::ID;
+      return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID
+             || T5::ID == TMessage::ID;
     }
 
     enum
@@ -4148,12 +4161,11 @@ namespace etl
       {
         etl::imessage* pmsg = static_cast<etl::imessage*>(data);
 
-
-  #if ETL_HAS_VIRTUAL_MESSAGES
+    #if ETL_HAS_VIRTUAL_MESSAGES
         pmsg->~imessage();
-  #else
+    #else
         delete_message(pmsg);
-  #endif
+    #endif
       }
     }
     #include "private/diagnostic_pop.h"
@@ -4176,7 +4188,7 @@ namespace etl
     void add_new_message(const etl::imessage& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -4189,12 +4201,12 @@ namespace etl
       }
     }
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
     //********************************************
     void add_new_message(etl::imessage&& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -4206,10 +4218,10 @@ namespace etl
         default: break;
       }
     }
-  #endif
+    #endif
 
     typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    bool valid;
+    bool                                                 valid;
   };
 
   //***************************************************************************
@@ -4220,20 +4232,20 @@ namespace etl
   {
   public:
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4>;
-  #endif
+    #endif
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     ETL_CONSTEXPR message_packet() ETL_NOEXCEPT
       : valid(false)
     {
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(const etl::imessage& msg)
     {
       if (accepts(msg))
@@ -4248,11 +4260,11 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(etl::imessage&& msg)
     {
       if (accepts(msg))
@@ -4267,47 +4279,49 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4> >::value &&
-                                                                    !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                    !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4>::value, int>::type>
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4> >::value
+                                                                      && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                      && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4>::value,
+                                                                    int>::type>
     explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4> >::value &&
-                                       !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                       etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4>::value);
+      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4> >::value
+                                       && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                       && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #else
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      #include "private/diagnostic_pop.h"
+    #else
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     template <typename TMessage>
-    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4> >::value &&
-                                                                         !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                         !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4>::value, int>::type = 0)
+    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4> >::value
+                                                                               && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                               && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4>::value,
+                                                                             int>::type = 0)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4> >::value &&
-                                   !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                   etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4>::value);
+      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4> >::value
+                                   && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                   && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     message_packet(const message_packet& other)
       : valid(other.is_valid())
     {
@@ -4316,11 +4330,11 @@ namespace etl
         add_new_message(other.get());
       }
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     message_packet(message_packet&& other)
       : valid(other.is_valid())
     {
@@ -4329,12 +4343,12 @@ namespace etl
         add_new_message(etl::move(other.get()));
       }
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -4345,12 +4359,12 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& rhs)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -4361,8 +4375,8 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
     //********************************************
     ~message_packet()
@@ -4410,7 +4424,7 @@ namespace etl
     //**********************************************
     template <typename TMessage>
     static ETL_CONSTEXPR
-    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
+      typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
       accepts()
     {
       return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID;
@@ -4432,12 +4446,11 @@ namespace etl
       {
         etl::imessage* pmsg = static_cast<etl::imessage*>(data);
 
-
-  #if ETL_HAS_VIRTUAL_MESSAGES
+    #if ETL_HAS_VIRTUAL_MESSAGES
         pmsg->~imessage();
-  #else
+    #else
         delete_message(pmsg);
-  #endif
+    #endif
       }
     }
     #include "private/diagnostic_pop.h"
@@ -4459,7 +4472,7 @@ namespace etl
     void add_new_message(const etl::imessage& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -4471,12 +4484,12 @@ namespace etl
       }
     }
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
     //********************************************
     void add_new_message(etl::imessage&& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -4487,10 +4500,10 @@ namespace etl
         default: break;
       }
     }
-  #endif
+    #endif
 
     typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    bool valid;
+    bool                                                 valid;
   };
 
   //***************************************************************************
@@ -4501,20 +4514,20 @@ namespace etl
   {
   public:
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3>;
-  #endif
+    #endif
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     ETL_CONSTEXPR message_packet() ETL_NOEXCEPT
       : valid(false)
     {
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(const etl::imessage& msg)
     {
       if (accepts(msg))
@@ -4529,11 +4542,11 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(etl::imessage&& msg)
     {
       if (accepts(msg))
@@ -4548,47 +4561,49 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3> >::value &&
-                                                                    !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                    !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3>::value, int>::type>
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3> >::value
+                                                                      && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                      && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3>::value,
+                                                                    int>::type>
     explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3> >::value &&
-                                       !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                       etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3>::value);
+      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3> >::value
+                                       && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                       && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #else
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      #include "private/diagnostic_pop.h"
+    #else
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     template <typename TMessage>
-    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3> >::value &&
-                                                                         !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                         !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3>::value, int>::type = 0)
+    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3> >::value
+                                                                               && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                               && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3>::value,
+                                                                             int>::type = 0)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3> >::value &&
-                                   !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                   etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3>::value);
+      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3> >::value
+                                   && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                   && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     message_packet(const message_packet& other)
       : valid(other.is_valid())
     {
@@ -4597,11 +4612,11 @@ namespace etl
         add_new_message(other.get());
       }
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     message_packet(message_packet&& other)
       : valid(other.is_valid())
     {
@@ -4610,12 +4625,12 @@ namespace etl
         add_new_message(etl::move(other.get()));
       }
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -4626,12 +4641,12 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& rhs)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -4642,8 +4657,8 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
     //********************************************
     ~message_packet()
@@ -4691,7 +4706,7 @@ namespace etl
     //**********************************************
     template <typename TMessage>
     static ETL_CONSTEXPR
-    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
+      typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
       accepts()
     {
       return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID;
@@ -4713,12 +4728,11 @@ namespace etl
       {
         etl::imessage* pmsg = static_cast<etl::imessage*>(data);
 
-
-  #if ETL_HAS_VIRTUAL_MESSAGES
+    #if ETL_HAS_VIRTUAL_MESSAGES
         pmsg->~imessage();
-  #else
+    #else
         delete_message(pmsg);
-  #endif
+    #endif
       }
     }
     #include "private/diagnostic_pop.h"
@@ -4739,7 +4753,7 @@ namespace etl
     void add_new_message(const etl::imessage& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -4750,12 +4764,12 @@ namespace etl
       }
     }
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
     //********************************************
     void add_new_message(etl::imessage&& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -4765,10 +4779,10 @@ namespace etl
         default: break;
       }
     }
-  #endif
+    #endif
 
     typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    bool valid;
+    bool                                                 valid;
   };
 
   //***************************************************************************
@@ -4779,20 +4793,20 @@ namespace etl
   {
   public:
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2>;
-  #endif
+    #endif
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     ETL_CONSTEXPR message_packet() ETL_NOEXCEPT
       : valid(false)
     {
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(const etl::imessage& msg)
     {
       if (accepts(msg))
@@ -4807,11 +4821,11 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(etl::imessage&& msg)
     {
       if (accepts(msg))
@@ -4826,47 +4840,49 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2> >::value &&
-                                                                    !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                    !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2>::value, int>::type>
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2> >::value
+                                                                      && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                      && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2>::value,
+                                                                    int>::type>
     explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2> >::value &&
-                                       !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                       etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2>::value);
+      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2> >::value
+                                       && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                       && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #else
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      #include "private/diagnostic_pop.h"
+    #else
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     template <typename TMessage>
-    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2> >::value &&
-                                                                         !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                         !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2>::value, int>::type = 0)
+    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2> >::value
+                                                                               && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                               && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2>::value,
+                                                                             int>::type = 0)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2> >::value &&
-                                   !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                   etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2>::value);
+      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2> >::value
+                                   && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                   && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     message_packet(const message_packet& other)
       : valid(other.is_valid())
     {
@@ -4875,11 +4891,11 @@ namespace etl
         add_new_message(other.get());
       }
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     message_packet(message_packet&& other)
       : valid(other.is_valid())
     {
@@ -4888,12 +4904,12 @@ namespace etl
         add_new_message(etl::move(other.get()));
       }
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -4904,12 +4920,12 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& rhs)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -4920,8 +4936,8 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
     //********************************************
     ~message_packet()
@@ -4969,7 +4985,7 @@ namespace etl
     //**********************************************
     template <typename TMessage>
     static ETL_CONSTEXPR
-    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
+      typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
       accepts()
     {
       return T1::ID == TMessage::ID || T2::ID == TMessage::ID;
@@ -4991,12 +5007,11 @@ namespace etl
       {
         etl::imessage* pmsg = static_cast<etl::imessage*>(data);
 
-
-  #if ETL_HAS_VIRTUAL_MESSAGES
+    #if ETL_HAS_VIRTUAL_MESSAGES
         pmsg->~imessage();
-  #else
+    #else
         delete_message(pmsg);
-  #endif
+    #endif
       }
     }
     #include "private/diagnostic_pop.h"
@@ -5016,7 +5031,7 @@ namespace etl
     void add_new_message(const etl::imessage& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -5026,12 +5041,12 @@ namespace etl
       }
     }
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
     //********************************************
     void add_new_message(etl::imessage&& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -5040,10 +5055,10 @@ namespace etl
         default: break;
       }
     }
-  #endif
+    #endif
 
     typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    bool valid;
+    bool                                                 valid;
   };
 
   //***************************************************************************
@@ -5054,20 +5069,20 @@ namespace etl
   {
   public:
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1>;
-  #endif
+    #endif
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     ETL_CONSTEXPR message_packet() ETL_NOEXCEPT
       : valid(false)
     {
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(const etl::imessage& msg)
     {
       if (accepts(msg))
@@ -5082,11 +5097,11 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     explicit message_packet(etl::imessage&& msg)
     {
       if (accepts(msg))
@@ -5101,47 +5116,49 @@ namespace etl
 
       ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1> >::value &&
-                                                                    !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                    !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1>::value, int>::type>
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1> >::value
+                                                                      && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                      && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1>::value,
+                                                                    int>::type>
     explicit message_packet(TMessage&& /*msg*/)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1> >::value &&
-                                       !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                       etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1>::value);
+      static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1> >::value
+                                       && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                       && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #else
-    //********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      #include "private/diagnostic_pop.h"
+    #else
+        //********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     template <typename TMessage>
-    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1> >::value &&
-                                                                         !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                                                         !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1>::value, int>::type = 0)
+    explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1> >::value
+                                                                               && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                                                               && !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1>::value,
+                                                                             int>::type = 0)
       : valid(true)
     {
       // Not etl::message_packet, not etl::imessage and in typelist.
-      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1> >::value &&
-                                   !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
-                                   etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1>::value);
+      static const bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1> >::value
+                                   && !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value
+                                   && etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1>::value);
 
       ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
     message_packet(const message_packet& other)
       : valid(other.is_valid())
     {
@@ -5150,11 +5167,11 @@ namespace etl
         add_new_message(other.get());
       }
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
     message_packet(message_packet&& other)
       : valid(other.is_valid())
     {
@@ -5163,12 +5180,12 @@ namespace etl
         add_new_message(etl::move(other.get()));
       }
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(const message_packet& rhs)
+      //**********************************************
+    #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(const message_packet& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -5179,12 +5196,12 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
+    #include "private/diagnostic_pop.h"
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
-    //**********************************************
-  #include "private/diagnostic_uninitialized_push.h"
-    message_packet& operator =(message_packet&& rhs)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+        //**********************************************
+      #include "private/diagnostic_uninitialized_push.h"
+    message_packet& operator=(message_packet&& rhs)
     {
       delete_current_message();
       valid = rhs.is_valid();
@@ -5195,8 +5212,8 @@ namespace etl
 
       return *this;
     }
-  #include "private/diagnostic_pop.h"
-  #endif
+      #include "private/diagnostic_pop.h"
+    #endif
 
     //********************************************
     ~message_packet()
@@ -5244,7 +5261,7 @@ namespace etl
     //**********************************************
     template <typename TMessage>
     static ETL_CONSTEXPR
-    typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
+      typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
       accepts()
     {
       return T1::ID == TMessage::ID;
@@ -5266,12 +5283,11 @@ namespace etl
       {
         etl::imessage* pmsg = static_cast<etl::imessage*>(data);
 
-
-  #if ETL_HAS_VIRTUAL_MESSAGES
+    #if ETL_HAS_VIRTUAL_MESSAGES
         pmsg->~imessage();
-  #else
+    #else
         delete_message(pmsg);
-  #endif
+    #endif
       }
     }
     #include "private/diagnostic_pop.h"
@@ -5290,7 +5306,7 @@ namespace etl
     void add_new_message(const etl::imessage& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -5299,12 +5315,12 @@ namespace etl
       }
     }
 
-  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
+    #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
     //********************************************
     void add_new_message(etl::imessage&& msg)
     {
       const size_t id = msg.get_message_id();
-      void* p = data;
+      void*        p  = data;
 
       switch (id)
       {
@@ -5312,10 +5328,10 @@ namespace etl
         default: break;
       }
     }
-  #endif
+    #endif
 
     typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
-    bool valid;
+    bool                                                 valid;
   };
 
   //***************************************************************************
@@ -5327,9 +5343,9 @@ namespace etl
   {
   public:
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<>;
-#endif
+    #endif
 
     ETL_CONSTEXPR message_packet() ETL_NOEXCEPT
       : valid(false)
@@ -5365,7 +5381,7 @@ namespace etl
 
     enum
     {
-      SIZE = 0U,
+      SIZE      = 0U,
       ALIGNMENT = 1U
     };
 
@@ -5373,7 +5389,7 @@ namespace etl
 
     bool valid;
   };
-#endif
-}
+  #endif
+} // namespace etl
 
 #endif
diff --git a/include/etl/message_router.h b/include/etl/message_router.h
index e9b79d30..2670b6f7 100644
--- a/include/etl/message_router.h
+++ b/include/etl/message_router.h
@@ -27,7 +27,7 @@ SOFTWARE.
 ******************************************************************************/
 
 #if 0
-#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+  #error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
 #endif
 
 //***************************************************************************
@@ -49,25 +49,25 @@ SOFTWARE.
 //***************************************************************************
 
 #ifndef ETL_MESSAGE_ROUTER_INCLUDED
-#define ETL_MESSAGE_ROUTER_INCLUDED
+  #define ETL_MESSAGE_ROUTER_INCLUDED
 
-#include "platform.h"
-#include "message.h"
-#include "shared_message.h"
-#include "message_packet.h"
-#include "message_types.h"
-#include "alignment.h"
-#include "error_handler.h"
-#include "exception.h"
-#include "largest.h"
-#include "nullptr.h"
-#include "placement_new.h"
-#include "successor.h"
-#include "type_traits.h"
-#include "type_list.h"
-#include "array.h"
+  #include "platform.h"
+  #include "alignment.h"
+  #include "array.h"
+  #include "error_handler.h"
+  #include "exception.h"
+  #include "largest.h"
+  #include "message.h"
+  #include "message_packet.h"
+  #include "message_types.h"
+  #include "nullptr.h"
+  #include "placement_new.h"
+  #include "shared_message.h"
+  #include "successor.h"
+  #include "type_list.h"
+  #include "type_traits.h"
 
-#include <stdint.h>
+  #include <stdint.h>
 
 namespace etl
 {
@@ -108,7 +108,8 @@ namespace etl
     template <typename... TMessageTypes>
     class traits
     {
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
+
     private:
 
       using message_id_sequence = etl::index_sequence<TMessageTypes::ID...>;
@@ -119,10 +120,10 @@ namespace etl
       using message_types        = etl::type_list<TMessageTypes...>;
       using sorted_message_types = etl::type_list_sort_t<message_types, etl::compare_message_id_less>;
 
-      static_assert(etl::type_list_is_unique<message_types>::value,                    "All TMessageTypes must be unique");
+      static_assert(etl::type_list_is_unique<message_types>::value, "All TMessageTypes must be unique");
       static_assert(etl::type_list_all_of<message_types, etl::is_message_type>::value, "All TMessageTypes must satisfy the condition etl::is_message_type");
-      static_assert(etl::index_sequence_is_unique<message_id_sequence>::value,         "All message IDs must be unique");
-#endif
+      static_assert(etl::index_sequence_is_unique<message_id_sequence>::value, "All message IDs must be unique");
+  #endif
     };
 
     //***************************************************************************
@@ -136,13 +137,13 @@ namespace etl
     {
     public:
 
-#if ETL_USING_CPP11
-      using message_packet = etl::message_packet<>;
-      using message_types = etl::type_list<>;
+  #if ETL_USING_CPP11
+      using message_packet       = etl::message_packet<>;
+      using message_types        = etl::type_list<>;
       using sorted_message_types = etl::type_list<>;
-#endif
+  #endif
     };
-  }
+  } // namespace private_message_router
 
   //***************************************************************************
   /// Forward declare null message router functionality.
@@ -159,11 +160,11 @@ namespace etl
   public:
 
     virtual ~imessage_router() {}
-    virtual void receive(const etl::imessage&) = 0;
+    virtual void receive(const etl::imessage&)    = 0;
     virtual bool accepts(etl::message_id_t) const = 0;
-    virtual bool is_null_router() const = 0;
-    virtual bool is_producer() const = 0;
-    virtual bool is_consumer() const = 0;
+    virtual bool is_null_router() const           = 0;
+    virtual bool is_producer() const              = 0;
+    virtual bool is_consumer() const              = 0;
 
     //********************************************
     virtual void receive(etl::message_router_id_t destination_router_id, const etl::imessage& message)
@@ -228,16 +229,16 @@ namespace etl
 
     // Disabled.
     imessage_router(const imessage_router&);
-    imessage_router& operator =(const imessage_router&);
+    imessage_router& operator=(const imessage_router&);
 
-    etl::message_router_id_t  message_router_id;
+    etl::message_router_id_t message_router_id;
   };
 
   //***************************************************************************
   /// This router can be used as a sink for messages or a 'null source' router.
   //***************************************************************************
   class null_message_router : public imessage_router
-                            , public private_message_router::traits<>
+    , public private_message_router::traits<>
   {
   public:
 
@@ -316,7 +317,7 @@ namespace etl
   /// This router can be used as a producer-only of messages, such an interrupt routine.
   //***************************************************************************
   class message_producer : public imessage_router
-                         , public private_message_router::traits<>
+    , public private_message_router::traits<>
   {
   public:
 
@@ -404,7 +405,7 @@ namespace etl
   //***************************************************************************
   template <typename TRouter, typename TMessage>
   static
-  typename etl::enable_if<etl::is_message_router<TRouter>::value && etl::is_message<TMessage>::value, void>::type
+    typename etl::enable_if<etl::is_message_router<TRouter>::value && etl::is_message<TMessage>::value, void>::type
     send_message(TRouter&        destination,
                  const TMessage& message)
   {
@@ -416,7 +417,7 @@ namespace etl
   //***************************************************************************
   template <typename TRouter>
   static
-  typename etl::enable_if<etl::is_message_router<TRouter>::value, void>::type
+    typename etl::enable_if<etl::is_message_router<TRouter>::value, void>::type
     send_message(TRouter&            destination,
                  etl::shared_message message)
   {
@@ -428,7 +429,7 @@ namespace etl
   //***************************************************************************
   template <typename TRouter, typename TMessage>
   static
-  typename etl::enable_if<etl::is_message_router<TRouter>::value && etl::is_message<TMessage>::value, void>::type
+    typename etl::enable_if<etl::is_message_router<TRouter>::value && etl::is_message<TMessage>::value, void>::type
     send_message(TRouter&                 destination,
                  etl::message_router_id_t id,
                  const TMessage&          message)
@@ -441,7 +442,7 @@ namespace etl
   //***************************************************************************
   template <typename TRouter>
   static
-  typename etl::enable_if<etl::is_message_router<TRouter>::value, void>::type
+    typename etl::enable_if<etl::is_message_router<TRouter>::value, void>::type
     send_message(TRouter&                 destination,
                  etl::message_router_id_t id,
                  etl::shared_message      message)
@@ -452,13 +453,13 @@ namespace etl
   //*************************************************************************************************
   // For C++11 and above.
   //*************************************************************************************************
-#if ETL_USING_CPP11 && !defined(ETL_MESSAGE_ROUTER_FORCE_CPP03_IMPLEMENTATION)
+  #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_ROUTER_FORCE_CPP03_IMPLEMENTATION)
   //***************************************************************************
   // The definition for all message types.
   //***************************************************************************
   template <typename TDerived, typename... TMessageTypes>
   class message_router : public imessage_router
-                       , public private_message_router::traits<TMessageTypes...>
+    , public private_message_router::traits<TMessageTypes...>
   {
   public:
 
@@ -513,8 +514,8 @@ namespace etl
     //***********************************************
     void receive(const etl::imessage& msg) ETL_OVERRIDE
     {
-      etl::message_id_t id = msg.get_message_id();
-      size_t index = Number_Of_Messages;
+      etl::message_id_t id    = msg.get_message_id();
+      size_t            index = Number_Of_Messages;
 
       // The IDs are sorted, so an ID less than the first is not handled by this router.
       if (id >= Message_Id_Start)
@@ -536,9 +537,9 @@ namespace etl
         }
         else
         {
-#include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
           static_cast<TDerived*>(this)->on_receive_unknown(msg);
-#include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
         }
       }
     }
@@ -552,9 +553,9 @@ namespace etl
     template <typename TMessage, typename etl::enable_if<etl::is_one_of<TMessage, TMessageTypes...>::value, int>::type = 0>
     void receive(const TMessage& msg)
     {
-#include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
-#include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     //**********************************************
@@ -563,8 +564,7 @@ namespace etl
     /// \param msg The message.
     /// Enabled if TMessage is a message type, but not in the message type list.
     //**********************************************
-    template <typename TMessage, typename etl::enable_if<etl::is_message<TMessage>::value &&
-                                                         !etl::is_one_of<TMessage, TMessageTypes...>::value, int>::type = 0>
+    template <typename TMessage, typename etl::enable_if<etl::is_message<TMessage>::value && !etl::is_one_of<TMessage, TMessageTypes...>::value, int>::type = 0>
     void receive(const TMessage& msg)
     {
       if (has_successor())
@@ -573,9 +573,9 @@ namespace etl
       }
       else
       {
-#include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
-#include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
       }
     }
 
@@ -650,9 +650,7 @@ namespace etl
 
     template <size_t Index>
     struct contiguous_impl<Index, false>
-      : etl::bool_constant<(etl::type_list_type_at_index_t<sorted_message_types, Index>::ID + 1U ==
-                            etl::type_list_type_at_index_t<sorted_message_types, Index + 1U>::ID) &&
-                            contiguous_impl<Index + 1U>::value>
+      : etl::bool_constant<(etl::type_list_type_at_index_t<sorted_message_types, Index>::ID + 1U == etl::type_list_type_at_index_t<sorted_message_types, Index + 1U>::ID) && contiguous_impl<Index + 1U>::value>
     {
     };
 
@@ -689,7 +687,7 @@ namespace etl
     template <size_t... Indices>
     static constexpr message_dispatch_table_t make_message_dispatch_table(etl::index_sequence<Indices...>)
     {
-      return message_dispatch_table_t{ { get_message_handler<Indices>()... } };
+      return message_dispatch_table_t{{get_message_handler<Indices>()...}};
     }
 
     //**********************************************
@@ -709,7 +707,7 @@ namespace etl
     template <size_t... Indices>
     static constexpr message_id_table_t make_message_id_table(etl::index_sequence<Indices...>)
     {
-      return message_id_table_t{ { get_message_id_from_index<Indices>()... } };
+      return message_id_table_t{{get_message_id_from_index<Indices>()...}};
     }
 
     //**********************************************
@@ -720,7 +718,7 @@ namespace etl
     //**********************************************
     static size_t get_dispatch_index_from_message_id(etl::message_id_t id)
     {
-      if ETL_IF_CONSTEXPR(Message_Ids_Are_Contiguous)
+      if ETL_IF_CONSTEXPR (Message_Ids_Are_Contiguous)
       {
         // The IDs are contiguous, so we can calculate the index directly.
         return static_cast<size_t>(id - Message_Id_Start);
@@ -774,7 +772,7 @@ namespace etl
       etl::message_router<TDerived, TMessageTypes...>::make_message_id_table(etl::make_index_sequence<etl::message_router<TDerived, TMessageTypes...>::Number_Of_Messages>{});
   };
 
-#if ETL_USING_CPP11 && !ETL_USING_CPP17
+    #if ETL_USING_CPP11 && !ETL_USING_CPP17
   template <typename TDerived, typename... TMessageTypes>
   constexpr const typename etl::message_router<TDerived, TMessageTypes...>::message_dispatch_table_t
     etl::message_router<TDerived, TMessageTypes...>::message_dispatch_table;
@@ -782,14 +780,14 @@ namespace etl
   template <typename TDerived, typename... TMessageTypes>
   constexpr const typename etl::message_router<TDerived, TMessageTypes...>::message_id_table_t
     etl::message_router<TDerived, TMessageTypes...>::message_id_table;
-#endif
+    #endif
 
   //***************************************************************************
   // The definition of a message_router for zero message types.
   //***************************************************************************
   template <typename TDerived>
   class message_router<TDerived> : public imessage_router
-                                 , public private_message_router::traits<>
+    , public private_message_router::traits<>
   {
   public:
 
@@ -838,12 +836,12 @@ namespace etl
     //***********************************************
     void receive(const etl::imessage& msg) ETL_OVERRIDE
     {
-#include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       if (has_successor())
       {
         get_successor().receive(msg);
       }
-#include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     //**********************************************
@@ -900,7 +898,7 @@ namespace etl
   template <typename TDerived, typename TTypeList>
   using message_router_from_type_list_t = typename message_router_from_type_list<TDerived, TTypeList>::type;
 
-#else
+  #else
   //*************************************************************************************************
   // For C++03/98.
   //*************************************************************************************************
@@ -912,15 +910,15 @@ namespace etl
             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_router  : public imessage_router
+  class message_router : public imessage_router
   {
   public:
 
     typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> message_packet;
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>;
-  #endif
+    #endif
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -955,7 +953,7 @@ namespace etl
     {
       const etl::message_id_t id = msg.get_message_id();
 
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -975,28 +973,28 @@ namespace etl
         case T15::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T15&>(msg)); break;
         case T16::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T16&>(msg)); break;
         default:
-        {
-           if (has_successor())
-           {
-             get_successor().receive(msg);
-           }
-           else
-           {
-             static_cast<TDerived*>(this)->on_receive_unknown(msg);
-           }
-           break;
-        }
+          {
+            if (has_successor())
+            {
+              get_successor().receive(msg);
+            }
+            else
+            {
+              static_cast<TDerived*>(this)->on_receive_unknown(msg);
+            }
+            break;
+          }
       }
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_message<TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value, void>::type
       receive(const TMessage& msg)
     {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -1009,9 +1007,9 @@ namespace etl
       }
       else
       {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
       }
     }
 
@@ -1022,20 +1020,34 @@ namespace etl
     {
       switch (id)
       {
-        case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID: case T8::ID:
-        case T9::ID: case T10::ID: case T11::ID: case T12::ID: case T13::ID: case T14::ID: case T15::ID: case T16::ID:
+        case T1::ID:
+        case T2::ID:
+        case T3::ID:
+        case T4::ID:
+        case T5::ID:
+        case T6::ID:
+        case T7::ID:
+        case T8::ID:
+        case T9::ID:
+        case T10::ID:
+        case T11::ID:
+        case T12::ID:
+        case T13::ID:
+        case T14::ID:
+        case T15::ID:
+        case T16::ID:
           return true;
         default:
-        {
-          if (has_successor())
           {
-            return get_successor().accepts(id);
+            if (has_successor())
+            {
+              return get_successor().accepts(id);
+            }
+            else
+            {
+              return false;
+            }
           }
-          else
-          {
-            return false;
-          }
-        }
       }
     }
 
@@ -1067,15 +1079,15 @@ namespace etl
             typename T9, typename T10, typename T11, typename T12,
             typename T13, typename T14, typename T15>
   class message_router<TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, void>
-   : public imessage_router
+    : public imessage_router
   {
   public:
 
-    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,  T15> message_packet;
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> message_packet;
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>;
-  #endif
+    #endif
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -1110,7 +1122,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -1129,28 +1141,28 @@ namespace etl
         case T14::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T14&>(msg)); break;
         case T15::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T15&>(msg)); break;
         default:
-        {
-           if (has_successor())
-           {
-             get_successor().receive(msg);
-           }
-           else
-           {
-             static_cast<TDerived*>(this)->on_receive_unknown(msg);
-           }
-           break;
-        }
+          {
+            if (has_successor())
+            {
+              get_successor().receive(msg);
+            }
+            else
+            {
+              static_cast<TDerived*>(this)->on_receive_unknown(msg);
+            }
+            break;
+          }
       }
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_message<TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value, void>::type
       receive(const TMessage& msg)
     {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -1163,13 +1175,12 @@ namespace etl
       }
       else
       {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
       }
     }
 
-
     //**********************************************
     using imessage_router::accepts;
 
@@ -1177,20 +1188,33 @@ namespace etl
     {
       switch (id)
       {
-        case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID: case T8::ID:
-        case T9::ID: case T10::ID: case T11::ID: case T12::ID: case T13::ID: case T14::ID: case T15::ID:
+        case T1::ID:
+        case T2::ID:
+        case T3::ID:
+        case T4::ID:
+        case T5::ID:
+        case T6::ID:
+        case T7::ID:
+        case T8::ID:
+        case T9::ID:
+        case T10::ID:
+        case T11::ID:
+        case T12::ID:
+        case T13::ID:
+        case T14::ID:
+        case T15::ID:
           return true;
         default:
-        {
-          if (has_successor())
           {
-            return get_successor().accepts(id);
+            if (has_successor())
+            {
+              return get_successor().accepts(id);
+            }
+            else
+            {
+              return false;
+            }
           }
-          else
-          {
-            return false;
-          }
-        }
       }
     }
 
@@ -1222,15 +1246,15 @@ namespace etl
             typename T9, typename T10, typename T11, typename T12,
             typename T13, typename T14>
   class message_router<TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, void, void>
-   : public imessage_router
+    : public imessage_router
   {
   public:
 
-    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,  T14> message_packet;
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> message_packet;
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>;
-  #endif
+    #endif
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -1265,7 +1289,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -1283,28 +1307,28 @@ namespace etl
         case T13::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T13&>(msg)); break;
         case T14::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T14&>(msg)); break;
         default:
-        {
-           if (has_successor())
-           {
-             get_successor().receive(msg);
-           }
-           else
-           {
-             static_cast<TDerived*>(this)->on_receive_unknown(msg);
-           }
-           break;
-        }
+          {
+            if (has_successor())
+            {
+              get_successor().receive(msg);
+            }
+            else
+            {
+              static_cast<TDerived*>(this)->on_receive_unknown(msg);
+            }
+            break;
+          }
       }
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_message<TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value, void>::type
       receive(const TMessage& msg)
     {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -1317,13 +1341,12 @@ namespace etl
       }
       else
       {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
       }
     }
 
-
     //**********************************************
     using imessage_router::accepts;
 
@@ -1331,20 +1354,32 @@ namespace etl
     {
       switch (id)
       {
-        case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID: case T8::ID:
-        case T9::ID: case T10::ID: case T11::ID: case T12::ID: case T13::ID: case T14::ID:
+        case T1::ID:
+        case T2::ID:
+        case T3::ID:
+        case T4::ID:
+        case T5::ID:
+        case T6::ID:
+        case T7::ID:
+        case T8::ID:
+        case T9::ID:
+        case T10::ID:
+        case T11::ID:
+        case T12::ID:
+        case T13::ID:
+        case T14::ID:
           return true;
         default:
-        {
-          if (has_successor())
           {
-            return get_successor().accepts(id);
+            if (has_successor())
+            {
+              return get_successor().accepts(id);
+            }
+            else
+            {
+              return false;
+            }
           }
-          else
-          {
-            return false;
-          }
-        }
       }
     }
 
@@ -1376,15 +1411,15 @@ namespace etl
             typename T9, typename T10, typename T11, typename T12,
             typename T13>
   class message_router<TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, void, void, void>
-   : public imessage_router
+    : public imessage_router
   {
   public:
 
-    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,  T13> message_packet;
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> message_packet;
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>;
-  #endif
+    #endif
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -1419,7 +1454,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -1436,28 +1471,28 @@ namespace etl
         case T12::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T12&>(msg)); break;
         case T13::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T13&>(msg)); break;
         default:
-        {
-           if (has_successor())
-           {
-             get_successor().receive(msg);
-           }
-           else
-           {
-             static_cast<TDerived*>(this)->on_receive_unknown(msg);
-           }
-           break;
-        }
+          {
+            if (has_successor())
+            {
+              get_successor().receive(msg);
+            }
+            else
+            {
+              static_cast<TDerived*>(this)->on_receive_unknown(msg);
+            }
+            break;
+          }
       }
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_message<TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value, void>::type
       receive(const TMessage& msg)
     {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -1470,13 +1505,12 @@ namespace etl
       }
       else
       {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
       }
     }
 
-
     //**********************************************
     using imessage_router::accepts;
 
@@ -1484,20 +1518,31 @@ namespace etl
     {
       switch (id)
       {
-        case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID: case T8::ID:
-        case T9::ID: case T10::ID: case T11::ID: case T12::ID: case T13::ID:
+        case T1::ID:
+        case T2::ID:
+        case T3::ID:
+        case T4::ID:
+        case T5::ID:
+        case T6::ID:
+        case T7::ID:
+        case T8::ID:
+        case T9::ID:
+        case T10::ID:
+        case T11::ID:
+        case T12::ID:
+        case T13::ID:
           return true;
         default:
-        {
-          if (has_successor())
           {
-            return get_successor().accepts(id);
+            if (has_successor())
+            {
+              return get_successor().accepts(id);
+            }
+            else
+            {
+              return false;
+            }
           }
-          else
-          {
-            return false;
-          }
-        }
       }
     }
 
@@ -1528,15 +1573,15 @@ namespace etl
             typename T5, typename T6, typename T7, typename T8,
             typename T9, typename T10, typename T11, typename T12>
   class message_router<TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, void, void, void, void>
-   : public imessage_router
+    : public imessage_router
   {
   public:
 
-    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,  T12> message_packet;
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> message_packet;
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>;
-  #endif
+    #endif
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -1571,7 +1616,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -1587,28 +1632,28 @@ namespace etl
         case T11::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T11&>(msg)); break;
         case T12::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T12&>(msg)); break;
         default:
-        {
-           if (has_successor())
-           {
-             get_successor().receive(msg);
-           }
-           else
-           {
-             static_cast<TDerived*>(this)->on_receive_unknown(msg);
-           }
-           break;
-        }
+          {
+            if (has_successor())
+            {
+              get_successor().receive(msg);
+            }
+            else
+            {
+              static_cast<TDerived*>(this)->on_receive_unknown(msg);
+            }
+            break;
+          }
       }
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_message<TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value, void>::type
       receive(const TMessage& msg)
     {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -1621,13 +1666,12 @@ namespace etl
       }
       else
       {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
       }
     }
 
-
     //**********************************************
     using imessage_router::accepts;
 
@@ -1635,20 +1679,30 @@ namespace etl
     {
       switch (id)
       {
-        case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID: case T8::ID:
-        case T9::ID: case T10::ID: case T11::ID: case T12::ID:
+        case T1::ID:
+        case T2::ID:
+        case T3::ID:
+        case T4::ID:
+        case T5::ID:
+        case T6::ID:
+        case T7::ID:
+        case T8::ID:
+        case T9::ID:
+        case T10::ID:
+        case T11::ID:
+        case T12::ID:
           return true;
         default:
-        {
-          if (has_successor())
           {
-            return get_successor().accepts(id);
+            if (has_successor())
+            {
+              return get_successor().accepts(id);
+            }
+            else
+            {
+              return false;
+            }
           }
-          else
-          {
-            return false;
-          }
-        }
       }
     }
 
@@ -1679,15 +1733,15 @@ namespace etl
             typename T5, typename T6, typename T7, typename T8,
             typename T9, typename T10, typename T11>
   class message_router<TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, void, void, void, void, void>
-   : public imessage_router
+    : public imessage_router
   {
   public:
 
-    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,  T11> message_packet;
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> message_packet;
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>;
-  #endif
+    #endif
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -1722,7 +1776,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -1737,28 +1791,28 @@ namespace etl
         case T10::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T10&>(msg)); break;
         case T11::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T11&>(msg)); break;
         default:
-        {
-           if (has_successor())
-           {
-             get_successor().receive(msg);
-           }
-           else
-           {
-             static_cast<TDerived*>(this)->on_receive_unknown(msg);
-           }
-           break;
-        }
+          {
+            if (has_successor())
+            {
+              get_successor().receive(msg);
+            }
+            else
+            {
+              static_cast<TDerived*>(this)->on_receive_unknown(msg);
+            }
+            break;
+          }
       }
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_message<TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value, void>::type
       receive(const TMessage& msg)
     {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -1771,13 +1825,12 @@ namespace etl
       }
       else
       {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
       }
     }
 
-
     //**********************************************
     using imessage_router::accepts;
 
@@ -1785,20 +1838,29 @@ namespace etl
     {
       switch (id)
       {
-        case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID: case T8::ID:
-        case T9::ID: case T10::ID: case T11::ID:
+        case T1::ID:
+        case T2::ID:
+        case T3::ID:
+        case T4::ID:
+        case T5::ID:
+        case T6::ID:
+        case T7::ID:
+        case T8::ID:
+        case T9::ID:
+        case T10::ID:
+        case T11::ID:
           return true;
         default:
-        {
-          if (has_successor())
           {
-            return get_successor().accepts(id);
+            if (has_successor())
+            {
+              return get_successor().accepts(id);
+            }
+            else
+            {
+              return false;
+            }
           }
-          else
-          {
-            return false;
-          }
-        }
       }
     }
 
@@ -1829,15 +1891,15 @@ namespace etl
             typename T5, typename T6, typename T7, typename T8,
             typename T9, typename T10>
   class message_router<TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, void, void, void, void, void, void>
-   : public imessage_router
+    : public imessage_router
   {
   public:
 
-    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9,  T10> message_packet;
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> message_packet;
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>;
-  #endif
+    #endif
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -1872,7 +1934,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -1886,28 +1948,28 @@ namespace etl
         case T9::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T9&>(msg)); break;
         case T10::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T10&>(msg)); break;
         default:
-        {
-           if (has_successor())
-           {
-             get_successor().receive(msg);
-           }
-           else
-           {
-             static_cast<TDerived*>(this)->on_receive_unknown(msg);
-           }
-           break;
-        }
+          {
+            if (has_successor())
+            {
+              get_successor().receive(msg);
+            }
+            else
+            {
+              static_cast<TDerived*>(this)->on_receive_unknown(msg);
+            }
+            break;
+          }
       }
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_message<TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value, void>::type
       receive(const TMessage& msg)
     {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -1920,13 +1982,12 @@ namespace etl
       }
       else
       {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
       }
     }
 
-
     //**********************************************
     using imessage_router::accepts;
 
@@ -1934,20 +1995,28 @@ namespace etl
     {
       switch (id)
       {
-        case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID: case T8::ID:
-        case T9::ID: case T10::ID:
+        case T1::ID:
+        case T2::ID:
+        case T3::ID:
+        case T4::ID:
+        case T5::ID:
+        case T6::ID:
+        case T7::ID:
+        case T8::ID:
+        case T9::ID:
+        case T10::ID:
           return true;
         default:
-        {
-          if (has_successor())
           {
-            return get_successor().accepts(id);
+            if (has_successor())
+            {
+              return get_successor().accepts(id);
+            }
+            else
+            {
+              return false;
+            }
           }
-          else
-          {
-            return false;
-          }
-        }
       }
     }
 
@@ -1978,15 +2047,15 @@ namespace etl
             typename T5, typename T6, typename T7, typename T8,
             typename T9>
   class message_router<TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, void, void, void, void, void, void, void>
-   : public imessage_router
+    : public imessage_router
   {
   public:
 
-    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8,  T9> message_packet;
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9> message_packet;
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7, T8, T9>;
-  #endif
+    #endif
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -2021,7 +2090,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -2034,28 +2103,28 @@ namespace etl
         case T8::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T8&>(msg)); break;
         case T9::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T9&>(msg)); break;
         default:
-        {
-           if (has_successor())
-           {
-             get_successor().receive(msg);
-           }
-           else
-           {
-             static_cast<TDerived*>(this)->on_receive_unknown(msg);
-           }
-           break;
-        }
+          {
+            if (has_successor())
+            {
+              get_successor().receive(msg);
+            }
+            else
+            {
+              static_cast<TDerived*>(this)->on_receive_unknown(msg);
+            }
+            break;
+          }
       }
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_message<TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9>::value, void>::type
       receive(const TMessage& msg)
     {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -2068,13 +2137,12 @@ namespace etl
       }
       else
       {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
       }
     }
 
-
     //**********************************************
     using imessage_router::accepts;
 
@@ -2082,20 +2150,27 @@ namespace etl
     {
       switch (id)
       {
-        case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID: case T8::ID:
+        case T1::ID:
+        case T2::ID:
+        case T3::ID:
+        case T4::ID:
+        case T5::ID:
+        case T6::ID:
+        case T7::ID:
+        case T8::ID:
         case T9::ID:
           return true;
         default:
-        {
-          if (has_successor())
           {
-            return get_successor().accepts(id);
+            if (has_successor())
+            {
+              return get_successor().accepts(id);
+            }
+            else
+            {
+              return false;
+            }
           }
-          else
-          {
-            return false;
-          }
-        }
       }
     }
 
@@ -2125,15 +2200,15 @@ namespace etl
             typename T1, typename T2, typename T3, typename T4,
             typename T5, typename T6, typename T7, typename T8>
   class message_router<TDerived, T1, T2, T3, T4, T5, T6, T7, T8, void, void, void, void, void, void, void, void>
-   : public imessage_router
+    : public imessage_router
   {
   public:
 
-    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7,  T8> message_packet;
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8> message_packet;
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7, T8>;
-  #endif
+    #endif
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -2168,7 +2243,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -2180,28 +2255,28 @@ namespace etl
         case T7::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T7&>(msg)); break;
         case T8::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T8&>(msg)); break;
         default:
-        {
-           if (has_successor())
-           {
-             get_successor().receive(msg);
-           }
-           else
-           {
-             static_cast<TDerived*>(this)->on_receive_unknown(msg);
-           }
-           break;
-        }
+          {
+            if (has_successor())
+            {
+              get_successor().receive(msg);
+            }
+            else
+            {
+              static_cast<TDerived*>(this)->on_receive_unknown(msg);
+            }
+            break;
+          }
       }
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_message<TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8>::value, void>::type
       receive(const TMessage& msg)
     {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -2214,13 +2289,12 @@ namespace etl
       }
       else
       {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
       }
     }
 
-
     //**********************************************
     using imessage_router::accepts;
 
@@ -2228,20 +2302,26 @@ namespace etl
     {
       switch (id)
       {
-        case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID: case T8::ID:
-
+        case T1::ID:
+        case T2::ID:
+        case T3::ID:
+        case T4::ID:
+        case T5::ID:
+        case T6::ID:
+        case T7::ID:
+        case T8::ID:
           return true;
         default:
-        {
-          if (has_successor())
           {
-            return get_successor().accepts(id);
+            if (has_successor())
+            {
+              return get_successor().accepts(id);
+            }
+            else
+            {
+              return false;
+            }
           }
-          else
-          {
-            return false;
-          }
-        }
       }
     }
 
@@ -2271,15 +2351,15 @@ namespace etl
             typename T1, typename T2, typename T3, typename T4,
             typename T5, typename T6, typename T7>
   class message_router<TDerived, T1, T2, T3, T4, T5, T6, T7, void, void, void, void, void, void, void, void, void>
-   : public imessage_router
+    : public imessage_router
   {
   public:
 
-    typedef etl::message_packet<T1, T2, T3, T4, T5, T6,  T7> message_packet;
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7> message_packet;
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6, T7>;
-  #endif
+    #endif
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -2314,7 +2394,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -2325,28 +2405,28 @@ namespace etl
         case T6::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T6&>(msg)); break;
         case T7::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T7&>(msg)); break;
         default:
-        {
-           if (has_successor())
-           {
-             get_successor().receive(msg);
-           }
-           else
-           {
-             static_cast<TDerived*>(this)->on_receive_unknown(msg);
-           }
-           break;
-        }
+          {
+            if (has_successor())
+            {
+              get_successor().receive(msg);
+            }
+            else
+            {
+              static_cast<TDerived*>(this)->on_receive_unknown(msg);
+            }
+            break;
+          }
       }
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_message<TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7>::value, void>::type
       receive(const TMessage& msg)
     {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -2359,13 +2439,12 @@ namespace etl
       }
       else
       {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
       }
     }
 
-
     //**********************************************
     using imessage_router::accepts;
 
@@ -2373,19 +2452,25 @@ namespace etl
     {
       switch (id)
       {
-        case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID:
+        case T1::ID:
+        case T2::ID:
+        case T3::ID:
+        case T4::ID:
+        case T5::ID:
+        case T6::ID:
+        case T7::ID:
           return true;
         default:
-        {
-          if (has_successor())
           {
-            return get_successor().accepts(id);
+            if (has_successor())
+            {
+              return get_successor().accepts(id);
+            }
+            else
+            {
+              return false;
+            }
           }
-          else
-          {
-            return false;
-          }
-        }
       }
     }
 
@@ -2415,15 +2500,15 @@ namespace etl
             typename T1, typename T2, typename T3, typename T4,
             typename T5, typename T6>
   class message_router<TDerived, T1, T2, T3, T4, T5, T6, void, void, void, void, void, void, void, void, void, void>
-   : public imessage_router
+    : public imessage_router
   {
   public:
 
-    typedef etl::message_packet<T1, T2, T3, T4, T5,  T6> message_packet;
+    typedef etl::message_packet<T1, T2, T3, T4, T5, T6> message_packet;
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5, T6>;
-  #endif
+    #endif
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -2458,7 +2543,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -2468,28 +2553,28 @@ namespace etl
         case T5::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T5&>(msg)); break;
         case T6::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T6&>(msg)); break;
         default:
-        {
-           if (has_successor())
-           {
-             get_successor().receive(msg);
-           }
-           else
-           {
-             static_cast<TDerived*>(this)->on_receive_unknown(msg);
-           }
-           break;
-        }
+          {
+            if (has_successor())
+            {
+              get_successor().receive(msg);
+            }
+            else
+            {
+              static_cast<TDerived*>(this)->on_receive_unknown(msg);
+            }
+            break;
+          }
       }
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_message<TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6>::value, void>::type
       receive(const TMessage& msg)
     {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -2502,13 +2587,12 @@ namespace etl
       }
       else
       {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
       }
     }
 
-
     //**********************************************
     using imessage_router::accepts;
 
@@ -2516,19 +2600,24 @@ namespace etl
     {
       switch (id)
       {
-        case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID:
+        case T1::ID:
+        case T2::ID:
+        case T3::ID:
+        case T4::ID:
+        case T5::ID:
+        case T6::ID:
           return true;
         default:
-        {
-          if (has_successor())
           {
-            return get_successor().accepts(id);
+            if (has_successor())
+            {
+              return get_successor().accepts(id);
+            }
+            else
+            {
+              return false;
+            }
           }
-          else
-          {
-            return false;
-          }
-        }
       }
     }
 
@@ -2558,15 +2647,15 @@ namespace etl
             typename T1, typename T2, typename T3, typename T4,
             typename T5>
   class message_router<TDerived, T1, T2, T3, T4, T5, void, void, void, void, void, void, void, void, void, void, void>
-   : public imessage_router
+    : public imessage_router
   {
   public:
 
-    typedef etl::message_packet<T1, T2, T3, T4,  T5> message_packet;
+    typedef etl::message_packet<T1, T2, T3, T4, T5> message_packet;
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4, T5>;
-  #endif
+    #endif
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -2601,7 +2690,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -2610,28 +2699,28 @@ namespace etl
         case T4::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T4&>(msg)); break;
         case T5::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T5&>(msg)); break;
         default:
-        {
-           if (has_successor())
-           {
-             get_successor().receive(msg);
-           }
-           else
-           {
-             static_cast<TDerived*>(this)->on_receive_unknown(msg);
-           }
-           break;
-        }
+          {
+            if (has_successor())
+            {
+              get_successor().receive(msg);
+            }
+            else
+            {
+              static_cast<TDerived*>(this)->on_receive_unknown(msg);
+            }
+            break;
+          }
       }
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_message<TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5>::value, void>::type
       receive(const TMessage& msg)
     {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -2644,13 +2733,12 @@ namespace etl
       }
       else
       {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
       }
     }
 
-
     //**********************************************
     using imessage_router::accepts;
 
@@ -2658,19 +2746,23 @@ namespace etl
     {
       switch (id)
       {
-        case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID:
+        case T1::ID:
+        case T2::ID:
+        case T3::ID:
+        case T4::ID:
+        case T5::ID:
           return true;
         default:
-        {
-          if (has_successor())
           {
-            return get_successor().accepts(id);
+            if (has_successor())
+            {
+              return get_successor().accepts(id);
+            }
+            else
+            {
+              return false;
+            }
           }
-          else
-          {
-            return false;
-          }
-        }
       }
     }
 
@@ -2699,15 +2791,15 @@ namespace etl
   template <typename TDerived,
             typename T1, typename T2, typename T3, typename T4>
   class message_router<TDerived, T1, T2, T3, T4, void, void, void, void, void, void, void, void, void, void, void, void>
-   : public imessage_router
+    : public imessage_router
   {
   public:
 
-    typedef etl::message_packet<T1, T2, T3,  T4> message_packet;
+    typedef etl::message_packet<T1, T2, T3, T4> message_packet;
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3, T4>;
-  #endif
+    #endif
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -2742,7 +2834,7 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
@@ -2750,28 +2842,28 @@ namespace etl
         case T3::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T3&>(msg)); break;
         case T4::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T4&>(msg)); break;
         default:
-        {
-           if (has_successor())
-           {
-             get_successor().receive(msg);
-           }
-           else
-           {
-             static_cast<TDerived*>(this)->on_receive_unknown(msg);
-           }
-           break;
-        }
+          {
+            if (has_successor())
+            {
+              get_successor().receive(msg);
+            }
+            else
+            {
+              static_cast<TDerived*>(this)->on_receive_unknown(msg);
+            }
+            break;
+          }
       }
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_message<TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4>::value, void>::type
       receive(const TMessage& msg)
     {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -2784,13 +2876,12 @@ namespace etl
       }
       else
       {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
       }
     }
 
-
     //**********************************************
     using imessage_router::accepts;
 
@@ -2798,19 +2889,22 @@ namespace etl
     {
       switch (id)
       {
-        case T1::ID: case T2::ID: case T3::ID: case T4::ID:
+        case T1::ID:
+        case T2::ID:
+        case T3::ID:
+        case T4::ID:
           return true;
         default:
-        {
-          if (has_successor())
           {
-            return get_successor().accepts(id);
+            if (has_successor())
+            {
+              return get_successor().accepts(id);
+            }
+            else
+            {
+              return false;
+            }
           }
-          else
-          {
-            return false;
-          }
-        }
       }
     }
 
@@ -2839,15 +2933,15 @@ namespace etl
   template <typename TDerived,
             typename T1, typename T2, typename T3>
   class message_router<TDerived, T1, T2, T3, void, void, void, void, void, void, void, void, void, void, void, void, void>
-   : public imessage_router
+    : public imessage_router
   {
   public:
 
-    typedef etl::message_packet<T1, T2,  T3> message_packet;
+    typedef etl::message_packet<T1, T2, T3> message_packet;
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2, T3>;
-  #endif
+    #endif
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -2882,35 +2976,35 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
         case T2::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T2&>(msg)); break;
         case T3::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T3&>(msg)); break;
         default:
-        {
-           if (has_successor())
-           {
-             get_successor().receive(msg);
-           }
-           else
-           {
-             static_cast<TDerived*>(this)->on_receive_unknown(msg);
-           }
-           break;
-        }
+          {
+            if (has_successor())
+            {
+              get_successor().receive(msg);
+            }
+            else
+            {
+              static_cast<TDerived*>(this)->on_receive_unknown(msg);
+            }
+            break;
+          }
       }
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_message<TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3>::value, void>::type
       receive(const TMessage& msg)
     {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -2923,13 +3017,12 @@ namespace etl
       }
       else
       {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
       }
     }
 
-
     //**********************************************
     using imessage_router::accepts;
 
@@ -2937,19 +3030,21 @@ namespace etl
     {
       switch (id)
       {
-        case T1::ID: case T2::ID: case T3::ID:
+        case T1::ID:
+        case T2::ID:
+        case T3::ID:
           return true;
         default:
-        {
-          if (has_successor())
           {
-            return get_successor().accepts(id);
+            if (has_successor())
+            {
+              return get_successor().accepts(id);
+            }
+            else
+            {
+              return false;
+            }
           }
-          else
-          {
-            return false;
-          }
-        }
       }
     }
 
@@ -2978,15 +3073,15 @@ namespace etl
   template <typename TDerived,
             typename T1, typename T2>
   class message_router<TDerived, T1, T2, void, void, void, void, void, void, void, void, void, void, void, void, void, void>
-   : public imessage_router
+    : public imessage_router
   {
   public:
 
-    typedef etl::message_packet<T1,  T2> message_packet;
+    typedef etl::message_packet<T1, T2> message_packet;
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1, T2>;
-  #endif
+    #endif
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -3021,34 +3116,34 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
         case T2::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T2&>(msg)); break;
         default:
-        {
-           if (has_successor())
-           {
-             get_successor().receive(msg);
-           }
-           else
-           {
-             static_cast<TDerived*>(this)->on_receive_unknown(msg);
-           }
-           break;
-        }
+          {
+            if (has_successor())
+            {
+              get_successor().receive(msg);
+            }
+            else
+            {
+              static_cast<TDerived*>(this)->on_receive_unknown(msg);
+            }
+            break;
+          }
       }
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_message<TMessage>::value && etl::is_one_of<TMessage, T1, T2>::value, void>::type
       receive(const TMessage& msg)
     {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -3061,13 +3156,12 @@ namespace etl
       }
       else
       {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
       }
     }
 
-
     //**********************************************
     using imessage_router::accepts;
 
@@ -3075,19 +3169,20 @@ namespace etl
     {
       switch (id)
       {
-        case T1::ID: case T2::ID:
+        case T1::ID:
+        case T2::ID:
           return true;
         default:
-        {
-          if (has_successor())
           {
-            return get_successor().accepts(id);
+            if (has_successor())
+            {
+              return get_successor().accepts(id);
+            }
+            else
+            {
+              return false;
+            }
           }
-          else
-          {
-            return false;
-          }
-        }
       }
     }
 
@@ -3116,15 +3211,15 @@ namespace etl
   template <typename TDerived,
             typename T1>
   class message_router<TDerived, T1, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void>
-   : public imessage_router
+    : public imessage_router
   {
   public:
 
-    typedef etl::message_packet< T1> message_packet;
+    typedef etl::message_packet<T1> message_packet;
 
-  #if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<T1>;
-  #endif
+    #endif
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -3159,33 +3254,33 @@ namespace etl
     {
       const size_t id = msg.get_message_id();
 
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       switch (id)
       {
         case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
         default:
-        {
-           if (has_successor())
-           {
-             get_successor().receive(msg);
-           }
-           else
-           {
-             static_cast<TDerived*>(this)->on_receive_unknown(msg);
-           }
-           break;
-        }
+          {
+            if (has_successor())
+            {
+              get_successor().receive(msg);
+            }
+            else
+            {
+              static_cast<TDerived*>(this)->on_receive_unknown(msg);
+            }
+            break;
+          }
       }
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
     typename etl::enable_if<etl::is_message<TMessage>::value && etl::is_one_of<TMessage, T1>::value, void>::type
       receive(const TMessage& msg)
     {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       static_cast<TDerived*>(this)->on_receive(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     template <typename TMessage>
@@ -3198,13 +3293,12 @@ namespace etl
       }
       else
       {
-  #include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
         static_cast<TDerived*>(this)->on_receive_unknown(msg);
-  #include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
       }
     }
 
-
     //**********************************************
     using imessage_router::accepts;
 
@@ -3215,16 +3309,16 @@ namespace etl
         case T1::ID:
           return true;
         default:
-        {
-          if (has_successor())
           {
-            return get_successor().accepts(id);
+            if (has_successor())
+            {
+              return get_successor().accepts(id);
+            }
+            else
+            {
+              return false;
+            }
           }
-          else
-          {
-            return false;
-          }
-        }
       }
     }
 
@@ -3258,9 +3352,9 @@ namespace etl
 
     typedef etl::message_packet<> message_packet;
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
     using message_types = etl::type_list<>;
-#endif
+    #endif
 
     //**********************************************
     message_router(etl::message_router_id_t id_)
@@ -3293,12 +3387,12 @@ namespace etl
 
     void receive(const etl::imessage& msg) ETL_OVERRIDE
     {
-#include "etl/private/diagnostic_array_bounds_push.h"
+    #include "etl/private/diagnostic_array_bounds_push.h"
       if (has_successor())
       {
         get_successor().receive(msg);
       }
-#include "etl/private/diagnostic_pop.h"
+    #include "etl/private/diagnostic_pop.h"
     }
 
     //**********************************************
@@ -3334,7 +3428,7 @@ namespace etl
       return true;
     }
   };
-#endif
-}
+  #endif
+} // namespace etl
 
 #endif
diff --git a/include/etl/smallest.h b/include/etl/smallest.h
index 635a8edd..de5b427b 100644
--- a/include/etl/smallest.h
+++ b/include/etl/smallest.h
@@ -29,7 +29,7 @@ SOFTWARE.
 ******************************************************************************/
 
 #if 0
-#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+  #error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
 #endif
 
 //***************************************************************************
@@ -51,19 +51,19 @@ SOFTWARE.
 //***************************************************************************
 
 #ifndef ETL_SMALLEST_INCLUDED
-#define ETL_SMALLEST_INCLUDED
+  #define ETL_SMALLEST_INCLUDED
 
-#include "platform.h"
-#include "integral_limits.h"
+  #include "platform.h"
+  #include "integral_limits.h"
 
-#include <stdint.h>
+  #include <stdint.h>
 
 ///\defgroup smallest smallest
 ///\ingroup utilities
 
 namespace etl
 {
-#if ETL_USING_CPP11 && !defined(ETL_SMALLEST_TYPE_FORCE_CPP03_IMPLEMENTATION)
+  #if ETL_USING_CPP11 && !defined(ETL_SMALLEST_TYPE_FORCE_CPP03_IMPLEMENTATION)
   //***************************************************************************
   /// Template to determine the largest type and size.
   /// Defines 'value_type' which is the type of the largest parameter.
@@ -83,9 +83,9 @@ namespace etl
     // Set 'type' to be the smallest of the first parameter and any of the others.
     // This is recursive.
     using type = typename etl::conditional<(etl::size_of<T1>::value < etl::size_of<smallest_other>::value), // Boolean
-                                            T1,                                                             // TrueType
-                                            smallest_other>                                                 // FalseType
-                                            ::type;                                                         // The smallest type of the two.
+                                           T1,                                                              // TrueType
+                                           smallest_other>                                                  // FalseType
+      ::type;                                                                                               // The smallest type of the two.
 
     // The size of the smallest type.
     enum
@@ -110,17 +110,17 @@ namespace etl
     };
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename... T>
   using smallest_type_t = typename smallest_type<T...>::type;
-#endif
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename... T>
   constexpr size_t smallest_type_v = smallest_type<T...>::size;
-#endif
+    #endif
 
-#else
+  #else
   //***************************************************************************
   /// Template to determine the smallest type and size.
   /// Supports up to 16 types.
@@ -128,9 +128,9 @@ namespace etl
   /// Defines 'size' which is the size of the smallest parameter.
   ///\ingroup smallest
   //***************************************************************************
-  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, 
+  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>
   struct smallest_type
   {
@@ -148,7 +148,7 @@ namespace etl
       typedef TrueType type;
     };
 
-    // Specialisation for 'false'. 
+    // Specialisation for 'false'.
     // Defines 'type' as 'FalseType'.
     template <typename TrueType, typename FalseType>
     struct choose_type<false, TrueType, FalseType>
@@ -158,15 +158,15 @@ namespace etl
 
   public:
 
-    // Define 'smallest_other' as 'smallest_type' with all but the first parameter. 
+    // Define 'smallest_other' as 'smallest_type' with all but the first parameter.
     typedef typename smallest_type<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::type smallest_other;
 
     // Set 'type' to be the smallest of the first parameter and any of the others.
     // This is recursive.
     typedef typename choose_type<(sizeof(T1) < sizeof(smallest_other)), // Boolean
-                                  T1,                                   // TrueType
-                                  smallest_other>                       // FalseType
-                                  ::type type;                          // The smallest type of the two.
+                                 T1,                                    // TrueType
+                                 smallest_other>                        // FalseType
+      ::type type;                                                      // The smallest type of the two.
 
     // The size of the smallest type.
     enum
@@ -179,7 +179,7 @@ namespace etl
   // Specialisation for one template parameter.
   //***************************************************************************
   template <typename T1>
-  struct smallest_type<T1,   void, void, void, void, void, void, void, 
+  struct smallest_type<T1, void, void, void, void, void, void, void,
                        void, void, void, void, void, void, void, void>
   {
     typedef T1 type;
@@ -189,7 +189,7 @@ namespace etl
       size = sizeof(type)
     };
   };
-#endif
+  #endif
 
   namespace private_smallest
   {
@@ -226,7 +226,7 @@ namespace etl
       typedef uint_least32_t type;
     };
 
-#if ETL_USING_64BIT_TYPES
+  #if ETL_USING_64BIT_TYPES
     //*************************************************************************
     // Greater than 32 bits.
     //*************************************************************************
@@ -235,7 +235,7 @@ namespace etl
     {
       typedef uint_least64_t type;
     };
-#endif
+  #endif
 
     //*************************************************************************
     // Determine the type to hold the number of bits based on the index.
@@ -270,7 +270,7 @@ namespace etl
       typedef int_least32_t type;
     };
 
-#if ETL_USING_64BIT_TYPES
+  #if ETL_USING_64BIT_TYPES
     //*************************************************************************
     // Greater than 32 bits.
     //*************************************************************************
@@ -279,8 +279,8 @@ namespace etl
     {
       typedef int_least64_t type;
     };
-#endif
-  }
+  #endif
+  } // namespace private_smallest
 
   //***************************************************************************
   /// Template to determine the smallest unsigned int type that can contain a
@@ -294,9 +294,7 @@ namespace etl
   private:
 
     // Determines the index of the best unsigned type for the required number of bits.
-    static ETL_CONSTANT int TYPE_INDEX = ((NBITS >  8) ? 1 : 0) +
-                                         ((NBITS > 16) ? 1 : 0) +
-                                         ((NBITS > 32) ? 1 : 0);
+    static ETL_CONSTANT int TYPE_INDEX = ((NBITS > 8) ? 1 : 0) + ((NBITS > 16) ? 1 : 0) + ((NBITS > 32) ? 1 : 0);
 
   public:
 
@@ -306,10 +304,10 @@ namespace etl
   template <size_t NBITS>
   ETL_CONSTANT int smallest_uint_for_bits<NBITS>::TYPE_INDEX;
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <size_t NBITS>
   using smallest_uint_for_bits_t = typename smallest_uint_for_bits<NBITS>::type;
-#endif
+  #endif
 
   //***************************************************************************
   /// Template to determine the smallest signed int type that can contain a
@@ -323,9 +321,7 @@ namespace etl
   private:
 
     // Determines the index of the best unsigned type for the required number of bits.
-    static ETL_CONSTANT int TYPE_INDEX = ((NBITS >  8) ? 1 : 0) +
-                                         ((NBITS > 16) ? 1 : 0) +
-                                         ((NBITS > 32) ? 1 : 0);
+    static ETL_CONSTANT int TYPE_INDEX = ((NBITS > 8) ? 1 : 0) + ((NBITS > 16) ? 1 : 0) + ((NBITS > 32) ? 1 : 0);
 
   public:
 
@@ -335,10 +331,10 @@ namespace etl
   template <size_t NBITS>
   ETL_CONSTANT int smallest_int_for_bits<NBITS>::TYPE_INDEX;
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <size_t NBITS>
   using smallest_int_for_bits_t = typename smallest_int_for_bits<NBITS>::type;
-#endif
+  #endif
 
   //***************************************************************************
   /// Template to determine the smallest unsigned int type that can contain the
@@ -352,9 +348,7 @@ namespace etl
   private:
 
     // Determines the index of the best unsigned type for the required value.
-    static ETL_CONSTANT int TYPE_INDEX = ((VALUE > UINT_LEAST8_MAX) ? 1 : 0) +
-      ((VALUE > UINT16_MAX) ? 1 : 0) +
-      ((VALUE > UINT32_MAX) ? 1 : 0);
+    static ETL_CONSTANT int TYPE_INDEX = ((VALUE > UINT_LEAST8_MAX) ? 1 : 0) + ((VALUE > UINT16_MAX) ? 1 : 0) + ((VALUE > UINT32_MAX) ? 1 : 0);
 
   public:
 
@@ -364,10 +358,10 @@ namespace etl
   template <uintmax_t VALUE>
   ETL_CONSTANT int smallest_uint_for_value<VALUE>::TYPE_INDEX;
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <uintmax_t VALUE>
   using smallest_uint_for_value_t = typename smallest_uint_for_value<VALUE>::type;
-#endif
+  #endif
 
   //***************************************************************************
   /// Template to determine the smallest int type that can contain the
@@ -381,9 +375,7 @@ namespace etl
   private:
 
     // Determines the index of the best signed type for the required value.
-    static ETL_CONSTANT int TYPE_INDEX = (((VALUE > intmax_t(INT_LEAST8_MAX)) || (VALUE < intmax_t(INT_LEAST8_MIN))) ? 1 : 0) +
-      (((VALUE > intmax_t(INT16_MAX)) || (VALUE < intmax_t(INT16_MIN))) ? 1 : 0) +
-      (((VALUE > intmax_t(INT32_MAX)) || (VALUE < intmax_t(INT32_MIN))) ? 1 : 0);
+    static ETL_CONSTANT int TYPE_INDEX = (((VALUE > intmax_t(INT_LEAST8_MAX)) || (VALUE < intmax_t(INT_LEAST8_MIN))) ? 1 : 0) + (((VALUE > intmax_t(INT16_MAX)) || (VALUE < intmax_t(INT16_MIN))) ? 1 : 0) + (((VALUE > intmax_t(INT32_MAX)) || (VALUE < intmax_t(INT32_MIN))) ? 1 : 0);
 
   public:
 
@@ -393,10 +385,10 @@ namespace etl
   template <intmax_t VALUE>
   ETL_CONSTANT int smallest_int_for_value<VALUE>::TYPE_INDEX;
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <intmax_t VALUE>
   using smallest_int_for_value_t = typename smallest_int_for_value<VALUE>::type;
-#endif
-}
+  #endif
+} // namespace etl
 
 #endif
diff --git a/include/etl/type_lookup.h b/include/etl/type_lookup.h
index 972ca9e1..2cf10197 100644
--- a/include/etl/type_lookup.h
+++ b/include/etl/type_lookup.h
@@ -30,15 +30,15 @@ SOFTWARE.
 #define ETL_TYPE_LOOKUP_INCLUDED
 
 #include "platform.h"
-#include "type_traits.h"
-#include "static_assert.h"
 #include "integral_limits.h"
 #include "null_type.h"
+#include "static_assert.h"
+#include "type_traits.h"
 
 #include <limits.h>
 
 #if 0
-#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+  #error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
 #endif
 
 //***************************************************************************
@@ -73,7 +73,7 @@ namespace etl
 
 #if ETL_USING_CPP11 && !defined(ETL_TYPE_SELECT_FORCE_CPP03_IMPLEMENTATION)
   //***************************************************************************
-  // type_id_lookup 
+  // type_id_lookup
   //***************************************************************************
   template <typename... TTypes>
   struct type_id_lookup
@@ -81,7 +81,9 @@ namespace etl
   private:
 
     // The type for no match.
-    struct nulltype {};
+    struct nulltype
+    {
+    };
 
     // For N type pairs.
     template <size_t Id, typename T1, typename... TRest>
@@ -148,10 +150,10 @@ namespace etl
       static_assert(value != UNKNOWN, "Invalid type");
     };
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
     template <typename T>
     static constexpr size_t id_from_type_v = id_from_type<T>::value;
-#endif
+  #endif
 
     //************************************
     template <typename T>
@@ -159,7 +161,7 @@ namespace etl
     {
       return get_id_from_type<T>();
     }
-     
+
     //************************************
     template <typename T>
     static unsigned int get_id_from_type()
@@ -177,7 +179,9 @@ namespace etl
   private:
 
     // The type for no match.
-    struct nulltype {};
+    struct nulltype
+    {
+    };
 
     template <typename T, typename T1, typename... TRest>
     struct type_from_type_helper
@@ -219,14 +223,14 @@ namespace etl
   // For 16 types.
   //***************************************************************************
   template <typename T1,
-            typename T2 = etl::type_id_pair<etl::null_type<0>, -2>,
-            typename T3 = etl::type_id_pair<etl::null_type<0>, -3>,
-            typename T4 = etl::type_id_pair<etl::null_type<0>, -4>,
-            typename T5 = etl::type_id_pair<etl::null_type<0>, -5>,
-            typename T6 = etl::type_id_pair<etl::null_type<0>, -6>,
-            typename T7 = etl::type_id_pair<etl::null_type<0>, -7>,
-            typename T8 = etl::type_id_pair<etl::null_type<0>, -8>,
-            typename T9 = etl::type_id_pair<etl::null_type<0>, -9>,
+            typename T2  = etl::type_id_pair<etl::null_type<0>, -2>,
+            typename T3  = etl::type_id_pair<etl::null_type<0>, -3>,
+            typename T4  = etl::type_id_pair<etl::null_type<0>, -4>,
+            typename T5  = etl::type_id_pair<etl::null_type<0>, -5>,
+            typename T6  = etl::type_id_pair<etl::null_type<0>, -6>,
+            typename T7  = etl::type_id_pair<etl::null_type<0>, -7>,
+            typename T8  = etl::type_id_pair<etl::null_type<0>, -8>,
+            typename T9  = etl::type_id_pair<etl::null_type<0>, -9>,
             typename T10 = etl::type_id_pair<etl::null_type<0>, -10>,
             typename T11 = etl::type_id_pair<etl::null_type<0>, -11>,
             typename T12 = etl::type_id_pair<etl::null_type<0>, -12>,
@@ -242,7 +246,8 @@ namespace etl
     template <int Id>
     struct type_from_id
     {
-      typedef 
+      // clang-format off
+      typedef
             typename etl::conditional<Id == T1::Id, typename T1::type,
             typename etl::conditional<Id == T2::Id, typename T2::type,
             typename etl::conditional<Id == T3::Id, typename T3::type,
@@ -263,6 +268,7 @@ namespace etl
                               ::type>::type>::type>::type>
                               ::type>::type>::type>::type>
                               ::type>::type>::type>::type type;
+      // clang-format on
 
       ETL_STATIC_ASSERT(!(etl::is_same<etl::null_type<0>, type>::value), "Invalid id");
     };
@@ -278,24 +284,23 @@ namespace etl
     {
       enum
       {
-        value =
-          (unsigned int) etl::is_same<T, typename T1::type>::value ? (unsigned int)T1::Id :
-          (unsigned int) etl::is_same<T, typename T2::type>::value ? (unsigned int)T2::Id :
-          (unsigned int) etl::is_same<T, typename T3::type>::value ? (unsigned int)T3::Id :
-          (unsigned int) etl::is_same<T, typename T4::type>::value ? (unsigned int)T4::Id :
-          (unsigned int) etl::is_same<T, typename T5::type>::value ? (unsigned int)T5::Id :
-          (unsigned int) etl::is_same<T, typename T6::type>::value ? (unsigned int)T6::Id :
-          (unsigned int) etl::is_same<T, typename T7::type>::value ? (unsigned int)T7::Id :
-          (unsigned int) etl::is_same<T, typename T8::type>::value ? (unsigned int)T8::Id :
-          (unsigned int) etl::is_same<T, typename T9::type>::value ? (unsigned int)T9::Id :
-          (unsigned int) etl::is_same<T, typename T10::type>::value ? (unsigned int)T10::Id :
-          (unsigned int) etl::is_same<T, typename T11::type>::value ? (unsigned int)T11::Id :
-          (unsigned int) etl::is_same<T, typename T12::type>::value ? (unsigned int)T12::Id :
-          (unsigned int) etl::is_same<T, typename T13::type>::value ? (unsigned int)T13::Id :
-          (unsigned int) etl::is_same<T, typename T14::type>::value ? (unsigned int)T14::Id :
-          (unsigned int) etl::is_same<T, typename T15::type>::value ? (unsigned int)T15::Id :
-          (unsigned int) etl::is_same<T, typename T16::type>::value ? (unsigned int)T16::Id :
-          (unsigned int) UNKNOWN
+        value = (unsigned int)etl::is_same<T, typename T1::type>::value    ? (unsigned int)T1::Id
+                : (unsigned int)etl::is_same<T, typename T2::type>::value  ? (unsigned int)T2::Id
+                : (unsigned int)etl::is_same<T, typename T3::type>::value  ? (unsigned int)T3::Id
+                : (unsigned int)etl::is_same<T, typename T4::type>::value  ? (unsigned int)T4::Id
+                : (unsigned int)etl::is_same<T, typename T5::type>::value  ? (unsigned int)T5::Id
+                : (unsigned int)etl::is_same<T, typename T6::type>::value  ? (unsigned int)T6::Id
+                : (unsigned int)etl::is_same<T, typename T7::type>::value  ? (unsigned int)T7::Id
+                : (unsigned int)etl::is_same<T, typename T8::type>::value  ? (unsigned int)T8::Id
+                : (unsigned int)etl::is_same<T, typename T9::type>::value  ? (unsigned int)T9::Id
+                : (unsigned int)etl::is_same<T, typename T10::type>::value ? (unsigned int)T10::Id
+                : (unsigned int)etl::is_same<T, typename T11::type>::value ? (unsigned int)T11::Id
+                : (unsigned int)etl::is_same<T, typename T12::type>::value ? (unsigned int)T12::Id
+                : (unsigned int)etl::is_same<T, typename T13::type>::value ? (unsigned int)T13::Id
+                : (unsigned int)etl::is_same<T, typename T14::type>::value ? (unsigned int)T14::Id
+                : (unsigned int)etl::is_same<T, typename T15::type>::value ? (unsigned int)T15::Id
+                : (unsigned int)etl::is_same<T, typename T16::type>::value ? (unsigned int)T16::Id
+                                                                           : (unsigned int)UNKNOWN
       };
 
       ETL_STATIC_ASSERT(((unsigned int)value != (unsigned int)UNKNOWN), "Invalid type");
@@ -320,14 +325,14 @@ namespace etl
   // For 16 types.
   //***************************************************************************
   template <typename T1,
-            typename T2 = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >,
-            typename T3 = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >,
-            typename T4 = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >,
-            typename T5 = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >,
-            typename T6 = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >,
-            typename T7 = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >,
-            typename T8 = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >,
-            typename T9 = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >,
+            typename T2  = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >,
+            typename T3  = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >,
+            typename T4  = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >,
+            typename T5  = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >,
+            typename T6  = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >,
+            typename T7  = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >,
+            typename T8  = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >,
+            typename T9  = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >,
             typename T10 = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >,
             typename T11 = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >,
             typename T12 = etl::type_type_pair<etl::null_type<0>, etl::null_type<0> >,
@@ -340,6 +345,7 @@ namespace etl
   public:
 
     //************************************
+    // clang-format off
     template <typename T>
     struct type_from_type
     {
@@ -365,9 +371,10 @@ namespace etl
 
       ETL_STATIC_ASSERT(!(etl::is_same<etl::null_type<0>, type>::value), "Invalid type");
     };
+    // clang-format on
   };
 
 #endif
-}
+} // namespace etl
 
 #endif
diff --git a/include/etl/type_select.h b/include/etl/type_select.h
index 36b9be0d..1c2fef4d 100644
--- a/include/etl/type_select.h
+++ b/include/etl/type_select.h
@@ -30,12 +30,12 @@ SOFTWARE.
 #define ETL_TYPE_SELECT_INCLUDED
 
 #include "platform.h"
+#include "null_type.h"
 #include "static_assert.h"
 #include "type_traits.h"
-#include "null_type.h"
 
 #if 0
-#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+  #error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
 #endif
 
 //***************************************************************************
@@ -87,7 +87,7 @@ namespace etl
   // Select type alias
   //***************************************************************************
   template <size_t Index, typename... TTypes>
-  using type_select_t = typename etl::type_select<TTypes...>:: template select_t<Index>;
+  using type_select_t = typename etl::type_select<TTypes...>::template select_t<Index>;
 
 #else
 
@@ -95,15 +95,15 @@ namespace etl
   // For 16 types.
   //***************************************************************************
   template <typename T0,
-            typename T1 = void,
-            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 T1  = void,
+            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,
@@ -117,6 +117,7 @@ namespace etl
     template <size_t Id>
     struct select
     {
+      // clang-format off
       typedef typename etl::conditional<Id == 0, T0,
               typename etl::conditional<Id == 1, T1,
               typename etl::conditional<Id == 2, T2,
@@ -136,6 +137,7 @@ namespace etl
               etl::null_type<0> >
               ::type>::type>::type>::type>::type>::type>::type>::type>
               ::type>::type>::type>::type>::type>::type>::type>::type type;
+      // clang-format on
 
       ETL_STATIC_ASSERT(Id < 16, "Invalid Id");
     };
@@ -144,27 +146,29 @@ namespace etl
   //***************************************************************************
   // For 15 types.
   //***************************************************************************
-  template <typename T0, 
-            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, 
+  template <typename T0,
+            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>
   struct type_select<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
   {
   public:
+
     template <size_t Id>
     struct select
     {
+      // clang-format off
       typedef typename etl::conditional<Id == 0, T0,
               typename etl::conditional<Id == 1, T1,
               typename etl::conditional<Id == 2, T2,
@@ -183,6 +187,7 @@ namespace etl
               etl::null_type<0> >
               ::type>::type>::type>::type>::type>::type>::type>::type>
               ::type>::type>::type>::type>::type>::type>::type type;
+      // clang-format on
 
       ETL_STATIC_ASSERT(Id < 15, "Invalid Id");
     };
@@ -191,26 +196,28 @@ namespace etl
   //***************************************************************************
   // For 14 types.
   //***************************************************************************
-  template <typename T0, 
-            typename T1, 
-            typename T2, 
-            typename T3, 
-            typename T4, 
-            typename T5, 
-            typename T6, 
-            typename T7, 
-            typename T8, 
-            typename T9, 
-            typename T10, 
-            typename T11, 
-            typename T12, 
+  template <typename T0,
+            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>
   struct type_select<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
   {
   public:
+
     template <size_t Id>
     struct select
     {
+      // clang-format off
       typedef typename etl::conditional<Id == 0, T0,
               typename etl::conditional<Id == 1, T1,
               typename etl::conditional<Id == 2, T2,
@@ -228,6 +235,7 @@ namespace etl
               etl::null_type<0> >
               ::type>::type>::type>::type>::type>::type>::type>::type>
               ::type>::type>::type>::type>::type>::type type;
+      // clang-format on
 
       ETL_STATIC_ASSERT(Id < 14, "Invalid Id");
     };
@@ -236,25 +244,27 @@ namespace etl
   //***************************************************************************
   // For 13 types.
   //***************************************************************************
-  template <typename T0, 
-            typename T1, 
-            typename T2, 
-            typename T3, 
-            typename T4, 
-            typename T5, 
-            typename T6, 
-            typename T7, 
-            typename T8, 
-            typename T9, 
-            typename T10, 
-            typename T11, 
+  template <typename T0,
+            typename T1,
+            typename T2,
+            typename T3,
+            typename T4,
+            typename T5,
+            typename T6,
+            typename T7,
+            typename T8,
+            typename T9,
+            typename T10,
+            typename T11,
             typename T12>
   struct type_select<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
   {
   public:
+
     template <size_t Id>
     struct select
     {
+      // clang-format off
       typedef typename etl::conditional<Id == 0, T0,
               typename etl::conditional<Id == 1, T1,
               typename etl::conditional<Id == 2, T2,
@@ -271,6 +281,7 @@ namespace etl
               etl::null_type<0> >
               ::type>::type>::type>::type>::type>::type>::type>::type>
               ::type>::type>::type>::type>::type type;
+      // clang-format on
 
       ETL_STATIC_ASSERT(Id < 13, "Invalid Id");
     };
@@ -279,24 +290,26 @@ namespace etl
   //***************************************************************************
   // For 12 types.
   //***************************************************************************
-  template <typename T0, 
-            typename T1, 
-            typename T2, 
-            typename T3, 
-            typename T4, 
-            typename T5, 
-            typename T6, 
-            typename T7, 
-            typename T8, 
-            typename T9, 
-            typename T10, 
+  template <typename T0,
+            typename T1,
+            typename T2,
+            typename T3,
+            typename T4,
+            typename T5,
+            typename T6,
+            typename T7,
+            typename T8,
+            typename T9,
+            typename T10,
             typename T11>
   struct type_select<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
   {
   public:
+
     template <size_t Id>
     struct select
     {
+      // clang-format off
       typedef typename etl::conditional<Id == 0, T0,
               typename etl::conditional<Id == 1, T1,
               typename etl::conditional<Id == 2, T2,
@@ -312,6 +325,7 @@ namespace etl
               etl::null_type<0> >
               ::type>::type>::type>::type>::type>::type>::type>::type>
               ::type>::type>::type>::type type;
+      // clang-format on
 
       ETL_STATIC_ASSERT(Id < 12, "Invalid Id");
     };
@@ -320,23 +334,25 @@ namespace etl
   //***************************************************************************
   // For 11 types.
   //***************************************************************************
-  template <typename T0, 
-            typename T1, 
-            typename T2, 
-            typename T3, 
-            typename T4, 
-            typename T5, 
-            typename T6, 
-            typename T7, 
-            typename T8, 
-            typename T9, 
+  template <typename T0,
+            typename T1,
+            typename T2,
+            typename T3,
+            typename T4,
+            typename T5,
+            typename T6,
+            typename T7,
+            typename T8,
+            typename T9,
             typename T10>
   struct type_select<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
   {
   public:
+
     template <size_t Id>
     struct select
     {
+      // clang-format off
       typedef typename etl::conditional<Id == 0, T0,
               typename etl::conditional<Id == 1, T1,
               typename etl::conditional<Id == 2, T2,
@@ -351,6 +367,7 @@ namespace etl
               etl::null_type<0> >
               ::type>::type>::type>::type>::type>::type>::type>::type>
               ::type>::type>::type type;
+      // clang-format on
 
       ETL_STATIC_ASSERT(Id < 11, "Invalid Id");
     };
@@ -359,22 +376,24 @@ namespace etl
   //***************************************************************************
   // For 10 types.
   //***************************************************************************
-  template <typename T0, 
-            typename T1, 
-            typename T2, 
-            typename T3, 
-            typename T4, 
-            typename T5, 
-            typename T6, 
-            typename T7, 
-            typename T8, 
+  template <typename T0,
+            typename T1,
+            typename T2,
+            typename T3,
+            typename T4,
+            typename T5,
+            typename T6,
+            typename T7,
+            typename T8,
             typename T9>
   struct type_select<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
   {
   public:
+
     template <size_t Id>
     struct select
     {
+      // clang-format off
       typedef typename etl::conditional<Id == 0, T0,
               typename etl::conditional<Id == 1, T1,
               typename etl::conditional<Id == 2, T2,
@@ -388,6 +407,7 @@ namespace etl
               etl::null_type<0> >
               ::type>::type>::type>::type>::type>::type>::type>::type>
               ::type>::type type;
+      // clang-format on
 
       ETL_STATIC_ASSERT(Id < 10, "Invalid Id");
     };
@@ -396,21 +416,23 @@ namespace etl
   //***************************************************************************
   // For 9 types.
   //***************************************************************************
-  template <typename T0, 
-            typename T1, 
-            typename T2, 
-            typename T3, 
-            typename T4, 
-            typename T5, 
-            typename T6, 
-            typename T7, 
+  template <typename T0,
+            typename T1,
+            typename T2,
+            typename T3,
+            typename T4,
+            typename T5,
+            typename T6,
+            typename T7,
             typename T8>
   struct type_select<T0, T1, T2, T3, T4, T5, T6, T7, T8>
   {
   public:
+
     template <size_t Id>
     struct select
     {
+      // clang-format off
       typedef typename etl::conditional<Id == 0, T0,
               typename etl::conditional<Id == 1, T1,
               typename etl::conditional<Id == 2, T2,
@@ -423,6 +445,7 @@ namespace etl
               etl::null_type<0> >
               ::type>::type>::type>::type>::type>::type>::type>::type>
               ::type type;
+      // clang-format on
 
       ETL_STATIC_ASSERT(Id < 9, "Invalid Id");
     };
@@ -431,20 +454,22 @@ namespace etl
   //***************************************************************************
   // For 8 types.
   //***************************************************************************
-  template <typename T0, 
-            typename T1, 
-            typename T2, 
-            typename T3, 
-            typename T4, 
-            typename T5, 
-            typename T6, 
+  template <typename T0,
+            typename T1,
+            typename T2,
+            typename T3,
+            typename T4,
+            typename T5,
+            typename T6,
             typename T7>
   struct type_select<T0, T1, T2, T3, T4, T5, T6, T7>
   {
   public:
+
     template <size_t Id>
     struct select
     {
+      // clang-format off
       typedef typename etl::conditional<Id == 0, T0,
               typename etl::conditional<Id == 1, T1,
               typename etl::conditional<Id == 2, T2,
@@ -455,6 +480,7 @@ namespace etl
               typename etl::conditional<Id == 7, T7,
               etl::null_type<0> >
               ::type>::type>::type>::type>::type>::type>::type>::type type;
+      // clang-format on
 
       ETL_STATIC_ASSERT(Id < 8, "Invalid Id");
     };
@@ -463,19 +489,21 @@ namespace etl
   //***************************************************************************
   // For 7 types.
   //***************************************************************************
-  template <typename T0, 
-            typename T1, 
-            typename T2, 
-            typename T3, 
-            typename T4, 
-            typename T5, 
+  template <typename T0,
+            typename T1,
+            typename T2,
+            typename T3,
+            typename T4,
+            typename T5,
             typename T6>
   struct type_select<T0, T1, T2, T3, T4, T5, T6>
   {
   public:
+
     template <size_t Id>
     struct select
     {
+      // clang-format off
       typedef typename etl::conditional<Id == 0, T0,
               typename etl::conditional<Id == 1, T1,
               typename etl::conditional<Id == 2, T2,
@@ -485,6 +513,7 @@ namespace etl
               typename etl::conditional<Id == 6, T6,
               etl::null_type<0> >
               ::type>::type>::type>::type>::type>::type>::type type;
+      // clang-format on
 
       ETL_STATIC_ASSERT(Id < 7, "Invalid Id");
     };
@@ -493,18 +522,20 @@ namespace etl
   //***************************************************************************
   // For 6 types.
   //***************************************************************************
-  template <typename T0, 
-            typename T1, 
-            typename T2, 
-            typename T3, 
-            typename T4, 
+  template <typename T0,
+            typename T1,
+            typename T2,
+            typename T3,
+            typename T4,
             typename T5>
   struct type_select<T0, T1, T2, T3, T4, T5>
   {
   public:
+
     template <size_t Id>
     struct select
     {
+      // clang-format off
       typedef typename etl::conditional<Id == 0, T0,
               typename etl::conditional<Id == 1, T1,
               typename etl::conditional<Id == 2, T2,
@@ -513,6 +544,7 @@ namespace etl
               typename etl::conditional<Id == 5, T5,
               etl::null_type<0> >
               ::type>::type>::type>::type>::type>::type type;
+      // clang-format on
 
       ETL_STATIC_ASSERT(Id < 6, "Invalid Id");
     };
@@ -521,17 +553,19 @@ namespace etl
   //***************************************************************************
   // For 5 types.
   //***************************************************************************
-  template <typename T0, 
-            typename T1, 
-            typename T2, 
-            typename T3, 
+  template <typename T0,
+            typename T1,
+            typename T2,
+            typename T3,
             typename T4>
   struct type_select<T0, T1, T2, T3, T4>
   {
   public:
+
     template <size_t Id>
     struct select
     {
+      // clang-format off
       typedef typename etl::conditional<Id == 0, T0,
               typename etl::conditional<Id == 1, T1,
               typename etl::conditional<Id == 2, T2,
@@ -539,6 +573,7 @@ namespace etl
               typename etl::conditional<Id == 4, T4,
               etl::null_type<0> >
               ::type>::type>::type>::type>::type type;
+      // clang-format on
 
       ETL_STATIC_ASSERT(Id < 5, "Invalid Id");
     };
@@ -547,22 +582,25 @@ namespace etl
   //***************************************************************************
   // For 4 types.
   //***************************************************************************
-  template <typename T0, 
-            typename T1, 
-            typename T2, 
+  template <typename T0,
+            typename T1,
+            typename T2,
             typename T3>
   struct type_select<T0, T1, T2, T3>
   {
   public:
+
     template <size_t Id>
     struct select
     {
+      // clang-format off
       typedef typename etl::conditional<Id == 0, T0,
               typename etl::conditional<Id == 1, T1,
               typename etl::conditional<Id == 2, T2,
               typename etl::conditional<Id == 3, T3,
               etl::null_type<0> >
               ::type>::type>::type>::type type;
+      // clang-format on
 
       ETL_STATIC_ASSERT(Id < 4, "Invalid Id");
     };
@@ -571,20 +609,23 @@ namespace etl
   //***************************************************************************
   // For 3 types.
   //***************************************************************************
-  template <typename T0, 
-            typename T1, 
+  template <typename T0,
+            typename T1,
             typename T2>
   struct type_select<T0, T1, T2>
   {
   public:
+
     template <size_t Id>
     struct select
     {
+      // clang-format off
       typedef typename etl::conditional<Id == 0, T0,
               typename etl::conditional<Id == 1, T1,
               typename etl::conditional<Id == 2, T2,
               etl::null_type<0> >
               ::type>::type>::type type;
+      // clang-format on
 
       ETL_STATIC_ASSERT(Id < 3, "Invalid Id");
     };
@@ -593,18 +634,21 @@ namespace etl
   //***************************************************************************
   // For 2 types.
   //***************************************************************************
-  template <typename T0, 
+  template <typename T0,
             typename T1>
   struct type_select<T0, T1>
   {
   public:
+
     template <size_t Id>
     struct select
     {
+      // clang-format off
       typedef typename etl::conditional<Id == 0, T0,
               typename etl::conditional<Id == 1, T1,
               etl::null_type<0> >
               ::type>::type type;
+      // clang-format on
 
       ETL_STATIC_ASSERT(Id < 2, "Invalid Id");
     };
@@ -617,17 +661,20 @@ namespace etl
   struct type_select<T0>
   {
   public:
+
     template <size_t Id>
     struct select
     {
+      // clang-format off
       typedef typename etl::conditional<Id == 0, T0,
               etl::null_type<0> >
               ::type type;
+      // clang-format on
 
       ETL_STATIC_ASSERT(Id < 1, "Invalid Id");
     };
   };
 #endif
-}
+} // namespace etl
 
 #endif
diff --git a/include/etl/type_traits.h b/include/etl/type_traits.h
index 524b74eb..20a6cd3e 100644
--- a/include/etl/type_traits.h
+++ b/include/etl/type_traits.h
@@ -29,7 +29,7 @@ SOFTWARE.
 ******************************************************************************/
 
 #if 0
-#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+  #error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
 #endif
 
 //***************************************************************************
@@ -51,32 +51,32 @@ SOFTWARE.
 //***************************************************************************
 
 #ifndef ETL_TYPE_TRAITS_INCLUDED
-#define ETL_TYPE_TRAITS_INCLUDED
+  #define ETL_TYPE_TRAITS_INCLUDED
 
-#include "platform.h"
-#include "nullptr.h"
-#include "static_assert.h"
+  #include "platform.h"
+  #include "nullptr.h"
+  #include "static_assert.h"
 
-#include <stddef.h>
-#include <stdint.h>
+  #include <stddef.h>
+  #include <stdint.h>
 
 ///\defgroup type_traits type_traits
 /// A set of type traits definitions.
 /// Derived from either the standard or alternate definitions, dependent on whether or not ETL_NO_STL is defined.
 /// \ingroup utilities
 
-#if ETL_USING_STL && ETL_USING_CPP11
-  #include <type_traits>
-#endif
+  #if ETL_USING_STL && ETL_USING_CPP11
+    #include <type_traits>
+  #endif
 
 namespace etl
 {
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename...>
   using void_t = void;
-#endif
+  #endif
 
-#if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
+  #if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
 
   //*****************************************************************************
   // Traits are defined by the ETL
@@ -89,7 +89,7 @@ namespace etl
   {
     static const T value = VALUE;
 
-    typedef T value_type;
+    typedef T                           value_type;
     typedef integral_constant<T, VALUE> type;
 
     operator value_type() const
@@ -105,23 +105,25 @@ namespace etl
   template <typename T, T VALUE>
   const T integral_constant<T, VALUE>::value;
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T, T VALUE>
   inline constexpr T integral_constant_v = etl::integral_constant<T, VALUE>::value;
-#endif
+    #endif
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <bool BValue>
   using bool_constant = integral_constant<bool, BValue>;
-#else
+    #else
   template <bool BValue>
-  struct bool_constant : etl::integral_constant<bool, BValue> { };
-#endif
+  struct bool_constant : etl::integral_constant<bool, BValue>
+  {
+  };
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <bool BValue>
   inline constexpr bool bool_constant_v = bool_constant<BValue>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// negation
@@ -130,386 +132,749 @@ namespace etl
   {
   };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool negation_v = negation<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_reference
-  template <typename T> struct remove_reference { typedef T type; };
-  template <typename T> struct remove_reference<T&> { typedef T type; };
-#if ETL_USING_CPP11
-  template <typename T> struct remove_reference<T&&> { typedef T type; };
-#endif
+  template <typename T>
+  struct remove_reference
+  {
+    typedef T type;
+  };
+  template <typename T>
+  struct remove_reference<T&>
+  {
+    typedef T type;
+  };
+    #if ETL_USING_CPP11
+  template <typename T>
+  struct remove_reference<T&&>
+  {
+    typedef T type;
+  };
+    #endif
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_reference_t = typename remove_reference<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_pointer
-  template <typename T> struct remove_pointer { typedef T type; };
-  template <typename T> struct remove_pointer<T*> { typedef T type; };
-  template <typename T> struct remove_pointer<const T*> { typedef const T type; };
-  template <typename T> struct remove_pointer<volatile T*> { typedef volatile T type; };
-  template <typename T> struct remove_pointer<const volatile T*> { typedef const volatile T type; };
-  template <typename T> struct remove_pointer<T* const> { typedef T type; };
-  template <typename T> struct remove_pointer<const T* const> { typedef const T type; };
-  template <typename T> struct remove_pointer<volatile T* const> { typedef volatile T type; };
-  template <typename T> struct remove_pointer<const volatile T* const> { typedef const volatile T type; };
+  template <typename T>
+  struct remove_pointer
+  {
+    typedef T type;
+  };
+  template <typename T>
+  struct remove_pointer<T*>
+  {
+    typedef T type;
+  };
+  template <typename T>
+  struct remove_pointer<const T*>
+  {
+    typedef const T type;
+  };
+  template <typename T>
+  struct remove_pointer<volatile T*>
+  {
+    typedef volatile T type;
+  };
+  template <typename T>
+  struct remove_pointer<const volatile T*>
+  {
+    typedef const volatile T type;
+  };
+  template <typename T>
+  struct remove_pointer<T* const>
+  {
+    typedef T type;
+  };
+  template <typename T>
+  struct remove_pointer<const T* const>
+  {
+    typedef const T type;
+  };
+  template <typename T>
+  struct remove_pointer<volatile T* const>
+  {
+    typedef volatile T type;
+  };
+  template <typename T>
+  struct remove_pointer<const volatile T* const>
+  {
+    typedef const volatile T type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_pointer_t = typename remove_pointer<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_pointer
-  template <typename T> struct add_pointer { typedef typename remove_reference<T>::type* type; };
+  template <typename T>
+  struct add_pointer
+  {
+    typedef typename remove_reference<T>::type* type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_pointer_t = typename add_pointer<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_const
-  template <typename T> struct is_const : false_type {};
-  template <typename T> struct is_const<const T> : true_type {};
-  template <typename T> struct is_const<const volatile T> : true_type {};
+  template <typename T>
+  struct is_const : false_type
+  {
+  };
+  template <typename T>
+  struct is_const<const T> : true_type
+  {
+  };
+  template <typename T>
+  struct is_const<const volatile T> : true_type
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_const_v = is_const<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_const
-  template <typename T> struct remove_const { typedef T type; };
-  template <typename T> struct remove_const<const T> { typedef T type; };
+  template <typename T>
+  struct remove_const
+  {
+    typedef T type;
+  };
+  template <typename T>
+  struct remove_const<const T>
+  {
+    typedef T type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_const_t = typename remove_const<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_const
-  template <typename T> struct add_const { typedef const T type; };
-  template <typename T> struct add_const<const T> { typedef const T type; };
+  template <typename T>
+  struct add_const
+  {
+    typedef const T type;
+  };
+  template <typename T>
+  struct add_const<const T>
+  {
+    typedef const T type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_const_t = typename add_const<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_volatile
-  template <typename T> struct is_volatile : false_type {};
-  template <typename T> struct is_volatile<volatile T> : true_type {};
-  template <typename T> struct is_volatile<const volatile T> : true_type {};
+  template <typename T>
+  struct is_volatile : false_type
+  {
+  };
+  template <typename T>
+  struct is_volatile<volatile T> : true_type
+  {
+  };
+  template <typename T>
+  struct is_volatile<const volatile T> : true_type
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_volatile_v = is_volatile<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_volatile
-  template <typename T> struct remove_volatile { typedef T type; };
-  template <typename T> struct remove_volatile<volatile T> { typedef T type; };
+  template <typename T>
+  struct remove_volatile
+  {
+    typedef T type;
+  };
+  template <typename T>
+  struct remove_volatile<volatile T>
+  {
+    typedef T type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_volatile_t = typename remove_volatile<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_volatile
-  template <typename T> struct add_volatile { typedef volatile T type; };
-  template <typename T> struct add_volatile<volatile T> { typedef volatile T type; };
+  template <typename T>
+  struct add_volatile
+  {
+    typedef volatile T type;
+  };
+  template <typename T>
+  struct add_volatile<volatile T>
+  {
+    typedef volatile T type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_volatile_t = typename add_volatile<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_cv
-  template <typename T> struct remove_cv
+  template <typename T>
+  struct remove_cv
   {
     typedef typename remove_volatile<typename remove_const<T>::type>::type type;
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_cv_t = typename remove_cv<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_cv
-  template <typename T> struct add_cv
+  template <typename T>
+  struct add_cv
   {
     typedef typename add_volatile<typename add_const<T>::type>::type type;
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_cv_t = typename add_cv<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_cvref
-  template <typename T> struct remove_cvref
+  template <typename T>
+  struct remove_cvref
   {
     typedef typename remove_cv<typename remove_reference<T>::type>::type type;
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_cvref_t = typename remove_cvref<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_integral
-  template <typename T> struct is_integral : false_type {};
-  template <> struct is_integral<bool> : true_type {};
-  template <> struct is_integral<char> : true_type {};
-  template <> struct is_integral<unsigned char> : true_type {};
-  template <> struct is_integral<signed char> : true_type {};
-  template <> struct is_integral<wchar_t> : true_type {};
-  template <> struct is_integral<short> : true_type {};
-  template <> struct is_integral<unsigned short> : true_type {};
-  template <> struct is_integral<int> : true_type {};
-  template <> struct is_integral<unsigned int> : true_type {};
-  template <> struct is_integral<long> : true_type {};
-  template <> struct is_integral<unsigned long> : true_type {};
-  template <> struct is_integral<long long> : true_type {};
-  template <> struct is_integral<unsigned long long> : true_type {};
-#if ETL_HAS_NATIVE_CHAR8_T
-  template <> struct is_integral<char8_t> : true_type {};
-#endif
-#if ETL_HAS_NATIVE_CHAR16_T
-  template <> struct is_integral<char16_t> : true_type {};
-#endif
-#if ETL_HAS_NATIVE_CHAR32_T
-  template <> struct is_integral<char32_t> : true_type {};
-#endif
-  template <typename T> struct is_integral<const T> : is_integral<T> {};
-  template <typename T> struct is_integral<volatile T> : is_integral<T> {};
-  template <typename T> struct is_integral<const volatile T> : is_integral<T> {};
+  template <typename T>
+  struct is_integral : false_type
+  {
+  };
+  template <>
+  struct is_integral<bool> : true_type
+  {
+  };
+  template <>
+  struct is_integral<char> : true_type
+  {
+  };
+  template <>
+  struct is_integral<unsigned char> : true_type
+  {
+  };
+  template <>
+  struct is_integral<signed char> : true_type
+  {
+  };
+  template <>
+  struct is_integral<wchar_t> : true_type
+  {
+  };
+  template <>
+  struct is_integral<short> : true_type
+  {
+  };
+  template <>
+  struct is_integral<unsigned short> : true_type
+  {
+  };
+  template <>
+  struct is_integral<int> : true_type
+  {
+  };
+  template <>
+  struct is_integral<unsigned int> : true_type
+  {
+  };
+  template <>
+  struct is_integral<long> : true_type
+  {
+  };
+  template <>
+  struct is_integral<unsigned long> : true_type
+  {
+  };
+  template <>
+  struct is_integral<long long> : true_type
+  {
+  };
+  template <>
+  struct is_integral<unsigned long long> : true_type
+  {
+  };
+    #if ETL_HAS_NATIVE_CHAR8_T
+  template <>
+  struct is_integral<char8_t> : true_type
+  {
+  };
+    #endif
+    #if ETL_HAS_NATIVE_CHAR16_T
+  template <>
+  struct is_integral<char16_t> : true_type
+  {
+  };
+    #endif
+    #if ETL_HAS_NATIVE_CHAR32_T
+  template <>
+  struct is_integral<char32_t> : true_type
+  {
+  };
+    #endif
+  template <typename T>
+  struct is_integral<const T> : is_integral<T>
+  {
+  };
+  template <typename T>
+  struct is_integral<volatile T> : is_integral<T>
+  {
+  };
+  template <typename T>
+  struct is_integral<const volatile T> : is_integral<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_integral_v = is_integral<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_signed
-  template <typename T> struct is_signed : false_type {};
-  template <> struct is_signed<char> : etl::bool_constant<(char(255) < 0)> {};
-  template <> struct is_signed<wchar_t> : public etl::bool_constant<wchar_t(-1) < wchar_t(0)> {};
-  template <> struct is_signed<signed char> : true_type {};
-  template <> struct is_signed<short> : true_type {};
-  template <> struct is_signed<int> : true_type {};
-  template <> struct is_signed<long> : true_type {};
-  template <> struct is_signed<long long> : true_type {};
-  template <> struct is_signed<float> : true_type {};
-  template <> struct is_signed<double> : true_type {};
-  template <> struct is_signed<long double> : true_type {};
-#if ETL_HAS_NATIVE_CHAR8_T
-  template <> struct is_signed<char8_t> : true_type {};
-#endif
-#if ETL_HAS_NATIVE_CHAR16_T
-  template <> struct is_signed<char16_t> : true_type {};
-#endif
-#if ETL_HAS_NATIVE_CHAR32_T
-  template <> struct is_signed<char32_t> : true_type {};
-#endif
-  template <typename T> struct is_signed<const T> : is_signed<T> {};
-  template <typename T> struct is_signed<volatile T> : is_signed<T> {};
-  template <typename T> struct is_signed<const volatile T> : is_signed<T> {};
+  template <typename T>
+  struct is_signed : false_type
+  {
+  };
+  template <>
+  struct is_signed<char> : etl::bool_constant<(char(255) < 0)>
+  {
+  };
+  template <>
+  struct is_signed<wchar_t> : public etl::bool_constant<wchar_t(-1) < wchar_t(0)>
+  {
+  };
+  template <>
+  struct is_signed<signed char> : true_type
+  {
+  };
+  template <>
+  struct is_signed<short> : true_type
+  {
+  };
+  template <>
+  struct is_signed<int> : true_type
+  {
+  };
+  template <>
+  struct is_signed<long> : true_type
+  {
+  };
+  template <>
+  struct is_signed<long long> : true_type
+  {
+  };
+  template <>
+  struct is_signed<float> : true_type
+  {
+  };
+  template <>
+  struct is_signed<double> : true_type
+  {
+  };
+  template <>
+  struct is_signed<long double> : true_type
+  {
+  };
+    #if ETL_HAS_NATIVE_CHAR8_T
+  template <>
+  struct is_signed<char8_t> : true_type
+  {
+  };
+    #endif
+    #if ETL_HAS_NATIVE_CHAR16_T
+  template <>
+  struct is_signed<char16_t> : true_type
+  {
+  };
+    #endif
+    #if ETL_HAS_NATIVE_CHAR32_T
+  template <>
+  struct is_signed<char32_t> : true_type
+  {
+  };
+    #endif
+  template <typename T>
+  struct is_signed<const T> : is_signed<T>
+  {
+  };
+  template <typename T>
+  struct is_signed<volatile T> : is_signed<T>
+  {
+  };
+  template <typename T>
+  struct is_signed<const volatile T> : is_signed<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_signed_v = is_signed<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_unsigned
-  template <typename T> struct is_unsigned : false_type {};
-  template <> struct is_unsigned<bool> : true_type {};
-  template <> struct is_unsigned<char> : etl::bool_constant<(char(255) > 0)> {};
-  template <> struct is_unsigned<unsigned char> : true_type {};
-  template <> struct is_unsigned<wchar_t> : public etl::bool_constant<(wchar_t(-1) > wchar_t(0))> {};
-  template <> struct is_unsigned<unsigned short> : true_type {};
-  template <> struct is_unsigned<unsigned int> : true_type {};
-  template <> struct is_unsigned<unsigned long> : true_type {};
-  template <> struct is_unsigned<unsigned long long> : true_type {};
-  template <typename T> struct is_unsigned<const T> : is_unsigned<T> {};
-  template <typename T> struct is_unsigned<volatile T> : is_unsigned<T> {};
-  template <typename T> struct is_unsigned<const volatile T> : is_unsigned<T> {};
+  template <typename T>
+  struct is_unsigned : false_type
+  {
+  };
+  template <>
+  struct is_unsigned<bool> : true_type
+  {
+  };
+  template <>
+  struct is_unsigned<char> : etl::bool_constant<(char(255) > 0)>
+  {
+  };
+  template <>
+  struct is_unsigned<unsigned char> : true_type
+  {
+  };
+  template <>
+  struct is_unsigned<wchar_t> : public etl::bool_constant<(wchar_t(-1) > wchar_t(0))>{};
+  template <>
+  struct is_unsigned<unsigned short> : true_type
+  {
+  };
+  template <>
+  struct is_unsigned<unsigned int> : true_type
+  {
+  };
+  template <>
+  struct is_unsigned<unsigned long> : true_type
+  {
+  };
+  template <>
+  struct is_unsigned<unsigned long long> : true_type
+  {
+  };
+  template <typename T>
+  struct is_unsigned<const T> : is_unsigned<T>
+  {
+  };
+  template <typename T>
+  struct is_unsigned<volatile T> : is_unsigned<T>
+  {
+  };
+  template <typename T>
+  struct is_unsigned<const volatile T> : is_unsigned<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_unsigned_v = is_unsigned<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_floating_point
-  template <typename T> struct is_floating_point : false_type {};
-  template <> struct is_floating_point<float> : true_type {};
-  template <> struct is_floating_point<double> : true_type {};
-  template <> struct is_floating_point<long double> : true_type {};
-  template <typename T> struct is_floating_point<const T> : is_floating_point<T> {};
-  template <typename T> struct is_floating_point<volatile T> : is_floating_point<T> {};
-  template <typename T> struct is_floating_point<const volatile T> : is_floating_point<T> {};
+  template <typename T>
+  struct is_floating_point : false_type
+  {
+  };
+  template <>
+  struct is_floating_point<float> : true_type
+  {
+  };
+  template <>
+  struct is_floating_point<double> : true_type
+  {
+  };
+  template <>
+  struct is_floating_point<long double> : true_type
+  {
+  };
+  template <typename T>
+  struct is_floating_point<const T> : is_floating_point<T>
+  {
+  };
+  template <typename T>
+  struct is_floating_point<volatile T> : is_floating_point<T>
+  {
+  };
+  template <typename T>
+  struct is_floating_point<const volatile T> : is_floating_point<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_floating_point_v = is_floating_point<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_same
-  template <typename T1, typename T2> struct is_same : public false_type {};
-  template <typename T> struct is_same<T, T> : public true_type {};
+  template <typename T1, typename T2>
+  struct is_same : public false_type
+  {
+  };
+  template <typename T>
+  struct is_same<T, T> : public true_type
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T1, typename T2>
   inline constexpr bool is_same_v = is_same<T1, T2>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_void
-  template<typename T> struct is_void : false_type {};
-  template<> struct is_void<void> : true_type {};
+  template <typename T>
+  struct is_void : false_type
+  {
+  };
+  template <>
+  struct is_void<void> : true_type
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_void_v = is_void<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_arithmetic
-  template<typename T> struct is_arithmetic : etl::bool_constant<is_integral<T>::value || is_floating_point<T>::value> {};
+  template <typename T>
+  struct is_arithmetic : etl::bool_constant<is_integral<T>::value || is_floating_point<T>::value>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_arithmetic_v = is_arithmetic<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_fundamental
-  template <typename T> struct is_fundamental : etl::bool_constant<is_arithmetic<T>::value || is_void<T>::value> {};
+  template <typename T>
+  struct is_fundamental : etl::bool_constant<is_arithmetic<T>::value || is_void<T>::value>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_fundamental_v = is_fundamental<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_compound
-  template <typename T> struct is_compound : etl::bool_constant<!is_fundamental<T>::value> {};
+  template <typename T>
+  struct is_compound : etl::bool_constant<!is_fundamental<T>::value>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_compound_v = is_compound<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_array
-  template <typename T> struct is_array : false_type {};
-  template <typename T> struct is_array<T[]> : true_type {};
-  template <typename T, size_t Size> struct is_array<T[Size]> : true_type {};
+  template <typename T>
+  struct is_array : false_type
+  {
+  };
+  template <typename T>
+  struct is_array<T[]> : true_type
+  {
+  };
+  template <typename T, size_t Size>
+  struct is_array<T[Size]> : true_type
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_array_v = is_array<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_pointer
-  template<typename T> struct is_pointer_helper : false_type {};
-  template<typename T> struct is_pointer_helper<T*> : true_type {};
-  template<typename T> struct is_pointer_helper<const T*> : is_pointer_helper<T*> {};
-  template<typename T> struct is_pointer_helper<volatile T*> : is_pointer_helper<T*> {};
-  template<typename T> struct is_pointer_helper<const volatile T*> : is_pointer_helper<T*> {};
-  template<typename T> struct is_pointer : is_pointer_helper<typename remove_cv<T>::type> {};
+  template <typename T>
+  struct is_pointer_helper : false_type
+  {
+  };
+  template <typename T>
+  struct is_pointer_helper<T*> : true_type
+  {
+  };
+  template <typename T>
+  struct is_pointer_helper<const T*> : is_pointer_helper<T*>
+  {
+  };
+  template <typename T>
+  struct is_pointer_helper<volatile T*> : is_pointer_helper<T*>
+  {
+  };
+  template <typename T>
+  struct is_pointer_helper<const volatile T*> : is_pointer_helper<T*>
+  {
+  };
+  template <typename T>
+  struct is_pointer : is_pointer_helper<typename remove_cv<T>::type>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_pointer_v = is_pointer<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_lvalue_reference
-  template<typename T> struct is_lvalue_reference_helper : false_type {};
-  template<typename T> struct is_lvalue_reference_helper<T&> : true_type {};
-  template<typename T> struct is_lvalue_reference : is_lvalue_reference_helper<typename remove_cv<T>::type> {};
+  template <typename T>
+  struct is_lvalue_reference_helper : false_type
+  {
+  };
+  template <typename T>
+  struct is_lvalue_reference_helper<T&> : true_type
+  {
+  };
+  template <typename T>
+  struct is_lvalue_reference : is_lvalue_reference_helper<typename remove_cv<T>::type>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_lvalue_reference_v = etl::is_lvalue_reference<T>::value;
-#endif
+    #endif
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   //***************************************************************************
   /// is_rvalue_reference
-  template<typename T> struct is_rvalue_reference_helper : false_type {};
-  template<typename T> struct is_rvalue_reference_helper<T&&> : true_type {};
-  template<typename T> struct is_rvalue_reference : is_rvalue_reference_helper<typename remove_cv<T>::type> {};
+  template <typename T>
+  struct is_rvalue_reference_helper : false_type
+  {
+  };
+  template <typename T>
+  struct is_rvalue_reference_helper<T&&> : true_type
+  {
+  };
+  template <typename T>
+  struct is_rvalue_reference : is_rvalue_reference_helper<typename remove_cv<T>::type>
+  {
+  };
 
-#if ETL_USING_CPP17
+      #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_rvalue_reference_v = etl::is_rvalue_reference<T>::value;
-#endif
-#endif
+      #endif
+    #endif
 
   //***************************************************************************
   /// is_reference
   // Either lvalue or rvalue (for CPP11)
-  template<typename T> struct is_reference : integral_constant<bool,
-    is_lvalue_reference<T>::value
+  template <typename T>
+  struct is_reference : integral_constant<bool, is_lvalue_reference<T>::value
     #if ETL_USING_CPP11
-        || is_rvalue_reference<T>::value
+                                                  || is_rvalue_reference<T>::value
     #endif
-  >{};
+                                          >
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_reference_v = is_reference<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_pod
   /// Only fundamental and pointers types are recognised.
-  template <typename T> struct is_pod : etl::bool_constant<etl::is_fundamental<T>::value || etl::is_pointer<T>::value> {};
+  template <typename T>
+  struct is_pod : etl::bool_constant<etl::is_fundamental<T>::value || etl::is_pointer<T>::value>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_pod_v = etl::is_pod<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// conditional
-  template <bool BValue, typename T, typename F>  struct conditional { typedef T type; };
-  template <typename T, typename F> struct conditional<false, T, F> { typedef F type; };
+  template <bool BValue, typename T, typename F>
+  struct conditional
+  {
+    typedef T type;
+  };
+  template <typename T, typename F>
+  struct conditional<false, T, F>
+  {
+    typedef F type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <bool BValue, typename T, typename F>
   using conditional_t = typename conditional<BValue, T, F>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// make_signed
-  template <typename T> struct make_signed { typedef  T type; };
-  template <> struct make_signed<char> { typedef  signed char type; };
-  template <> struct make_signed<unsigned char> { typedef  signed char type; };
+  template <typename T>
+  struct make_signed
+  {
+    typedef T type;
+  };
+  template <>
+  struct make_signed<char>
+  {
+    typedef signed char type;
+  };
+  template <>
+  struct make_signed<unsigned char>
+  {
+    typedef signed char type;
+  };
 
-  template <> struct make_signed<wchar_t>
+  template <>
+  struct make_signed<wchar_t>
   {
     typedef etl::conditional<sizeof(wchar_t) == sizeof(int16_t),
                              int16_t,
@@ -518,27 +883,69 @@ namespace etl
                                               void>::type>::type type;
   };
 
-  template <> struct make_signed<unsigned short> { typedef  short type; };
-  template <> struct make_signed<unsigned int> { typedef int type; };
-  template <> struct make_signed<unsigned long> { typedef  long type; };
-  template <> struct make_signed<unsigned long long> { typedef long long type; };
-  template <typename T> struct make_signed<const T> : add_const<typename make_signed<T>::type> {};
-  template <typename T> struct make_signed<volatile T> : add_volatile<typename make_signed<T>::type> {};
-  template <typename T> struct make_signed<const volatile T> : add_const<typename add_volatile<typename make_signed<T>::type>::type> {};
+  template <>
+  struct make_signed<unsigned short>
+  {
+    typedef short type;
+  };
+  template <>
+  struct make_signed<unsigned int>
+  {
+    typedef int type;
+  };
+  template <>
+  struct make_signed<unsigned long>
+  {
+    typedef long type;
+  };
+  template <>
+  struct make_signed<unsigned long long>
+  {
+    typedef long long type;
+  };
+  template <typename T>
+  struct make_signed<const T> : add_const<typename make_signed<T>::type>
+  {
+  };
+  template <typename T>
+  struct make_signed<volatile T> : add_volatile<typename make_signed<T>::type>
+  {
+  };
+  template <typename T>
+  struct make_signed<const volatile T> : add_const<typename add_volatile<typename make_signed<T>::type>::type>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using make_signed_t = typename make_signed<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// make_unsigned
-  template <typename T> struct make_unsigned { typedef  T type; };
-  template <> struct make_unsigned<char> { typedef unsigned char type; };
-  template <> struct make_unsigned<signed char> { typedef unsigned char type; };
-  template <> struct make_unsigned<short> { typedef unsigned short type; };
+  template <typename T>
+  struct make_unsigned
+  {
+    typedef T type;
+  };
+  template <>
+  struct make_unsigned<char>
+  {
+    typedef unsigned char type;
+  };
+  template <>
+  struct make_unsigned<signed char>
+  {
+    typedef unsigned char type;
+  };
+  template <>
+  struct make_unsigned<short>
+  {
+    typedef unsigned short type;
+  };
 
-  template <> struct make_unsigned<wchar_t>
+  template <>
+  struct make_unsigned<wchar_t>
   {
     typedef etl::conditional<sizeof(wchar_t) == sizeof(uint16_t),
                              uint16_t,
@@ -547,150 +954,231 @@ namespace etl
                                               void>::type>::type type;
   };
 
-  template <> struct make_unsigned<int> { typedef unsigned int type; };
-  template <> struct make_unsigned<long> { typedef unsigned long type; };
-  template <> struct make_unsigned<long long> { typedef unsigned long long type; };
-  template <typename T> struct make_unsigned<const T> : add_const<typename make_unsigned<T>::type> {};
-  template <typename T> struct make_unsigned<volatile T> : add_volatile<typename make_unsigned<T>::type> {};
-  template <typename T> struct make_unsigned<const volatile T> : add_const<typename add_volatile<typename make_unsigned<T>::type>::type> {};
+  template <>
+  struct make_unsigned<int>
+  {
+    typedef unsigned int type;
+  };
+  template <>
+  struct make_unsigned<long>
+  {
+    typedef unsigned long type;
+  };
+  template <>
+  struct make_unsigned<long long>
+  {
+    typedef unsigned long long type;
+  };
+  template <typename T>
+  struct make_unsigned<const T> : add_const<typename make_unsigned<T>::type>
+  {
+  };
+  template <typename T>
+  struct make_unsigned<volatile T> : add_volatile<typename make_unsigned<T>::type>
+  {
+  };
+  template <typename T>
+  struct make_unsigned<const volatile T> : add_const<typename add_volatile<typename make_unsigned<T>::type>::type>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using make_unsigned_t = typename make_unsigned<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// enable_if
-  template <bool BValue, typename T = void> struct enable_if {};
-  template <typename T> struct enable_if<true, T> { typedef T type; };
+  template <bool BValue, typename T = void>
+  struct enable_if
+  {
+  };
+  template <typename T>
+  struct enable_if<true, T>
+  {
+    typedef T type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <bool BValue, typename T = void>
   using enable_if_t = typename enable_if<BValue, T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// extent
   template <typename T, unsigned Size = 0U>
-  struct extent : integral_constant<size_t, 0U> {};
+  struct extent : integral_constant<size_t, 0U>
+  {
+  };
 
   template <typename T>
-  struct extent<T[], 0> : integral_constant<size_t, 0U> {};
+  struct extent<T[], 0> : integral_constant<size_t, 0U>
+  {
+  };
 
   template <typename T, unsigned Size>
-  struct extent<T[], Size> : integral_constant<size_t, extent<T, Size - 1>::value> {};
+  struct extent<T[], Size> : integral_constant<size_t, extent<T, Size - 1>::value>
+  {
+  };
 
   template <typename T, unsigned Size>
-  struct extent<T[Size], 0> : integral_constant<size_t, Size> {};
+  struct extent<T[Size], 0> : integral_constant<size_t, Size>
+  {
+  };
 
   template <typename T, unsigned I, unsigned Size>
-  struct extent<T[I], Size> : integral_constant<size_t, extent<T, Size - 1>::value> {};
+  struct extent<T[I], Size> : integral_constant<size_t, extent<T, Size - 1>::value>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T, unsigned Size = 0U>
   inline constexpr size_t extent_v = extent<T, Size>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_extent
-  template <typename T> struct remove_extent { typedef T type; };
-  template <typename T> struct remove_extent<T[]> { typedef T type; };
-  template <typename T, size_t Size> struct remove_extent<T[Size]> { typedef T type; };
+  template <typename T>
+  struct remove_extent
+  {
+    typedef T type;
+  };
+  template <typename T>
+  struct remove_extent<T[]>
+  {
+    typedef T type;
+  };
+  template <typename T, size_t Size>
+  struct remove_extent<T[Size]>
+  {
+    typedef T type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_extent_t = typename remove_extent<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_all_extents
-  template <typename T> struct remove_all_extents { typedef T type; };
-  template <typename T> struct remove_all_extents<T[]> { typedef typename remove_all_extents<T>::type type; };
-  template <typename T, size_t Size> struct remove_all_extents<T[Size]> { typedef typename remove_all_extents<T>::type type; };
+  template <typename T>
+  struct remove_all_extents
+  {
+    typedef T type;
+  };
+  template <typename T>
+  struct remove_all_extents<T[]>
+  {
+    typedef typename remove_all_extents<T>::type type;
+  };
+  template <typename T, size_t Size>
+  struct remove_all_extents<T[Size]>
+  {
+    typedef typename remove_all_extents<T>::type type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_all_extents_t = typename remove_all_extents<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// rank
-  template <typename T>struct rank : integral_constant<size_t, 0> {};
-  template <typename T> struct rank<T[]> : public integral_constant<size_t, rank<T>::value + 1> {};
-  template <typename T, size_t Size> struct rank<T[Size]> : public integral_constant<size_t, rank<T>::value + 1> {};
+  template <typename T>
+  struct rank : integral_constant<size_t, 0>
+  {
+  };
+  template <typename T>
+  struct rank<T[]> : public integral_constant<size_t, rank<T>::value + 1>
+  {
+  };
+  template <typename T, size_t Size>
+  struct rank<T[Size]> : public integral_constant<size_t, rank<T>::value + 1>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr size_t rank_v = rank<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// decay
   template <typename T>
   struct decay
   {
-    typedef typename etl::remove_reference<T>::type U;
+    typedef typename etl::remove_reference<T>::type                           U;
     typedef typename etl::conditional<etl::is_array<U>::value,
                                       typename etl::remove_extent<U>::type*,
                                       typename etl::remove_cv<U>::type>::type type;
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using decay_t = typename decay<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_class
   namespace private_type_traits
   {
-    template <typename T> char test(int T::*); // Match for classes.
+    template <typename T>
+    char test(int T::*); // Match for classes.
 
-    struct dummy { char c[2]; };
-    template <typename T> dummy test(...);     // Match for non-classes.
-  }
+    struct dummy
+    {
+      char c[2];
+    };
+    template <typename T>
+    dummy test(...); // Match for non-classes.
+  } // namespace private_type_traits
 
   template <typename T>
-  struct is_class : etl::bool_constant<sizeof(private_type_traits::test<T>(0)) == 1U> {};
+  struct is_class : etl::bool_constant<sizeof(private_type_traits::test<T>(0)) == 1U>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_class_v = is_class<T>::value;
-#endif
+    #endif
 
-  //***************************************************************************
-  /// is_base_of
-#if ETL_USING_CPP11
+    //***************************************************************************
+    /// is_base_of
+    #if ETL_USING_CPP11
   namespace private_type_traits
   {
-    template<typename B>
+    template <typename B>
     etl::true_type test_ptr_conv(const volatile B*);
-    template<typename>
+    template <typename>
     etl::false_type test_ptr_conv(const volatile void*);
 
-    template<typename B, typename D>
+    template <typename B, typename D>
     auto test_is_base_of(int) -> decltype(test_ptr_conv<B>(static_cast<D*>(nullptr)));
-    template<typename, typename>
+    template <typename, typename>
     auto test_is_base_of(...) -> etl::true_type; // private or ambiguous base
-  }
+  } // namespace private_type_traits
 
-  template<typename TBase, typename TDerived>
-  struct is_base_of: etl::integral_constant<
-    bool,
-    etl::is_class<TBase>::value &&
-    etl::is_class<TDerived>::value &&
-    decltype(private_type_traits::test_is_base_of<TBase, TDerived>(0))::value
-    > {};
-#else
-  template<typename TBase,
-           typename TDerived,
-           const bool IsFundamental = (etl::is_fundamental<TBase>::value || etl::is_fundamental<TDerived>::value || etl::is_array<TDerived>::value)>
+  template <typename TBase, typename TDerived>
+  struct is_base_of : etl::integral_constant< bool, etl::is_class<TBase>::value && etl::is_class<TDerived>::value&& decltype(private_type_traits::test_is_base_of<TBase, TDerived>(0))::value >
+  {
+  };
+    #else
+  template <typename TBase,
+            typename TDerived,
+            const bool IsFundamental = (etl::is_fundamental<TBase>::value || etl::is_fundamental<TDerived>::value || etl::is_array<TDerived>::value)>
   struct is_base_of
   {
   private:
 
-    static TBase* check(TBase*) { return (TBase*)0; }
-    static char check(...) { return 0; }
+    static TBase* check(TBase*)
+    {
+      return (TBase*)0;
+    }
+    static char check(...)
+    {
+      return 0;
+    }
 
   public:
 
@@ -698,66 +1186,114 @@ namespace etl
   };
 
   // For when TBase or TDerived is a fundamental type.
-  template<typename TBase, typename TDerived>
+  template <typename TBase, typename TDerived>
   struct is_base_of<TBase, TDerived, true>
   {
     static const bool value = false;
   };
-#endif
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T1, typename T2>
   inline constexpr bool is_base_of_v = is_base_of<T1, T2>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_lvalue_reference
-  template <typename T> struct add_lvalue_reference { typedef T& type; };
-  template <typename T> struct add_lvalue_reference<T&> { typedef T& type; };
-  template <>           struct add_lvalue_reference<void> { typedef void type; };
-  template <>           struct add_lvalue_reference<const void> { typedef const void type; };
-  template <>           struct add_lvalue_reference<volatile void> { typedef volatile void type; };
-  template <>           struct add_lvalue_reference<const volatile void> { typedef const volatile void type; };
+  template <typename T>
+  struct add_lvalue_reference
+  {
+    typedef T& type;
+  };
+  template <typename T>
+  struct add_lvalue_reference<T&>
+  {
+    typedef T& type;
+  };
+  template <>
+  struct add_lvalue_reference<void>
+  {
+    typedef void type;
+  };
+  template <>
+  struct add_lvalue_reference<const void>
+  {
+    typedef const void type;
+  };
+  template <>
+  struct add_lvalue_reference<volatile void>
+  {
+    typedef volatile void type;
+  };
+  template <>
+  struct add_lvalue_reference<const volatile void>
+  {
+    typedef const volatile void type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_lvalue_reference_t = typename etl::add_lvalue_reference<T>::type;
-#endif
+    #endif
 
-  //***************************************************************************
-  /// add_rvalue_reference
-#if ETL_USING_CPP11
-  template <typename T> struct add_rvalue_reference { using type = T && ; };
-  template <typename T> struct add_rvalue_reference<T&> { using type = T & ; };
-  template <>           struct add_rvalue_reference<void> { using type = void; };
-  template <>           struct add_rvalue_reference<const void> { using type = const void; };
-  template <>           struct add_rvalue_reference<volatile void> { using type = volatile void; };
-  template <>           struct add_rvalue_reference<const volatile void> { using type = const volatile void; };
-#endif
+    //***************************************************************************
+    /// add_rvalue_reference
+    #if ETL_USING_CPP11
+  template <typename T>
+  struct add_rvalue_reference
+  {
+    using type = T&&;
+  };
+  template <typename T>
+  struct add_rvalue_reference<T&>
+  {
+    using type = T&;
+  };
+  template <>
+  struct add_rvalue_reference<void>
+  {
+    using type = void;
+  };
+  template <>
+  struct add_rvalue_reference<const void>
+  {
+    using type = const void;
+  };
+  template <>
+  struct add_rvalue_reference<volatile void>
+  {
+    using type = volatile void;
+  };
+  template <>
+  struct add_rvalue_reference<const volatile void>
+  {
+    using type = const volatile void;
+  };
+    #endif
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_rvalue_reference_t = typename etl::add_rvalue_reference<T>::type;
-#endif
+    #endif
 
-  //***************************************************************************
-  /// declval
-#if ETL_USING_CPP11
+    //***************************************************************************
+    /// declval
+    #if ETL_USING_CPP11
   template <typename T>
   typename etl::add_rvalue_reference<T>::type declval() ETL_NOEXCEPT;
-#endif
+    #endif
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   //***************************************************************************
   /// is_enum
   ///\ingroup type_traits
   /// Implemented by checking if type is convertible to an integer through static_cast
 
-  namespace private_type_traits 
+  namespace private_type_traits
   {
     // Base case
     template <typename T, typename = int>
-    struct is_convertible_to_int 
+    struct is_convertible_to_int
       : false_type
     {
     };
@@ -766,86 +1302,82 @@ namespace etl
     // 2nd template argument of base case defaults to int to ensure that this partial specialization is always tried first
     template <typename T>
     struct is_convertible_to_int<T, decltype(static_cast<int>(declval<T>()))>
-      : true_type 
+      : true_type
     {
     };
-  }
+  } // namespace private_type_traits
 
   template <typename T>
   struct is_enum
-    : integral_constant<bool, private_type_traits::is_convertible_to_int<T>::value &&
-                              !is_class<T>::value &&
-                              !is_arithmetic<T>::value &&
-                              !is_reference<T>::value> 
+    : integral_constant<bool, private_type_traits::is_convertible_to_int<T>::value && !is_class<T>::value && !is_arithmetic<T>::value && !is_reference<T>::value>
   {
   };
 
-#if ETL_USING_CPP17
+      #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_enum_v = etl::is_enum<T>::value;
-#endif
-#else
+      #endif
+    #else
   namespace private_type_traits
   {
     // Helper to detect if a type is convertible to an integer
     template <typename T>
     struct is_convertible_to_int
     {
-      static char test(int);   // Match if T is convertible to int
+      static char   test(int); // Match if T is convertible to int
       static double test(...); // Fallback for other types
 
       static const bool value = sizeof(test(static_cast<T>(0))) == sizeof(char);
     };
-  }
+  } // namespace private_type_traits
 
   // Implementation of is_enum
   template <typename T>
   struct is_enum
   {
-    static const bool value = private_type_traits::is_convertible_to_int<T>::value &&
-                              !is_class<T>::value &&
-                              !is_arithmetic<T>::value &&
-                              !is_reference<T>::value;
+    static const bool value = private_type_traits::is_convertible_to_int<T>::value && !is_class<T>::value && !is_arithmetic<T>::value && !is_reference<T>::value;
   };
-#endif
+    #endif
 
-  //***************************************************************************
-  /// is_convertible
-  ///\ingroup type_traits
-#if ETL_USING_CPP11
+    //***************************************************************************
+    /// is_convertible
+    ///\ingroup type_traits
+    #if ETL_USING_CPP11
   namespace private_type_traits
   {
     template <typename>
     using true_type_for = etl::true_type;
 
     template <typename T>
-    auto returnable(int)->true_type_for<T()>;
+    auto returnable(int) -> true_type_for<T()>;
 
     template <typename>
-    auto returnable(...)->etl::false_type;
+    auto returnable(...) -> etl::false_type;
 
     template <typename TFrom, typename TTo>
-    auto nonvoid_convertible(int)->true_type_for<decltype(etl::declval<void(&)(TTo)>()(etl::declval<TFrom>()))
-    >;
+    auto nonvoid_convertible(int) -> true_type_for<decltype(etl::declval<void (&)(TTo)>()(etl::declval<TFrom>())) >;
     template <typename, typename>
-    auto nonvoid_convertible(...)->etl::false_type;
-  }
+    auto nonvoid_convertible(...) -> etl::false_type;
+  } // namespace private_type_traits
 
-#if defined(ETL_COMPILER_ARM5)
+      #if defined(ETL_COMPILER_ARM5)
   template <typename TFrom, typename TTo>
-  struct is_convertible : etl::bool_constant<__is_convertible_to(TFrom, TTo)> {};
-#else
+  struct is_convertible : etl::bool_constant<__is_convertible_to(TFrom, TTo)>
+  {
+  };
+      #else
   template <typename TFrom, typename TTo>
-  struct is_convertible : etl::bool_constant<(decltype(private_type_traits::returnable<TTo>(0))::value &&
-                                              decltype(private_type_traits::nonvoid_convertible<TFrom, TTo>(0))::value) ||
-                                              (etl::is_void<TFrom>::value && etl::is_void<TTo>::value)> {};
-#endif
+  struct is_convertible : etl::bool_constant<(decltype(private_type_traits::returnable<TTo>(0))::value && decltype(private_type_traits::nonvoid_convertible<TFrom, TTo>(0))::value) || (etl::is_void<TFrom>::value && etl::is_void<TTo>::value)>
+  {
+  };
+      #endif
 
   // Is convertible and the conversion is noexcept.
   template <typename TFrom, typename TTo>
   struct is_nothrow_convertible
   {
   private:
+
     // Helper: a function taking TTo to require the conversion.
     static void sink(TTo) noexcept;
 
@@ -858,515 +1390,659 @@ namespace etl
     static etl::false_type test(...);
 
   public:
+
     static ETL_CONSTANT bool value = decltype(test<TFrom>(0))::value;
   };
-#endif
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename TFrom, typename TTo >
   inline constexpr bool is_convertible_v = etl::is_convertible<TFrom, TTo>::value;
 
   template <typename TFrom, typename TTo >
   inline constexpr bool is_nothrow_convertible_v = etl::is_nothrow_convertible<TFrom, TTo>::value;
-#endif
+    #endif
 
-  //***************************************************************************
-  /// Alignment templates.
-  /// These require compiler specific intrinsics.
-#if ETL_USING_CPP11 && !defined(ETL_COMPILER_ARM5)
-  template <typename T> struct alignment_of : integral_constant<size_t, alignof(T)> { };
-#elif defined(ETL_COMPILER_MICROSOFT)
-  template <typename T> struct alignment_of : integral_constant<size_t, size_t(__alignof(T))> {};
-#elif defined(ETL_COMPILER_IAR) || defined(ETL_COMPILER_TI)
-  template <typename T> struct alignment_of : integral_constant<size_t, size_t(__ALIGNOF__(T))> {};
-#else
-  template <typename T> struct alignment_of : integral_constant<size_t, size_t(__alignof__(T))> {};
-#endif
+    //***************************************************************************
+    /// Alignment templates.
+    /// These require compiler specific intrinsics.
+    #if ETL_USING_CPP11 && !defined(ETL_COMPILER_ARM5)
+  template <typename T>
+  struct alignment_of : integral_constant<size_t, alignof(T)>
+  {
+  };
+    #elif defined(ETL_COMPILER_MICROSOFT)
+  template <typename T>
+  struct alignment_of : integral_constant<size_t, size_t(__alignof(T))>
+  {
+  };
+    #elif defined(ETL_COMPILER_IAR) || defined(ETL_COMPILER_TI)
+  template <typename T>
+  struct alignment_of : integral_constant<size_t, size_t(__ALIGNOF__(T))>
+  {
+  };
+    #else
+  template <typename T>
+  struct alignment_of : integral_constant<size_t, size_t(__alignof__(T))>
+  {
+  };
+    #endif
 
   /// Specialisation of 'alignment_of' for 'void'.
   ///\ingroup type_traits
-  template <> struct alignment_of<void> : integral_constant <size_t, 0> {};
-  template <> struct alignment_of<const void> : integral_constant <size_t, 0> {};
+  template <>
+  struct alignment_of<void> : integral_constant<size_t, 0>
+  {
+  };
+  template <>
+  struct alignment_of<const void> : integral_constant<size_t, 0>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr size_t alignment_of_v = etl::alignment_of<T>::value;
-#endif
+    #endif
 
-#else // Condition = ETL_USING_STL && ETL_USING_CPP11
+  #else // Condition = ETL_USING_STL && ETL_USING_CPP11
 
-//*****************************************************************************
-// Traits are derived from the STL
-//*****************************************************************************
+  //*****************************************************************************
+  // Traits are derived from the STL
+  //*****************************************************************************
 
   //***************************************************************************
   /// integral_constant
   ///\ingroup type_traits
   template <typename T, T VALUE>
-  struct integral_constant : std::integral_constant<T, VALUE> {};
+  struct integral_constant : std::integral_constant<T, VALUE>
+  {
+  };
 
-/// integral_constant specialisations
-///\ingroup type_traits
-typedef integral_constant<bool, false> false_type;
-typedef integral_constant<bool, true>  true_type;
+  /// integral_constant specialisations
+  ///\ingroup type_traits
+  typedef integral_constant<bool, false> false_type;
+  typedef integral_constant<bool, true>  true_type;
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T, T VALUE>
   inline constexpr T integral_constant_v = std::integral_constant<T, VALUE>::value;
-#endif
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <bool BValue>
   using bool_constant = std::bool_constant<BValue>;
-#else
+    #else
   template <bool BValue>
-  struct bool_constant : std::integral_constant<bool, BValue> { };
-#endif
+  struct bool_constant : std::integral_constant<bool, BValue>
+  {
+  };
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <bool BValue>
   inline constexpr bool bool_constant_v = bool_constant<BValue>::value;
-#endif
+    #endif
 
-  //***************************************************************************
-  /// negation
-  ///\ingroup type_traits
-#if ETL_USING_CPP17
+    //***************************************************************************
+    /// negation
+    ///\ingroup type_traits
+    #if ETL_USING_CPP17
   template <typename T>
   using negation = std::negation<T>;
-#else
+    #else
   template <typename T>
   struct negation : etl::bool_constant<!bool(T::value)>
   {
   };
-#endif
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool negation_v = std::negation_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_reference
   ///\ingroup type_traits
-  template <typename T> struct remove_reference : std::remove_reference<T> {};
+  template <typename T>
+  struct remove_reference : std::remove_reference<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_reference_t = typename std::remove_reference<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_pointer
   ///\ingroup type_traits
-  template <typename T> struct remove_pointer : std::remove_pointer<T> {};
+  template <typename T>
+  struct remove_pointer : std::remove_pointer<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_pointer_t = typename std::remove_pointer<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_pointer
   ///\ingroup type_traits
-  template <typename T> struct add_pointer : std::add_pointer<T> {};
+  template <typename T>
+  struct add_pointer : std::add_pointer<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_pointer_t = typename std::add_pointer<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_const
   ///\ingroup type_traits
-  template <typename T> struct is_const : std::is_const<T> {};
+  template <typename T>
+  struct is_const : std::is_const<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_const_v = std::is_const_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_const
   ///\ingroup type_traits
-  template <typename T> struct remove_const : std::remove_const<T> {};
+  template <typename T>
+  struct remove_const : std::remove_const<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_const_t = typename std::remove_const<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_const
   ///\ingroup type_traits
-  template <typename T> struct add_const : std::add_const<T> {};
+  template <typename T>
+  struct add_const : std::add_const<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_const_t = typename std::add_const<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_volatile
   ///\ingroup type_traits
-  template <typename T> struct is_volatile : std::is_volatile<T> {};
+  template <typename T>
+  struct is_volatile : std::is_volatile<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_volatile_v = std::is_volatile_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_volatile
   ///\ingroup type_traits
-  template <typename T> struct remove_volatile : std::remove_volatile<T> {};
+  template <typename T>
+  struct remove_volatile : std::remove_volatile<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_volatile_t = typename std::remove_volatile<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_volatile
   ///\ingroup type_traits
-  template <typename T> struct add_volatile : std::add_volatile<T> {};
+  template <typename T>
+  struct add_volatile : std::add_volatile<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_volatile_t = typename std::add_volatile<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_cv
   ///\ingroup type_traits
-  template <typename T> struct remove_cv : std::remove_cv<T> {};
+  template <typename T>
+  struct remove_cv : std::remove_cv<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_cv_t = typename std::remove_cv<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_cv
   ///\ingroup type_traits
-  template <typename T> struct add_cv : std::add_cv<T> {};
+  template <typename T>
+  struct add_cv : std::add_cv<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_cv_t = typename std::add_cv<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_cvref
   ///\ingroup type_traits
-  template <typename T> struct remove_cvref
+  template <typename T>
+  struct remove_cvref
   {
     typedef typename std::remove_cv<typename std::remove_reference<T>::type>::type type;
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_cvref_t = typename etl::remove_cvref<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_integral
   ///\ingroup type_traits
-  template <typename T> struct is_integral : std::is_integral<T> {};
+  template <typename T>
+  struct is_integral : std::is_integral<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_integral_v = std::is_integral_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_signed
   ///\ingroup type_traits
-  template <typename T> struct is_signed : std::is_signed<T> {};
+  template <typename T>
+  struct is_signed : std::is_signed<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_signed_v = std::is_signed_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_unsigned
   ///\ingroup type_traits
-  template <typename T> struct is_unsigned : std::is_unsigned<T> {};
+  template <typename T>
+  struct is_unsigned : std::is_unsigned<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_unsigned_v = std::is_unsigned_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_floating_point
   ///\ingroup type_traits
-  template <typename T> struct is_floating_point : std::is_floating_point<T> {};
+  template <typename T>
+  struct is_floating_point : std::is_floating_point<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_floating_point_v = std::is_floating_point_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_same
   ///\ingroup type_traits
-  template <typename T1, typename T2> struct is_same : std::is_same<T1, T2> {};
+  template <typename T1, typename T2>
+  struct is_same : std::is_same<T1, T2>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T1, typename T2>
   inline constexpr bool is_same_v = std::is_same_v<T1, T2>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_void
   ///\ingroup type_traits
-  template<typename T> struct is_void : std::is_void<T> {};
+  template <typename T>
+  struct is_void : std::is_void<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_void_v = std::is_void_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_arithmetic
   ///\ingroup type_traits
-  template<typename T> struct is_arithmetic : std::is_arithmetic<T> {};
+  template <typename T>
+  struct is_arithmetic : std::is_arithmetic<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_arithmetic_v = std::is_arithmetic_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_fundamental
   ///\ingroup type_traits
-  template <typename T> struct is_fundamental : std::is_fundamental<T> {};
+  template <typename T>
+  struct is_fundamental : std::is_fundamental<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_fundamental_v = std::is_fundamental_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_compound
   ///\ingroup type_traits
-  template <typename T> struct is_compound : std::is_compound<T> {};
+  template <typename T>
+  struct is_compound : std::is_compound<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_compound_v = std::is_compound_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_array
   ///\ingroup type_traits
-  template <typename T> struct is_array : std::is_array<T> {};
+  template <typename T>
+  struct is_array : std::is_array<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_array_v = std::is_array_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_pointer
   ///\ingroup type_traits
-  template<typename T> struct is_pointer : std::is_pointer<T> {};
+  template <typename T>
+  struct is_pointer : std::is_pointer<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_pointer_v = std::is_pointer_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_reference
   ///\ingroup type_traits
-  template<typename T> struct is_reference : std::is_reference<T> {};
+  template <typename T>
+  struct is_reference : std::is_reference<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_reference_v = std::is_reference_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_lvalue_reference
   ///\ingroup type_traits
-  template<typename T> struct is_lvalue_reference : std::is_lvalue_reference<T> {};
+  template <typename T>
+  struct is_lvalue_reference : std::is_lvalue_reference<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_lvalue_reference_v = std::is_lvalue_reference_v<T>;
-#endif
+    #endif
 
-  //***************************************************************************
-  /// is_rvalue_reference
-  ///\ingroup type_traits
-#if ETL_USING_CPP11
-  template<typename T> struct is_rvalue_reference : std::is_rvalue_reference<T> {};
+    //***************************************************************************
+    /// is_rvalue_reference
+    ///\ingroup type_traits
+    #if ETL_USING_CPP11
+  template <typename T>
+  struct is_rvalue_reference : std::is_rvalue_reference<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+      #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_rvalue_reference_v = std::is_rvalue_reference_v<T>;
-#endif
-#endif
+      #endif
+    #endif
 
   //***************************************************************************
   /// is_pod
   ///\ingroup type_traits
   template <typename T>
-  struct is_pod : std::integral_constant<bool, std::is_standard_layout<T>::value && std::is_trivially_default_constructible<T>::value && std::is_trivially_copyable<T>::value> {};
+  struct is_pod : std::integral_constant<bool, std::is_standard_layout<T>::value && std::is_trivially_default_constructible<T>::value && std::is_trivially_copyable<T>::value>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_pod_v = std::is_standard_layout_v<T> && std::is_trivially_default_constructible_v<T> && std::is_trivially_copyable_v<T>;
-#endif
+    #endif
 
-#if defined(ETL_COMPILER_GCC)
-  #if ETL_COMPILER_VERSION >= 5
-    #define ETL_GCC_V5_TYPE_TRAITS_SUPPORTED
-  #endif
-#endif
+    #if defined(ETL_COMPILER_GCC)
+      #if ETL_COMPILER_VERSION >= 5
+        #define ETL_GCC_V5_TYPE_TRAITS_SUPPORTED
+      #endif
+    #endif
 
   //***************************************************************************
   /// conditional
   ///\ingroup type_traits
-  template <bool BValue, typename T, typename F>  struct conditional { typedef T type; };
-  template <typename T, typename F> struct conditional<false, T, F> { typedef F type; };
+  template <bool BValue, typename T, typename F>
+  struct conditional
+  {
+    typedef T type;
+  };
+  template <typename T, typename F>
+  struct conditional<false, T, F>
+  {
+    typedef F type;
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <bool BValue, typename T, typename F>
   using conditional_t = typename conditional<BValue, T, F>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// make_signed
   ///\ingroup type_traits
-  template <typename T> struct make_signed : std::make_signed<T> {};
+  template <typename T>
+  struct make_signed : std::make_signed<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using make_signed_t = typename std::make_signed<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// make_unsigned
   ///\ingroup type_traits
-  template <typename T> struct make_unsigned : std::make_unsigned<T> {};
+  template <typename T>
+  struct make_unsigned : std::make_unsigned<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using make_unsigned_t = typename std::make_unsigned<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// enable_if
   ///\ingroup type_traits
-  template <bool BValue, typename T = void> struct enable_if : std::enable_if<BValue, T> {};
+  template <bool BValue, typename T = void>
+  struct enable_if : std::enable_if<BValue, T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <bool BValue, typename T = void>
   using enable_if_t = typename std::enable_if<BValue, T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// extent
   ///\ingroup type_traits
   template <typename T, unsigned Size = 0U>
-  struct extent : std::extent<T, Size> {};
+  struct extent : std::extent<T, Size>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T, unsigned Size = 0U>
   inline constexpr size_t extent_v = std::extent_v<T, Size>;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_extent
   ///\ingroup type_traits
-  template <typename T> struct remove_extent : std::remove_extent<T> { };
+  template <typename T>
+  struct remove_extent : std::remove_extent<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_extent_t = typename std::remove_extent<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// remove_all_extents
   ///\ingroup type_traits
-  template <typename T> struct remove_all_extents : std::remove_all_extents<T> { };
+  template <typename T>
+  struct remove_all_extents : std::remove_all_extents<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using remove_all_extents_t = typename std::remove_all_extents<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// rank
   ///\ingroup type_traits
-  template <typename T>struct rank : std::rank<T> {};
+  template <typename T>
+  struct rank : std::rank<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr size_t rank_v = std::rank_v<T>;
-#endif
+    #endif
 
   //***************************************************************************
   /// decay
   ///\ingroup type_traits
-  template <typename T> struct decay : std::decay<T> {};
+  template <typename T>
+  struct decay : std::decay<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using decay_t = typename std::decay<T>::type;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_base_of
   ///\ingroup type_traits
-  template<typename TBase, typename TDerived> struct is_base_of : std::is_base_of<TBase, TDerived> {};
+  template <typename TBase, typename TDerived>
+  struct is_base_of : std::is_base_of<TBase, TDerived>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename TBase, typename TDerived>
   inline constexpr bool is_base_of_v = std::is_base_of_v<TBase, TDerived>;
-#endif
+    #endif
 
   //***************************************************************************
   /// is_class
-  template <typename T> struct is_class : std::is_class<T>{};
+  template <typename T>
+  struct is_class : std::is_class<T>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_class_v = is_class<T>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// add_lvalue_reference
-  template <typename T> struct add_lvalue_reference : std::add_lvalue_reference<T> {};
+  template <typename T>
+  struct add_lvalue_reference : std::add_lvalue_reference<T>
+  {
+  };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_lvalue_reference_t = typename std::add_lvalue_reference<T>::type;
-#endif
+    #endif
 
-  //***************************************************************************
-  /// add_rvalue_reference
-#if ETL_USING_CPP11
-  template <typename T> struct add_rvalue_reference : std::add_rvalue_reference<T> {};
-#endif
+    //***************************************************************************
+    /// add_rvalue_reference
+    #if ETL_USING_CPP11
+  template <typename T>
+  struct add_rvalue_reference : std::add_rvalue_reference<T>
+  {
+  };
+    #endif
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   template <typename T>
   using add_rvalue_reference_t = typename std::add_rvalue_reference<T>::type;
-#endif
+    #endif
 
-  //***************************************************************************
-  /// declval
-#if ETL_USING_CPP11
+    //***************************************************************************
+    /// declval
+    #if ETL_USING_CPP11
   template <typename T>
   typename std::add_rvalue_reference<T>::type declval() ETL_NOEXCEPT;
-#endif
+    #endif
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   //***************************************************************************
   /// is_enum
   ///\ingroup type_traits
@@ -1375,25 +2051,28 @@ typedef integral_constant<bool, true>  true_type;
   {
   };
 
-#if ETL_USING_CPP17
+      #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_enum_v = etl::is_enum<T>::value;
-#endif
+      #endif
 
-#endif
+    #endif
 
-  //***************************************************************************
-  /// is_convertible
-  ///\ingroup type_traits
-#if ETL_USING_CPP11
+    //***************************************************************************
+    /// is_convertible
+    ///\ingroup type_traits
+    #if ETL_USING_CPP11
   template <typename TFrom, typename TTo>
-  struct is_convertible : std::is_convertible<TFrom, TTo> {};
+  struct is_convertible : std::is_convertible<TFrom, TTo>
+  {
+  };
 
   // Is convertible and the conversion is noexcept.
   template <typename TFrom, typename TTo>
   struct is_nothrow_convertible
   {
   private:
+
     // Helper: a function taking TTo to require the conversion.
     static void sink(TTo) noexcept;
 
@@ -1406,40 +2085,50 @@ typedef integral_constant<bool, true>  true_type;
     static etl::false_type test(...);
 
   public:
+
     static ETL_CONSTANT bool value = decltype(test<TFrom>(0))::value;
   };
-#endif
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename TFrom, typename TTo>
   inline constexpr bool is_convertible_v = std::is_convertible_v<TFrom, TTo>;
 
   template <typename TFrom, typename TTo >
   inline constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<TFrom, TTo>::value;
-#endif
+    #endif
 
   //***************************************************************************
   /// Alignment templates.
   ///\ingroup type_traits
-  template <typename T> struct alignment_of : std::alignment_of<T> {};
-  template <> struct alignment_of<void> : std::integral_constant<size_t, 0> {};
-  template <> struct alignment_of<const void> : std::integral_constant <size_t, 0> {};
+  template <typename T>
+  struct alignment_of : std::alignment_of<T>
+  {
+  };
+  template <>
+  struct alignment_of<void> : std::integral_constant<size_t, 0>
+  {
+  };
+  template <>
+  struct alignment_of<const void> : std::integral_constant<size_t, 0>
+  {
+  };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr size_t alignment_of_v = std::alignment_of_v<T>;
-#endif
+    #endif
 
-#endif // Condition = ETL_USING_STL && ETL_USING_CPP11
+  #endif // Condition = ETL_USING_STL && ETL_USING_CPP11
 
   //***************************************************************************
   // ETL extended type traits.
   //***************************************************************************
 
-#if ETL_USING_CPP11
-  //***************************************************************************
-  /// conjunction
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
+    //***************************************************************************
+    /// conjunction
+    #if ETL_USING_CPP11
   template <typename...>
   struct conjunction : public etl::true_type
   {
@@ -1454,16 +2143,16 @@ typedef integral_constant<bool, true>  true_type;
   struct conjunction<T> : public T
   {
   };
-#endif
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename... T>
   inline constexpr bool conjunction_v = conjunction<T...>::value;
-#endif
+    #endif
 
-  //***************************************************************************
-  /// disjunction
-#if ETL_USING_CPP11
+    //***************************************************************************
+    /// disjunction
+    #if ETL_USING_CPP11
   template <typename...>
   struct disjunction : public etl::false_type
   {
@@ -1474,21 +2163,22 @@ typedef integral_constant<bool, true>  true_type;
   {
   };
 
-  template <typename T1> struct disjunction<T1> : public T1
+  template <typename T1>
+  struct disjunction<T1> : public T1
   {
   };
-#endif
+    #endif
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename... T>
   inline constexpr bool disjunction_v = etl::disjunction<T...>::value;
-#endif
+    #endif
 
-#endif
+  #endif
 
   //***************************************************************************
   /// exclusive_disjunction
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename... TTypes>
   struct exclusive_disjunction;
 
@@ -1502,12 +2192,12 @@ typedef integral_constant<bool, true>  true_type;
   struct exclusive_disjunction<T1, T2, TRest...> : public etl::exclusive_disjunction<etl::integral_constant<bool, etl::disjunction<T1, T2>::value && !etl::conjunction<T1, T2>::value>, TRest...>
   {
   };
-#endif
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename... T>
   inline constexpr bool exclusive_disjunction_v = etl::exclusive_disjunction<T...>::value;
-#endif
+  #endif
 
   //***************************************************************************
   /// conditional_integral_constant
@@ -1529,7 +2219,7 @@ typedef integral_constant<bool, true>  true_type;
     static const T value = FALSE_VALUE;
   };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //***************************************************************************
   /// Template to determine if a type is a base of all types in a specified list.
   ///\ingroup types
@@ -1537,76 +2227,63 @@ typedef integral_constant<bool, true>  true_type;
   struct is_one_of : etl::disjunction<etl::is_same<T, TRest>...>
   {
   };
-#else
+  #else
   //***************************************************************************
   /// Template to determine if a type is one of a specified list.
   ///\ingroup types
   template <typename T,
-            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 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>
   struct is_one_of
   {
-    static const bool value = 
-        etl::is_same<T, T1>::value ||
-        etl::is_same<T, T2>::value ||
-        etl::is_same<T, T3>::value ||
-        etl::is_same<T, T4>::value ||
-        etl::is_same<T, T5>::value ||
-        etl::is_same<T, T6>::value ||
-        etl::is_same<T, T7>::value ||
-        etl::is_same<T, T8>::value ||
-        etl::is_same<T, T9>::value ||
-        etl::is_same<T, T10>::value ||
-        etl::is_same<T, T11>::value ||
-        etl::is_same<T, T12>::value ||
-        etl::is_same<T, T13>::value ||
-        etl::is_same<T, T14>::value ||
-        etl::is_same<T, T15>::value ||
-        etl::is_same<T, T16>::value;
+    static const bool value = etl::is_same<T, T1>::value || etl::is_same<T, T2>::value || etl::is_same<T, T3>::value || etl::is_same<T, T4>::value
+                              || etl::is_same<T, T5>::value || etl::is_same<T, T6>::value || etl::is_same<T, T7>::value || etl::is_same<T, T8>::value
+                              || etl::is_same<T, T9>::value || etl::is_same<T, T10>::value || etl::is_same<T, T11>::value || etl::is_same<T, T12>::value
+                              || etl::is_same<T, T13>::value || etl::is_same<T, T14>::value || etl::is_same<T, T15>::value || etl::is_same<T, T16>::value;
   };
-#endif
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T, typename... TRest>
   inline constexpr bool is_one_of_v = etl::is_one_of<T, TRest...>::value;
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   namespace private_type_traits
   {
     //***************************************************************************
     // Helper to count occurrences of a type in a list of types
-    template<typename T, typename... TTypes>
+    template <typename T, typename... TTypes>
     struct count_type;
 
     // Base case: zero occurrences
-    template<typename T>
+    template <typename T>
     struct count_type<T> : etl::integral_constant<size_t, 0>
     {
     };
 
     // Recursive case: increment count if head is the same as T, otherwise continue with tail
-    template<typename T, typename THead, typename... TTail>
+    template <typename T, typename THead, typename... TTail>
     struct count_type<T, THead, TTail...> : etl::integral_constant<size_t, (etl::is_same<T, THead>::value ? 1 : 0) + count_type<T, TTail...>::value>
     {
     };
-  }
+  } // namespace private_type_traits
 
-  template<typename T, typename... TTypes>
+  template <typename T, typename... TTypes>
   struct has_duplicates_of
     : etl::integral_constant<bool, (private_type_traits::count_type<T, TTypes...>::value > 1)>
   {
   };
-#endif
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T, typename... TRest>
   inline constexpr bool has_duplicates_of_v = etl::has_duplicates_of<T, TRest...>::value;
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //***************************************************************************
   /// Template to determine if a type is a base of all types in a specified list.
   ///\ingroup types
@@ -1614,14 +2291,14 @@ typedef integral_constant<bool, true>  true_type;
   struct is_base_of_all : etl::conjunction<etl::is_base_of<TBase, TDerived>...>
   {
   };
-#endif
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T, typename... TRest>
   inline constexpr bool is_base_of_all_v = etl::is_base_of_all<T, TRest...>::value;
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //***************************************************************************
   /// Template to determine if a type is a base of any type in a specified list.
   ///\ingroup types
@@ -1630,17 +2307,17 @@ typedef integral_constant<bool, true>  true_type;
   {
   };
 
-#endif
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T, typename... TRest>
   inline constexpr bool is_base_of_any_v = etl::is_base_of_any<T, TRest...>::value;
-#endif
+  #endif
 
   //***************************************************************************
   /// Get the Nth base of a recursively inherited type.
   /// Requires that the class has defined 'base_type'.
-  //*************************************************************************** 
+  //***************************************************************************
   // Recursive definition of the type.
   template <size_t Index, typename TType>
   struct nth_base
@@ -1654,10 +2331,10 @@ typedef integral_constant<bool, true>  true_type;
     typedef TType type;
   };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <size_t Index, typename TType>
   using nth_base_t = typename nth_base<Index, TType>::type;
-#endif
+  #endif
 
   //***************************************************************************
   /// A set of templates to allow related types to be derived.
@@ -1680,9 +2357,9 @@ typedef integral_constant<bool, true>  true_type;
     typedef const type_t*       const_pointer;
     typedef const type_t* const const_pointer_const;
 
-#if ETL_USING_CPP11
-    typedef type_t&&            rvalue_reference;
-#endif
+  #if ETL_USING_CPP11
+    typedef type_t&& rvalue_reference;
+  #endif
   };
 
   // Pointers.
@@ -1702,9 +2379,9 @@ typedef integral_constant<bool, true>  true_type;
     typedef const type_t*       const_pointer;
     typedef const type_t* const const_pointer_const;
 
-#if ETL_USING_CPP11
-    typedef type_t&&            rvalue_reference;
-#endif
+  #if ETL_USING_CPP11
+    typedef type_t&& rvalue_reference;
+  #endif
   };
 
   // Pointers.
@@ -1721,12 +2398,12 @@ typedef integral_constant<bool, true>  true_type;
     typedef type_t&             reference;
     typedef const type_t&       const_reference;
     typedef type_t*             pointer;
-    typedef const type_t* const_pointer;
+    typedef const type_t*       const_pointer;
     typedef const type_t* const const_pointer_const;
 
-#if ETL_USING_CPP11
-    typedef type_t&&            rvalue_reference;
-#endif
+  #if ETL_USING_CPP11
+    typedef type_t&& rvalue_reference;
+  #endif
   };
 
   // References.
@@ -1746,12 +2423,12 @@ typedef integral_constant<bool, true>  true_type;
     typedef const type_t*       const_pointer;
     typedef const type_t* const const_pointer_const;
 
-#if ETL_USING_CPP11
-    typedef type_t&&            rvalue_reference;
-#endif
+  #if ETL_USING_CPP11
+    typedef type_t&& rvalue_reference;
+  #endif
   };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   // rvalue References.
   template <typename T>
   struct types<T&&>
@@ -1769,13 +2446,13 @@ typedef integral_constant<bool, true>  true_type;
     typedef const type_t*       const_pointer;
     typedef const type_t* const const_pointer_const;
 
-#if ETL_USING_CPP11
-    typedef type_t&&            rvalue_reference;
-#endif
+    #if ETL_USING_CPP11
+    typedef type_t&& rvalue_reference;
+    #endif
   };
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename T>
   using types_t = typename types<T>::type;
 
@@ -1796,35 +2473,41 @@ typedef integral_constant<bool, true>  true_type;
 
   template <typename T>
   using types_cpc = typename types<T>::const_pointer_const;
-#endif
+  #endif
 
   //***************************************************************************
   /// size_of
   ///\ingroup types
-  template <typename T> struct size_of : etl::integral_constant<size_t, sizeof(T)> {};
-  template <> struct size_of<void> : etl::integral_constant<size_t, 1U> {};
+  template <typename T>
+  struct size_of : etl::integral_constant<size_t, sizeof(T)>
+  {
+  };
+  template <>
+  struct size_of<void> : etl::integral_constant<size_t, 1U>
+  {
+  };
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T>
   inline constexpr size_t size_of_v = etl::size_of<T>::value;
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //***************************************************************************
   /// are_all_same
   template <typename T, typename... TRest>
   struct are_all_same : etl::conjunction<etl::is_same<T, TRest>...>
   {
   };
-#endif
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T, typename... TRest>
   inline constexpr bool are_all_same_v = are_all_same<T, TRest...>::value;
-#endif
+  #endif
 
   //***************************************************************************
-#if ETL_USING_STL && ETL_USING_CPP11 && !defined(ETL_USE_TYPE_TRAITS_BUILTINS) && !defined(ETL_USER_DEFINED_TYPE_TRAITS) && ((!defined(ARDUINO) && ETL_NOT_USING_STLPORT) || defined(ETL_GCC_V5_TYPE_TRAITS_SUPPORTED))
+  #if ETL_USING_STL && ETL_USING_CPP11 && !defined(ETL_USE_TYPE_TRAITS_BUILTINS) && !defined(ETL_USER_DEFINED_TYPE_TRAITS) && ((!defined(ARDUINO) && ETL_NOT_USING_STLPORT) || defined(ETL_GCC_V5_TYPE_TRAITS_SUPPORTED))
 
   //*********************************************
   // Use the STL's definitions.
@@ -1832,12 +2515,12 @@ typedef integral_constant<bool, true>  true_type;
 
   //*********************************************
   // is_assignable
-  template<typename T1, typename T2>
+  template <typename T1, typename T2>
   using is_assignable = std::is_assignable<T1, T2>;
 
   //*********************************************
   // is_constructible
-  template<typename T, typename... TArgs>
+  template <typename T, typename... TArgs>
   using is_constructible = std::is_constructible<T, TArgs...>;
 
   //*********************************************
@@ -1850,57 +2533,57 @@ typedef integral_constant<bool, true>  true_type;
   template <typename T>
   using is_move_constructible = std::is_move_constructible<T>;
 
-  //*********************************************
-  // is_trivially_constructible
-#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
+    //*********************************************
+    // is_trivially_constructible
+    #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
   using is_trivially_constructible = std::is_trivially_constructible<T>;
-#else
+    #else
   template <typename T>
   using is_trivially_constructible = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
-#endif
+    #endif
 
-  //*********************************************
-  // is_trivially_copy_constructible
-#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
+    //*********************************************
+    // is_trivially_copy_constructible
+    #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
   using is_trivially_copy_constructible = std::is_trivially_copy_constructible<T>;
-#else
+    #else
   template <typename T>
   using is_trivially_copy_constructible = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
-#endif
+    #endif
 
-  //*********************************************
-  // is_trivially_destructible
-#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
+    //*********************************************
+    // is_trivially_destructible
+    #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
   using is_trivially_destructible = std::is_trivially_destructible<T>;
-#else
+    #else
   template <typename T>
   using is_trivially_destructible = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
-#endif
+    #endif
 
-  //*********************************************
-  // is_trivially_copy_assignable
-#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
+    //*********************************************
+    // is_trivially_copy_assignable
+    #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
   using is_trivially_copy_assignable = std::is_trivially_copy_assignable<T>;
-#else
+    #else
   template <typename T>
   using is_trivially_copy_assignable = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
-#endif
+    #endif
 
-  //*********************************************
-  // is_trivially_copyable
-#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
+    //*********************************************
+    // is_trivially_copyable
+    #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
   template <typename T>
   using is_trivially_copyable = std::is_trivially_copyable<T>;
-#else
+    #else
   template <typename T>
   using is_trivially_copyable = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
-#endif
+    #endif
 
-#elif defined(ETL_USE_TYPE_TRAITS_BUILTINS) && !defined(ETL_USER_DEFINED_TYPE_TRAITS)
+  #elif defined(ETL_USE_TYPE_TRAITS_BUILTINS) && !defined(ETL_USER_DEFINED_TYPE_TRAITS)
 
   //*********************************************
   // Use the compiler's builtins.
@@ -1908,24 +2591,24 @@ typedef integral_constant<bool, true>  true_type;
 
   //*********************************************
   // is_assignable
-  template<typename T1, typename T2>
+  template <typename T1, typename T2>
   struct is_assignable
   {
     static ETL_CONSTANT bool value = __is_assignable(T1, T2);
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   //*********************************************
   // is_constructible
-  template<typename T, typename... TArgs>
+  template <typename T, typename... TArgs>
   struct is_constructible
   {
     static ETL_CONSTANT bool value = __is_constructible(T, TArgs...);
   };
-#else
+    #else
   //*********************************************
   // is_constructible
-  template<typename T, typename TArgs = void>
+  template <typename T, typename TArgs = void>
   struct is_constructible
   {
     static ETL_CONSTANT bool value = __is_constructible(T, TArgs);
@@ -1933,12 +2616,12 @@ typedef integral_constant<bool, true>  true_type;
 
   //*********************************************
   // is_constructible
-  template<typename T>
+  template <typename T>
   struct is_constructible<T, void>
   {
     static ETL_CONSTANT bool value = __is_constructible(T);
   };
-#endif
+    #endif
 
   //*********************************************
   // is_copy_constructible
@@ -1954,29 +2637,29 @@ typedef integral_constant<bool, true>  true_type;
   {
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   //*********************************************
   // is_trivially_constructible
   template <typename T, typename... TArgs>
   struct is_trivially_constructible
   {
-#if defined(ETL_COMPILER_GCC)
+      #if defined(ETL_COMPILER_GCC)
     static ETL_CONSTANT bool value = __has_trivial_constructor(T);
-#else
+      #else
     static ETL_CONSTANT bool value = __is_trivially_constructible(T, TArgs...);
-#endif
+      #endif
   };
-#else
+    #else
   //*********************************************
   // is_trivially_constructible
   template <typename T, typename TArgs = void>
   struct is_trivially_constructible
   {
-#if defined(ETL_COMPILER_GCC)
+      #if defined(ETL_COMPILER_GCC)
     static ETL_CONSTANT bool value = __has_trivial_constructor(T);
-#else
+      #else
     static ETL_CONSTANT bool value = __is_trivially_constructible(T, TArgs);
-#endif
+      #endif
   };
 
   //*********************************************
@@ -1984,13 +2667,13 @@ typedef integral_constant<bool, true>  true_type;
   template <typename T>
   struct is_trivially_constructible<T, void>
   {
-#if defined(ETL_COMPILER_GCC)
+      #if defined(ETL_COMPILER_GCC)
     static ETL_CONSTANT bool value = __has_trivial_constructor(T);
-#else
+      #else
     static ETL_CONSTANT bool value = __is_trivially_constructible(T);
-#endif
+      #endif
   };
-#endif
+    #endif
 
   //*********************************************
   // is_trivially_copy_constructible
@@ -2004,11 +2687,11 @@ typedef integral_constant<bool, true>  true_type;
   template <typename T>
   struct is_trivially_destructible
   {
-#if defined(ETL_COMPILER_GCC)
+    #if defined(ETL_COMPILER_GCC)
     static ETL_CONSTANT bool value = __has_trivial_destructor(T);
-#else
+    #else
     static ETL_CONSTANT bool value = __is_trivially_destructible(T);
-#endif
+    #endif
   };
 
   //*********************************************
@@ -2016,11 +2699,11 @@ typedef integral_constant<bool, true>  true_type;
   template <typename T>
   struct is_trivially_copy_assignable
   {
-#if defined(ETL_COMPILER_GCC)
+    #if defined(ETL_COMPILER_GCC)
     static ETL_CONSTANT bool value = __has_trivial_copy(T);
-#else
+    #else
     static ETL_CONSTANT bool value = __is_trivially_copyable(T);
-#endif
+    #endif
   };
 
   //*********************************************
@@ -2028,14 +2711,14 @@ typedef integral_constant<bool, true>  true_type;
   template <typename T>
   struct is_trivially_copyable
   {
-#if defined(ETL_COMPILER_GCC)
+    #if defined(ETL_COMPILER_GCC)
     static ETL_CONSTANT bool value = __has_trivial_copy(T);
-#else
+    #else
     static ETL_CONSTANT bool value = __is_trivially_copyable(T);
-#endif
+    #endif
   };
 
-#elif defined(ETL_USER_DEFINED_TYPE_TRAITS) && !defined(ETL_USE_TYPE_TRAITS_BUILTINS)
+  #elif defined(ETL_USER_DEFINED_TYPE_TRAITS) && !defined(ETL_USE_TYPE_TRAITS_BUILTINS)
 
   //*********************************************
   // Force the user to provide specialisations for
@@ -2057,7 +2740,7 @@ typedef integral_constant<bool, true>  true_type;
   template <typename T1, typename T2>
   struct is_assignable<T1, T2, false>;
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   //*********************************************
   // is_constructible
   template <typename T, bool BValue, typename... TArgs>
@@ -2075,7 +2758,7 @@ typedef integral_constant<bool, true>  true_type;
   struct is_constructible : public is_constructible_helper<T, etl::is_arithmetic<T>::value || etl::is_pointer<T>::value, TArgs...>
   {
   };
-#endif
+    #endif
 
   //*********************************************
   // is_copy_constructible
@@ -2168,7 +2851,7 @@ typedef integral_constant<bool, true>  true_type;
   template <typename T>
   struct is_trivially_copyable<T, false>;
 
-#else
+  #else
 
   //*********************************************
   // Assume that anything other than arithmetics
@@ -2182,17 +2865,21 @@ typedef integral_constant<bool, true>  true_type;
   {
   };
 
-#if ETL_USING_CPP11
+    #if ETL_USING_CPP11
   //***************************************************************************
   /// is_constructible
-  namespace private_type_traits 
+  namespace private_type_traits
   {
     template <class, class T, class... TArgs>
-    struct is_constructible_ : etl::false_type {};
+    struct is_constructible_ : etl::false_type
+    {
+    };
 
     template <class T, class... TArgs>
-    struct is_constructible_<void_t<decltype(T(etl::declval<TArgs>()...))>, T, TArgs...> : etl::true_type {};
-  }
+    struct is_constructible_<void_t<decltype(T(etl::declval<TArgs>()...))>, T, TArgs...> : etl::true_type
+    {
+    };
+  } // namespace private_type_traits
 
   //*********************************************
   // is_constructible
@@ -2201,21 +2888,51 @@ typedef integral_constant<bool, true>  true_type;
 
   //*********************************************
   // is_copy_constructible
-  template <class T> struct is_copy_constructible : public is_constructible<T,  typename etl::add_lvalue_reference<typename etl::add_const<T>::type>::type>{};
-  template <> struct is_copy_constructible<void> : public false_type{};
-  template <> struct is_copy_constructible<void const> : public false_type{};
-  template <> struct is_copy_constructible<void volatile> : public false_type{};
-  template <> struct is_copy_constructible<void const volatile> : public false_type{};
+  template <class T>
+  struct is_copy_constructible : public is_constructible<T, typename etl::add_lvalue_reference<typename etl::add_const<T>::type>::type>
+  {
+  };
+  template <>
+  struct is_copy_constructible<void> : public false_type
+  {
+  };
+  template <>
+  struct is_copy_constructible<void const> : public false_type
+  {
+  };
+  template <>
+  struct is_copy_constructible<void volatile> : public false_type
+  {
+  };
+  template <>
+  struct is_copy_constructible<void const volatile> : public false_type
+  {
+  };
 
   //*********************************************
   // is_move_constructible
-  template <typename T> struct is_move_constructible: public is_constructible<T, typename etl::add_rvalue_reference<T>::type>{};
-  template <> struct is_move_constructible<void> : public false_type{};
-  template <> struct is_move_constructible<void const> : public false_type{};
-  template <> struct is_move_constructible<void volatile> : public false_type{};
-  template <> struct is_move_constructible<void const volatile> : public false_type{};
+  template <typename T>
+  struct is_move_constructible : public is_constructible<T, typename etl::add_rvalue_reference<T>::type>
+  {
+  };
+  template <>
+  struct is_move_constructible<void> : public false_type
+  {
+  };
+  template <>
+  struct is_move_constructible<void const> : public false_type
+  {
+  };
+  template <>
+  struct is_move_constructible<void volatile> : public false_type
+  {
+  };
+  template <>
+  struct is_move_constructible<void const volatile> : public false_type
+  {
+  };
 
-#else
+    #else
 
   //*********************************************
   // is_copy_constructible
@@ -2230,7 +2947,7 @@ typedef integral_constant<bool, true>  true_type;
   struct is_move_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
   {
   };
-#endif
+    #endif
 
   //*********************************************
   // is_trivially_constructible
@@ -2267,30 +2984,33 @@ typedef integral_constant<bool, true>  true_type;
   {
   };
 
-#endif
+  #endif
 
   template <typename T1, typename T2>
-  struct is_lvalue_assignable : public etl::is_assignable<typename etl::add_lvalue_reference<T1>::type,
-                                                          typename etl::add_lvalue_reference<typename etl::add_const<T2>::type>::type>
+  struct is_lvalue_assignable : public etl::is_assignable<typename etl::add_lvalue_reference<T1>::type, typename etl::add_lvalue_reference<typename etl::add_const<T2>::type>::type>
   {
   };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //*********************************************
   // is_default_constructible
-  template<typename T, typename = void>
-  struct is_default_constructible : etl::false_type { };
+  template <typename T, typename = void>
+  struct is_default_constructible : etl::false_type
+  {
+  };
 
-  template<typename T>
-  struct is_default_constructible<T, etl::void_t<decltype(T())>> : etl::true_type { };
-#else
+  template <typename T>
+  struct is_default_constructible<T, etl::void_t<decltype(T())>> : etl::true_type
+  {
+  };
+  #else
   template <typename T>
   struct is_default_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
   {
   };
-#endif
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
 
   template <typename T1, typename T2>
   inline constexpr bool is_assignable_v = etl::is_assignable<T1, T2>::value;
@@ -2298,16 +3018,16 @@ typedef integral_constant<bool, true>  true_type;
   template <typename T1, typename T2>
   inline constexpr bool is_lvalue_assignable_v = etl::is_lvalue_assignable<T1, T2>::value;
 
-  template<typename T, typename... TArgs>
+  template <typename T, typename... TArgs>
   inline constexpr bool is_constructible_v = etl::is_constructible<T, TArgs...>::value;
 
-  template<typename T, typename... TArgs>
+  template <typename T, typename... TArgs>
   inline constexpr bool is_default_constructible_v = etl::is_default_constructible<T, TArgs...>::value;
 
-  template<typename T>
+  template <typename T>
   inline constexpr bool is_copy_constructible_v = etl::is_copy_constructible<T>::value;
 
-  template<typename T>
+  template <typename T>
   inline constexpr bool is_move_constructible_v = etl::is_move_constructible<T>::value;
 
   template <typename T>
@@ -2325,9 +3045,9 @@ typedef integral_constant<bool, true>  true_type;
   template <typename T>
   inline constexpr bool is_trivially_copyable_v = etl::is_trivially_copyable<T>::value;
 
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //*********************************************
   // common_type
   // Based on the sample implementation detailed on
@@ -2335,7 +3055,7 @@ typedef integral_constant<bool, true>  true_type;
   //*********************************************
   //***********************************
   // Primary template
-  template<typename...>
+  template <typename...>
   struct common_type
   {
   };
@@ -2364,7 +3084,7 @@ typedef integral_constant<bool, true>  true_type;
     };
 
     template <typename T1, typename T2, typename = void>
-    struct common_type_2_impl 
+    struct common_type_2_impl
       : decay_conditional_result<const T1&, const T2&>
     {
     };
@@ -2374,16 +3094,16 @@ typedef integral_constant<bool, true>  true_type;
       : decay_conditional_result<T1, T2>
     {
     };
-  }
+  } // namespace private_common_type
 
   //***********************************
   // Two types
   template <typename T1, typename T2>
   struct common_type<T1, T2>
-    : etl::conditional<etl::is_same<T1, typename etl::decay<T1>::type>::value&& etl::is_same<T2, typename etl::decay<T2>::type>::value,
+    : etl::conditional<etl::is_same<T1, typename etl::decay<T1>::type>::value && etl::is_same<T2, typename etl::decay<T2>::type>::value,
                        private_common_type::common_type_2_impl<T1, T2>,
                        common_type<typename etl::decay<T2>::type,
-                       typename etl::decay<T2>::type>>::type
+                                   typename etl::decay<T2>::type>>::type
   {
   };
 
@@ -2401,9 +3121,9 @@ typedef integral_constant<bool, true>  true_type;
       : common_type<typename common_type<T1, T2>::type, TRest...>
     {
     };
-  }
+  } // namespace private_common_type
 
-  template<typename T1, typename T2, typename... TRest>
+  template <typename T1, typename T2, typename... TRest>
   struct common_type<T1, T2, TRest...>
     : private_common_type::common_type_multi_impl<void, T1, T2, TRest...>
   {
@@ -2411,7 +3131,7 @@ typedef integral_constant<bool, true>  true_type;
 
   template <typename... T>
   using common_type_t = typename common_type<T...>::type;
-#endif
+  #endif
 
   //***************************************************************************
   /// Defines one of five unsigned types that has the same size as T.
@@ -2420,16 +3140,16 @@ typedef integral_constant<bool, true>  true_type;
   struct unsigned_type
   {
     typedef typename etl::conditional<sizeof(T) == sizeof(unsigned char), unsigned char,
-      typename etl::conditional<sizeof(T) == sizeof(unsigned short), unsigned short,
-        typename etl::conditional<sizeof(T) == sizeof(unsigned int), unsigned int,
-          typename etl::conditional<sizeof(T) == sizeof(unsigned long), unsigned long,
-            unsigned long long>::type>::type>::type>::type type;
+                                      typename etl::conditional<sizeof(T) == sizeof(unsigned short), unsigned short,
+                                                                typename etl::conditional<sizeof(T) == sizeof(unsigned int), unsigned int,
+                                                                                          typename etl::conditional<sizeof(T) == sizeof(unsigned long), unsigned long,
+                                                                                                                    unsigned long long>::type>::type>::type>::type type;
   };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename T>
   using unsigned_type_t = typename unsigned_type<T>::type;
-#endif
+  #endif
 
   //***************************************************************************
   /// Defines one of five signed types that has the same size as T.
@@ -2438,31 +3158,34 @@ typedef integral_constant<bool, true>  true_type;
   struct signed_type
   {
     typedef typename etl::conditional<sizeof(T) == sizeof(char), char,
-      typename etl::conditional<sizeof(T) == sizeof(short), short,
-        typename etl::conditional<sizeof(T) == sizeof(int), int,
-          typename etl::conditional<sizeof(T) == sizeof(long), long,
-            long long>::type>::type>::type>::type type;
+                                      typename etl::conditional<sizeof(T) == sizeof(short), short,
+                                                                typename etl::conditional<sizeof(T) == sizeof(int), int,
+                                                                                          typename etl::conditional<sizeof(T) == sizeof(long), long,
+                                                                                                                    long long>::type>::type>::type>::type type;
   };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename T>
   using signed_type_t = typename signed_type<T>::type;
-#endif
+  #endif
 
   //*********************************************
   // type_identity
 
   template <typename T>
-  struct type_identity { typedef T type; };
+  struct type_identity
+  {
+    typedef T type;
+  };
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename T>
   using type_identity_t = typename type_identity<T>::type;
-#endif
+  #endif
 
   //*********************************************
   // underlying_type
-#if ETL_USING_BUILTIN_UNDERLYING_TYPE
+  #if ETL_USING_BUILTIN_UNDERLYING_TYPE
   // Primary template for etl::underlying_type
   template <typename T, bool = etl::is_enum<T>::value>
   struct underlying_type;
@@ -2480,7 +3203,7 @@ typedef integral_constant<bool, true>  true_type;
   {
     typedef __underlying_type(T) type;
   };
-#else
+  #else
   /// Primary template for etl::underlying_type
   /// Users must specialise this template for their enumerations.
   template <typename T>
@@ -2488,76 +3211,86 @@ typedef integral_constant<bool, true>  true_type;
   {
     typedef int type;
   };
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   template <typename T>
   using underlying_type_t = typename underlying_type<T>::type;
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //*********************************************
   // has_duplicates
   template <typename... TTypes>
   struct has_duplicates;
 
   template <typename TFirst, typename... TRest>
-  struct has_duplicates<TFirst, TRest...> : etl::conditional_t<etl::is_one_of<TFirst, TRest...>::value,
-                                                               etl::true_type,
-                                                               has_duplicates<TRest...>> {};
+  struct has_duplicates<TFirst, TRest...> : etl::conditional_t<etl::is_one_of<TFirst, TRest...>::value, etl::true_type, has_duplicates<TRest...>>
+  {
+  };
 
   template <typename T>
-  struct has_duplicates<T> : etl::false_type {};
+  struct has_duplicates<T> : etl::false_type
+  {
+  };
 
   template <>
-  struct has_duplicates<> : etl::false_type {};
-#endif
+  struct has_duplicates<> : etl::false_type
+  {
+  };
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename... TTypes>
   inline constexpr bool has_duplicates_v = etl::has_duplicates<TTypes...>::value;
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //*********************************************
   // count_of
   template <typename T, typename... TTypes>
   struct count_of;
 
   template <typename T, typename U, typename... URest>
-  struct count_of<T, U, URest...> : etl::integral_constant<size_t,
-                                                            etl::is_same<T, U>::value +
-                                                              count_of<T, URest...>::value> {};
+  struct count_of<T, U, URest...> : etl::integral_constant<size_t, etl::is_same<T, U>::value + count_of<T, URest...>::value>
+  {
+  };
 
   template <typename T>
-  struct count_of<T> : etl::integral_constant<size_t, 0> {};
-#endif
+  struct count_of<T> : etl::integral_constant<size_t, 0>
+  {
+  };
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T, typename... TTypes>
   inline constexpr size_t count_of_v = etl::count_of<T, TTypes...>::value;
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //*********************************************
   /// is_specialization
   template <typename T, template <typename...> class Template>
-  struct is_specialization : etl::false_type {};
+  struct is_specialization : etl::false_type
+  {
+  };
 
   template <template <typename...> class Template, typename... TArgs>
-  struct is_specialization<Template<TArgs...>, Template> : etl::true_type {};
-#endif
+  struct is_specialization<Template<TArgs...>, Template> : etl::true_type
+  {
+  };
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T, template <typename...> class Template>
   inline constexpr bool is_specialization_v = etl::is_specialization<T, Template>::value;
-#endif
+  #endif
 
   //*********************************************
   // is_constant_evaluated
   ETL_CONSTEXPR inline bool is_constant_evaluated() ETL_NOEXCEPT
   {
-#if ETL_USING_CPP23
+  #if ETL_USING_CPP23
     if consteval
     {
       return true;
@@ -2566,85 +3299,116 @@ typedef integral_constant<bool, true>  true_type;
     {
       return false;
     }
-#elif ETL_USING_BUILTIN_IS_CONSTANT_EVALUATED == 1
+  #elif ETL_USING_BUILTIN_IS_CONSTANT_EVALUATED == 1
     // Fallback for C++20 on supported compilers
     return __builtin_is_constant_evaluated();
-#else
+  #else
     // default if unsupported
     return false;
-#endif
+  #endif
   }
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //*********************************
   /// Check if T is a function type
   //*********************************
-  template<typename T>
+  template <typename T>
   struct is_function : etl::false_type
   {
   };
 
   // Plain / cv-qualified
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs...)> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs...)> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs...) const> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs...) const> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs...) volatile> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs...) volatile> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs...) const volatile> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs...) const volatile> : etl::true_type
+  {
+  };
 
   // Variadic
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs..., ...)> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs..., ...)> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs..., ...) const> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs..., ...) const> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs..., ...) volatile> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs..., ...) volatile> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs..., ...) const volatile> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs..., ...) const volatile> : etl::true_type
+  {
+  };
 
-  // noexcept variants (if supported)
-#if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs...) noexcept> : etl::true_type {};
+    // noexcept variants (if supported)
+    #if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs...) noexcept> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs...) const noexcept> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs...) const noexcept> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs...) volatile noexcept> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs...) volatile noexcept> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs...) const volatile noexcept> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs...) const volatile noexcept> : etl::true_type
+  {
+  };
 
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs..., ...) noexcept> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs..., ...) noexcept> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs..., ...) const noexcept> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs..., ...) const noexcept> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs..., ...) volatile noexcept> : etl::true_type
+  {
+  };
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs..., ...) volatile noexcept> : etl::true_type {};
+  template <typename TReturn, typename... TArgs>
+  struct is_function<TReturn(TArgs..., ...) const volatile noexcept> : etl::true_type
+  {
+  };
+    #endif
 
-  template<typename TReturn, typename... TArgs>
-  struct is_function<TReturn(TArgs..., ...) const volatile noexcept> : etl::true_type {};
-#endif
-
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_function_v = etl::is_function<T>::value;
-#endif
-#endif
+    #endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //*********************************
   /// Check for the presence of operator()
   //*********************************
@@ -2660,13 +3424,13 @@ typedef integral_constant<bool, true>  true_type;
     static const bool value = etl::is_same<decltype(test<T>(0)), etl::true_type>::value;
   };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool has_call_operator_v = etl::has_call_operator<T>::value;
-#endif
-#endif
+    #endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //***************************************************************************
   /// Check that there is only one operator()
   //***************************************************************************
@@ -2691,133 +3455,293 @@ typedef integral_constant<bool, true>  true_type;
     static constexpr bool value = decltype(test<etl::decay_t<T>>(0))::value;
   };
 
-#if ETL_USING_CPP17
+    #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool has_unique_call_operator_v = etl::has_unique_call_operator<T>::value;
-#endif
-#endif
+    #endif
+  #endif
 
   //***************************************************************************
   /// Is T a member pointer
   //***************************************************************************
   namespace private_type_traits
   {
-    template<typename T>
-    struct is_member_pointer_helper : etl::false_type {};
+    template <typename T>
+    struct is_member_pointer_helper : etl::false_type
+    {
+    };
 
-    template<typename T, typename TObject>
-    struct is_member_pointer_helper<T TObject::*> : etl::true_type {};
-  }
+    template <typename T, typename TObject>
+    struct is_member_pointer_helper<T TObject::*> : etl::true_type
+    {
+    };
+  } // namespace private_type_traits
 
-  template<typename T> 
-  struct is_member_pointer : private_type_traits::is_member_pointer_helper<typename etl::remove_cv<T>::type> {};
+  template <typename T>
+  struct is_member_pointer : private_type_traits::is_member_pointer_helper<typename etl::remove_cv<T>::type>
+  {
+  };
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_member_pointer_v = etl::is_member_pointer<T>::value;
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //***************************************************************************
   /// Is T a member function pointer
   //***************************************************************************
-  template <typename T> struct is_member_function_pointer : etl::false_type {};
+  template <typename T>
+  struct is_member_function_pointer : etl::false_type
+  {
+  };
 
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...)> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) volatile> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const volatile> : etl::true_type {};
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...)> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) volatile> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const volatile> : etl::true_type
+  {
+  };
 
-#if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) noexcept> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const noexcept> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) volatile noexcept> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const volatile noexcept> : etl::true_type {};
-#endif
+    #if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) volatile noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const volatile noexcept> : etl::true_type
+  {
+  };
+    #endif
 
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) &>                : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const &>          : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) volatile &>       : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const volatile &> : etl::true_type {};
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...)&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) volatile&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const volatile&> : etl::true_type
+  {
+  };
 
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) &&>               : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const &&>         : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) volatile &&>      : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const volatile &&>: etl::true_type {};
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) &&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const&&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) volatile&&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const volatile&&> : etl::true_type
+  {
+  };
 
-#if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) & noexcept>                : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const & noexcept>          : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) volatile & noexcept>       : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const volatile & noexcept> : etl::true_type {};
+    #if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) & noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const & noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) volatile & noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const volatile & noexcept> : etl::true_type
+  {
+  };
 
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) && noexcept>               : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const && noexcept>         : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) volatile && noexcept>      : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs...) const volatile && noexcept>: etl::true_type {};
-#endif
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) && noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const && noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) volatile && noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs...) const volatile && noexcept> : etl::true_type
+  {
+  };
+    #endif
 
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...)> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) volatile> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const volatile> : etl::true_type {};
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...)> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) volatile> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const volatile> : etl::true_type
+  {
+  };
 
-#if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) noexcept> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const noexcept> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) volatile noexcept> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const volatile noexcept> : etl::true_type {};
-#endif
+    #if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) volatile noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const volatile noexcept> : etl::true_type
+  {
+  };
+    #endif
 
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) &>                : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const &>          : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) volatile &>       : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const volatile &> : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) &&>               : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const &&>         : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) volatile &&>      : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const volatile &&>: etl::true_type {};
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...)&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) volatile&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const volatile&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) &&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const&&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) volatile&&> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const volatile&&> : etl::true_type
+  {
+  };
 
-#if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) & noexcept>                : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const & noexcept>          : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) volatile & noexcept>       : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const volatile & noexcept> : etl::true_type {};
+    #if ETL_HAS_NOEXCEPT_FUNCTION_TYPE
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) & noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const & noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) volatile & noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const volatile & noexcept> : etl::true_type
+  {
+  };
 
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) && noexcept>               : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const && noexcept>         : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) volatile && noexcept>      : etl::true_type {};
-  template <typename TReturn, typename TObject, typename... TArgs> struct is_member_function_pointer<TReturn(TObject::*)(TArgs..., ...) const volatile && noexcept>: etl::true_type {};
-#endif
-#endif
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) && noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const && noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) volatile && noexcept> : etl::true_type
+  {
+  };
+  template <typename TReturn, typename TObject, typename... TArgs>
+  struct is_member_function_pointer<TReturn (TObject::*)(TArgs..., ...) const volatile && noexcept> : etl::true_type
+  {
+  };
+    #endif
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_member_function_pointer_v = etl::is_member_function_pointer<T>::value;
-#endif
+  #endif
 
-#if ETL_USING_CPP11
+  #if ETL_USING_CPP11
   //***************************************************************************
   /// Is T a member object pointer
   //***************************************************************************
   namespace private_type_traits
   {
-    template<typename> 
-    struct is_member_object_pointer_helper : public etl::false_type {};
+    template <typename>
+    struct is_member_object_pointer_helper : public etl::false_type
+    {
+    };
 
-    template<typename T, typename TObject> 
-    struct is_member_object_pointer_helper<T TObject::*> : public etl::negation<etl::is_function<T>> {};
-  }
+    template <typename T, typename TObject>
+    struct is_member_object_pointer_helper<T TObject::*> : public etl::negation<etl::is_function<T>>
+    {
+    };
+  } // namespace private_type_traits
 
-  template<typename T> struct is_member_object_pointer : public private_type_traits::is_member_object_pointer_helper<etl::remove_cv_t<T>>::type {};
-#endif
+  template <typename T>
+  struct is_member_object_pointer : public private_type_traits::is_member_object_pointer_helper<etl::remove_cv_t<T>>::type
+  {
+  };
+  #endif
 
-#if ETL_USING_CPP17
+  #if ETL_USING_CPP17
   template <typename T>
   inline constexpr bool is_member_object_pointer_v = etl::is_member_object_pointer<T>::value;
-#endif
+  #endif
 
-#if ETL_USING_CPP20
+  #if ETL_USING_CPP20
   template <class... TArgs>
   struct common_reference;
 
@@ -2919,8 +3843,7 @@ typedef integral_constant<bool, true>  true_type;
     using cv_cond_res = cond_res<copy_cv_t<T1, T2>&, copy_cv_t<T2, T1>&>;
 
     template <class T1, class T2, class T1_RR, class T2_RR>
-      requires requires { typename cv_cond_res<T1_RR, T2_RR>; } &&
-        is_reference_v<cv_cond_res<T1_RR, T2_RR>>
+      requires requires { typename cv_cond_res<T1_RR, T2_RR>; } && is_reference_v<cv_cond_res<T1_RR, T2_RR>>
     struct common_ref<T1&, T2&, T1_RR, T2_RR>
     {
       using type = cv_cond_res<T1_RR, T2_RR>;
@@ -2930,9 +3853,7 @@ typedef integral_constant<bool, true>  true_type;
     using common_ref_rr = remove_reference_t<common_ref_t<T1&, T2&>>&&;
 
     template <class T1, class T2, class T1_R, class T2_R>
-      requires requires { typename common_ref_rr<T1_R, T2_R>; } &&
-        is_convertible_v<T1&&, common_ref_rr<T1_R, T2_R>> &&
-        is_convertible_v<T2&&, common_ref_rr<T1_R, T2_R>>
+      requires requires { typename common_ref_rr<T1_R, T2_R>; } && is_convertible_v<T1&&, common_ref_rr<T1_R, T2_R>> && is_convertible_v<T2&&, common_ref_rr<T1_R, T2_R>>
     struct common_ref<T1&&, T2&&, T1_R, T2_R>
     {
       using type = common_ref_rr<T1_R, T2_R>;
@@ -2942,15 +3863,14 @@ typedef integral_constant<bool, true>  true_type;
     using common_ref_cr = common_ref_t<const T1&, T2&>;
 
     template <class T1, class T2, class T3, class T4>
-      requires requires { typename common_ref_cr<T3, T4>; } &&
-        is_convertible_v<T1&&, common_ref_cr<T3, T4>>
+      requires requires { typename common_ref_cr<T3, T4>; } && is_convertible_v<T1&&, common_ref_cr<T3, T4>>
     struct common_ref<T1&&, T2&, T3, T4>
     {
       using type = common_ref_cr<T3, T4>;
     };
 
     template <class T1, class T2, class T3, class T4>
-    struct common_ref<T1&, T2&&, T3, T4>: common_ref<T2&&, T1&>
+    struct common_ref<T1&, T2&&, T3, T4> : common_ref<T2&&, T1&>
     {
     };
 
@@ -2963,28 +3883,26 @@ typedef integral_constant<bool, true>  true_type;
     struct common_reference_impl3;
 
     template <class T1, class T2>
-    struct common_reference_impl2: common_reference_impl3<T1, T2>
+    struct common_reference_impl2 : common_reference_impl3<T1, T2>
     {
     };
 
     template <class T1, class T2>
-    struct common_reference_impl1: common_reference_impl2<T1, T2>
+    struct common_reference_impl1 : common_reference_impl2<T1, T2>
     {
     };
-  }
+  } // namespace private_type_traits
 
   // If sizeof...(T) is 2
   template <class T1, class T2>
-  struct common_reference<T1, T2>: private_type_traits::common_reference_impl1<T1, T2>
+  struct common_reference<T1, T2> : private_type_traits::common_reference_impl1<T1, T2>
   {
   };
 
   namespace private_type_traits
   {
     template <class T1, class T2>
-      requires is_reference_v<T1> && is_reference_v<T2> && requires { typename common_ref_t<T1, T2>; } &&
-               is_convertible_v<add_pointer_t<T1>, add_pointer_t<common_ref_t<T1, T2>>> &&
-               is_convertible_v<add_pointer_t<T2>, add_pointer_t<common_ref_t<T1, T2>>>
+      requires is_reference_v<T1> && is_reference_v<T2> && requires { typename common_ref_t<T1, T2>; } && is_convertible_v<add_pointer_t<T1>, add_pointer_t<common_ref_t<T1, T2>>> && is_convertible_v<add_pointer_t<T2>, add_pointer_t<common_ref_t<T1, T2>>>
     struct common_reference_impl1<T1, T2>
     {
       using type = common_ref_t<T1, T2>;
@@ -3012,31 +3930,33 @@ typedef integral_constant<bool, true>  true_type;
     };
 
     template <class T1, class T2>
-    struct common_reference_impl3: common_type<T1, T2>
+    struct common_reference_impl3 : common_type<T1, T2>
     {
     };
-  }
+  } // namespace private_type_traits
 
   template <class T1, class T2, class T3, class... TArgs>
     requires requires { typename common_reference_t<T1, T2>; }
-  struct common_reference<T1, T2, T3, TArgs...> : common_reference<common_reference_t<T1, T2>, T3, TArgs...> {};
+  struct common_reference<T1, T2, T3, TArgs...> : common_reference<common_reference_t<T1, T2>, T3, TArgs...>
+  {
+  };
 
-  template<class... TArgs>
+  template <class... TArgs>
   struct common_reference
   {
   };
 
-#endif
-}
+  #endif
+} // namespace etl
 
-// Helper macros
-#define ETL_IS_CHAR_TYPE(type)        (etl::is_same<char, type>::value || etl::is_same<signed char, type>::value || etl::is_same<unsigned char, type>::value)
-#define ETL_IS_NOT_CHAR_TYPE(type)    (!ETL_IS_CHAR_TYPE(type))
+  // Helper macros
+  #define ETL_IS_CHAR_TYPE(type)     (etl::is_same<char, type>::value || etl::is_same<signed char, type>::value || etl::is_same<unsigned char, type>::value)
+  #define ETL_IS_NOT_CHAR_TYPE(type) (!ETL_IS_CHAR_TYPE(type))
 
-#define ETL_IS_POINTER_TYPE(type)     (etl::is_pointer<type>::value)
-#define ETL_IS_NOT_POINTER_TYPE(type) (!ETL_IS_POINTER_TYPE(type))
+  #define ETL_IS_POINTER_TYPE(type)     (etl::is_pointer<type>::value)
+  #define ETL_IS_NOT_POINTER_TYPE(type) (!ETL_IS_POINTER_TYPE(type))
 
-#define ETL_TARGET_IS_TRIVIALLY_COPYABLE(type)     (etl::is_trivially_copyable<typename etl::iterator_traits<type>::value_type>::value)
-#define ETL_TARGET_IS_NOT_TRIVIALLY_COPYABLE(type) (!ETL_TARGET_IS_TRIVIALLY_COPYABLE(type))
+  #define ETL_TARGET_IS_TRIVIALLY_COPYABLE(type)     (etl::is_trivially_copyable<typename etl::iterator_traits<type>::value_type>::value)
+  #define ETL_TARGET_IS_NOT_TRIVIALLY_COPYABLE(type) (!ETL_TARGET_IS_TRIVIALLY_COPYABLE(type))
 
 #endif // ETL_TYPE_TRAITS_INCLUDED
diff --git a/include/etl/variant_pool.h b/include/etl/variant_pool.h
index c0bc2161..745f9980 100644
--- a/include/etl/variant_pool.h
+++ b/include/etl/variant_pool.h
@@ -27,7 +27,7 @@ SOFTWARE.
 ******************************************************************************/
 
 #if 0
-#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
+  #error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
 #endif
 
 //***************************************************************************
@@ -49,21 +49,21 @@ SOFTWARE.
 //***************************************************************************
 
 #ifndef ETL_VARIANT_POOL_INCLUDED
-#define ETL_VARIANT_POOL_INCLUDED
+  #define ETL_VARIANT_POOL_INCLUDED
 
-#include "platform.h"
-#include "pool.h"
-#include "type_traits.h"
-#include "static_assert.h"
-#include "largest.h"
+  #include "platform.h"
+  #include "largest.h"
+  #include "pool.h"
+  #include "static_assert.h"
+  #include "type_traits.h"
 
-#include <stdint.h>
+  #include <stdint.h>
 
 namespace etl
 {
-#if ETL_USING_CPP11 && !defined(ETL_VARIANT_POOL_FORCE_CPP03_IMPLEMENTATION)
+  #if ETL_USING_CPP11 && !defined(ETL_VARIANT_POOL_FORCE_CPP03_IMPLEMENTATION)
   //***************************************************************************
-  template <size_t MAX_SIZE_, typename ... Ts>
+  template <size_t MAX_SIZE_, typename... Ts>
   class variant_pool
     : public etl::generic_pool<etl::largest<Ts...>::size,
                                etl::largest<Ts...>::alignment,
@@ -73,7 +73,8 @@ namespace etl
 
     typedef etl::generic_pool<etl::largest<Ts...>::size,
                               etl::largest<Ts...>::alignment,
-                              MAX_SIZE_> base_t;
+                              MAX_SIZE_>
+      base_t;
 
     static const size_t MAX_SIZE = MAX_SIZE_;
 
@@ -117,11 +118,11 @@ namespace etl
   private:
 
     variant_pool(const variant_pool&) ETL_DELETE;
-    variant_pool& operator =(const variant_pool&) ETL_DELETE;
+    variant_pool& operator=(const variant_pool&) ETL_DELETE;
   };
 
   //***************************************************************************
-  template <typename ... Ts>
+  template <typename... Ts>
   class variant_pool_ext
     : public etl::generic_pool_ext<etl::largest<Ts...>::size,
                                    etl::largest<Ts...>::alignment>
@@ -129,7 +130,8 @@ namespace etl
   public:
 
     typedef etl::generic_pool_ext<etl::largest<Ts...>::size,
-                                  etl::largest<Ts...>::alignment> base_t;
+                                  etl::largest<Ts...>::alignment>
+      base_t;
 
     //*************************************************************************
     /// Default constructor.
@@ -172,20 +174,20 @@ namespace etl
   private:
 
     variant_pool_ext(const variant_pool_ext&) ETL_DELETE;
-    variant_pool_ext& operator =(const variant_pool_ext&) ETL_DELETE;
+    variant_pool_ext& operator=(const variant_pool_ext&) ETL_DELETE;
   };
-#else
+  #else
   //***************************************************************************
   template <size_t MAX_SIZE_,
             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 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,
@@ -202,7 +204,8 @@ namespace etl
 
     typedef etl::generic_pool<etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::size,
                               etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::alignment,
-                              MAX_SIZE_> base_t;
+                              MAX_SIZE_>
+      base_t;
 
     static const size_t MAX_SIZE = MAX_SIZE_;
 
@@ -213,7 +216,7 @@ namespace etl
     {
     }
 
-#if ETL_CPP11_NOT_SUPPORTED || ETL_USING_STLPORT
+    #if ETL_CPP11_NOT_SUPPORTED || ETL_USING_STLPORT
     //*************************************************************************
     /// Creates the object. Default constructor.
     //*************************************************************************
@@ -268,7 +271,7 @@ namespace etl
 
       return base_t::template create<T>(p1, p2, p3, p4);
     }
-#else
+    #else
     //*************************************************************************
     /// Creates the object from a type. Variadic parameter constructor.
     //*************************************************************************
@@ -279,7 +282,7 @@ namespace etl
 
       return base_t::template create<T>(etl::forward<Args>(args)...);
     }
-#endif
+    #endif
 
     //*************************************************************************
     /// Destroys the object.
@@ -287,23 +290,12 @@ namespace etl
     template <typename T>
     void destroy(const T* const p)
     {
-      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 ||
-                         etl::is_base_of<T, T1>::value ||
-                         etl::is_base_of<T, T2>::value ||
-                         etl::is_base_of<T, T3>::value ||
-                         etl::is_base_of<T, T4>::value ||
-                         etl::is_base_of<T, T5>::value ||
-                         etl::is_base_of<T, T6>::value ||
-                         etl::is_base_of<T, T7>::value ||
-                         etl::is_base_of<T, T8>::value ||
-                         etl::is_base_of<T, T9>::value ||
-                         etl::is_base_of<T, T10>::value ||
-                         etl::is_base_of<T, T11>::value ||
-                         etl::is_base_of<T, T12>::value ||
-                         etl::is_base_of<T, T13>::value ||
-                         etl::is_base_of<T, T14>::value ||
-                         etl::is_base_of<T, T15>::value ||
-                         etl::is_base_of<T, T16>::value), "Invalid type");
+      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
+                         || etl::is_base_of<T, T1>::value || etl::is_base_of<T, T2>::value || etl::is_base_of<T, T3>::value || etl::is_base_of<T, T4>::value
+                         || etl::is_base_of<T, T5>::value || etl::is_base_of<T, T6>::value || etl::is_base_of<T, T7>::value || etl::is_base_of<T, T8>::value
+                         || etl::is_base_of<T, T9>::value || etl::is_base_of<T, T10>::value || etl::is_base_of<T, T11>::value || etl::is_base_of<T, T12>::value
+                         || etl::is_base_of<T, T13>::value || etl::is_base_of<T, T14>::value || etl::is_base_of<T, T15>::value || etl::is_base_of<T, T16>::value),
+                        "Invalid type");
 
       base_t::destroy(p);
     }
@@ -319,19 +311,19 @@ namespace etl
   private:
 
     variant_pool(const variant_pool&) ETL_DELETE;
-    variant_pool& operator =(const variant_pool&) ETL_DELETE;
+    variant_pool& operator=(const variant_pool&) ETL_DELETE;
   };
 
   //***************************************************************************
   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 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,
@@ -346,17 +338,18 @@ namespace etl
   public:
 
     typedef etl::generic_pool_ext<etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::size,
-                                  etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::alignment> base_t;
+                                  etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::alignment>
+      base_t;
 
     //*************************************************************************
     /// Default constructor.
     //*************************************************************************
     variant_pool_ext(typename base_t::element* buffer, size_t size)
-      : base_t(buffer, size) 
+      : base_t(buffer, size)
     {
     }
 
-#if ETL_CPP11_NOT_SUPPORTED || ETL_USING_STLPORT
+    #if ETL_CPP11_NOT_SUPPORTED || ETL_USING_STLPORT
     //*************************************************************************
     /// Creates the object. Default constructor.
     //*************************************************************************
@@ -411,7 +404,7 @@ namespace etl
 
       return base_t::template create<T>(p1, p2, p3, p4);
     }
-#else
+    #else
     //*************************************************************************
     /// Creates the object from a type. Variadic parameter constructor.
     //*************************************************************************
@@ -422,7 +415,7 @@ namespace etl
 
       return base_t::template create<T>(etl::forward<Args>(args)...);
     }
-#endif
+    #endif
 
     //*************************************************************************
     /// Destroys the object.
@@ -430,23 +423,12 @@ namespace etl
     template <typename T>
     void destroy(const T* const p)
     {
-      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 ||
-                         etl::is_base_of<T, T1>::value ||
-                         etl::is_base_of<T, T2>::value ||
-                         etl::is_base_of<T, T3>::value ||
-                         etl::is_base_of<T, T4>::value ||
-                         etl::is_base_of<T, T5>::value ||
-                         etl::is_base_of<T, T6>::value ||
-                         etl::is_base_of<T, T7>::value ||
-                         etl::is_base_of<T, T8>::value ||
-                         etl::is_base_of<T, T9>::value ||
-                         etl::is_base_of<T, T10>::value ||
-                         etl::is_base_of<T, T11>::value ||
-                         etl::is_base_of<T, T12>::value ||
-                         etl::is_base_of<T, T13>::value ||
-                         etl::is_base_of<T, T14>::value ||
-                         etl::is_base_of<T, T15>::value ||
-                         etl::is_base_of<T, T16>::value), "Invalid type");
+      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
+                         || etl::is_base_of<T, T1>::value || etl::is_base_of<T, T2>::value || etl::is_base_of<T, T3>::value || etl::is_base_of<T, T4>::value
+                         || etl::is_base_of<T, T5>::value || etl::is_base_of<T, T6>::value || etl::is_base_of<T, T7>::value || etl::is_base_of<T, T8>::value
+                         || etl::is_base_of<T, T9>::value || etl::is_base_of<T, T10>::value || etl::is_base_of<T, T11>::value || etl::is_base_of<T, T12>::value
+                         || etl::is_base_of<T, T13>::value || etl::is_base_of<T, T14>::value || etl::is_base_of<T, T15>::value || etl::is_base_of<T, T16>::value),
+                        "Invalid type");
 
       base_t::destroy(p);
     }
@@ -454,17 +436,17 @@ namespace etl
     //*************************************************************************
     /// Returns the maximum number of items in the variant_pool.
     //*************************************************************************
-    size_t max_size() const 
-    { 
-      return base_t::max_size(); 
+    size_t max_size() const
+    {
+      return base_t::max_size();
     }
 
   private:
 
     variant_pool_ext(const variant_pool_ext&) ETL_DELETE;
-    variant_pool_ext& operator =(const variant_pool_ext&) ETL_DELETE;
+    variant_pool_ext& operator=(const variant_pool_ext&) ETL_DELETE;
   };
-#endif
-}
+  #endif
+} // namespace etl
 
 #endif