Made uuid in jetfix configurable.

.gitignore

@@ -37,3 +37,4 @@ trace_data/
 *.rej
 /build
 .clangd/
+/.cache/

src/client/spark/Modules/Market/TimeAndSales/TimeAndSalesRowVM.cs

@@ -1,6 +1,7 @@
 using bts.api;
 using bts.co2;
 using bts.utils;
+using bts.utils.csv;
 using mbts;
 using mbts.spark;
 using mbts.ui.controls;
@@ -49,6 +50,18 @@ namespace bts.shell.time_and_sales {
       public void raise_invalidated() =>
          invalidated?.Invoke();
 
+      public static System.Collections.Specialized.OrderedDictionary csv_ordered_properties =>
+            CsvHelper.create_ordering_maintainer(
+               typeof(TimeAndSalesRowVM),
+               new string[] {
+                  nameof(security),
+                  nameof(time),
+                  nameof(price),
+                  nameof(size),
+                  nameof(aggressor_side),
+                  nameof(security_key),
+               });
+
       public bool Equals(TimeAndSalesRowVM other) =>
          other != null &&
          row_key == other.row_key;

src/client/spark/Modules/Market/TimeAndSales/TimeAndSalesWindow.cs

@@ -2,6 +2,7 @@
 using bts.shell.fills;
 using bts.spark;
 using bts.view;
+using bts.utils.csv;
 using mbts;
 using mbts.co2;
 using mbts.persist;
@@ -124,6 +125,8 @@ namespace bts.shell.time_and_sales {
             show_in_context_menu = _can_pause_updates
          };
          _commands = new SparkCommand[] {
+            // csv export
+            new SparkCommandCommand("Export to csv", Icons.Export, FileDialogCommand.export_csv(() => _vm.rows.ToCsv(TimeAndSalesRowVM.csv_ordered_properties), "TaS")),
             // ladder
             SparkCommands.ShowLadderAutoLookup(SparkCommands.KeyGestures.ShowLadder)
                .complete(current_sec_key_src, sec_keys => sec_keys.Count > 0),

src/client/spark/Modules/Trading/Fills/FillsVM.cs

@@ -5,6 +5,7 @@ using bts.collections;
 using bts.shell.fills;
 using bts.spark;
 using bts.utils;
+using bts.utils.csv;
 using mbts.collections;
 using mbts.persist;
 using mbts.spark.filters;
@@ -333,6 +334,27 @@ namespace mbts.spark {
          public override bool Equals(object obj) => Equals(obj as Row);
          public override int GetHashCode() => _fill.FillKey.GetHashCode() ^ _order.Key.GetHashCode();
 
+         public static System.Collections.Specialized.OrderedDictionary csv_ordered_properties =>
+            CsvHelper.create_ordering_maintainer(typeof(Row),
+               new string[] {
+                  nameof(security),
+                  nameof(order_type),
+                  nameof(root_algo_display_name),
+                  nameof(side),
+                  nameof(fill_time),
+                  nameof(user),
+                  nameof(account),
+                  nameof(exchange),
+                  nameof(time_in_force),
+                  nameof(size),
+                  nameof(price),
+                  nameof(fill_kind),
+                  nameof(fill_status),
+                  nameof(fill_key),
+                  nameof(order_key),
+                  nameof(security_key)
+               });
+
          public event Action invalidated;
          void IRowVM.raise_invalidated() => invalidated?.Invoke();
       }

src/client/spark/Modules/Trading/Fills/FillsWindow.cs

@@ -4,6 +4,7 @@ using bts.shell;
 using bts.shell.fills;
 using bts.spark;
 using bts.view;
+using bts.utils.csv;
 using mbts.persist;
 using mbts.ui;
 using mbts.ui.settings;
@@ -61,6 +62,7 @@ namespace mbts.spark {
          _view = new FillsView { DataContext = _vm };
 
          _commands = new List<SparkCommand> {
+            new SparkCommandCommand("Export to csv", Icons.Export, FileDialogCommand.export_csv(() => _vm.rows.ToCsv(FillsVM.Row.csv_ordered_properties), "Fills")),
             // wrap the grid settings view factory in a dialogCommand here since the vm is destroyed/recreated when the security criteria changes
             SparkCommands.window_settings_command(new DialogCommand(() => {
                var vm = new ShellSettingsDialogVM<GridSettings, SimpleGridSettingsVM>(

src/client/spark/Modules/Trading/OrderBook/OrderBookRowVM.cs

@@ -4,6 +4,7 @@ using bts.api.orderman;
 using bts.collections;
 using bts.spark;
 using bts.utils;
+using bts.utils.csv;
 using mbts.ui;
 using mbts.ui.controls;
 using System;
@@ -11,6 +12,7 @@ using System.Collections.Generic;
 using System.ComponentModel;
 using System.Reactive.Linq;
 using System.Runtime.CompilerServices;
+using System.Linq;
 using System.Windows.Input;
 using System.Windows.Media;
 using Columns = mbts.spark.OrderBookGridView.ColumnKeys;
@@ -60,6 +62,35 @@ namespace mbts.spark {
       public event Action<(OrderSecurityRootPair oldval, OrderSecurityRootPair newval)> updated;
       public event PropertyChangedEventHandler PropertyChanged;
 
+      public static System.Collections.Specialized.OrderedDictionary csv_ordered_properties =>
+            CsvHelper.create_ordering_maintainer(
+               typeof(OrderBookRowVM), 
+               new string[] {
+                  nameof(security_text),
+                  nameof(symbol),
+                  nameof(time_created),
+                  nameof(last_change),
+                  nameof(user),
+                  nameof(account),
+                  nameof(exchange),
+                  nameof(time_in_force),
+                  nameof(order_type),
+                  nameof(root_algo_display_name),
+                  nameof(order_sub_type),
+                  nameof(side),
+                  nameof(quantity),
+                  nameof(filled_quantity),
+                  nameof(price),
+                  nameof(avg_price),
+                  nameof(last_price),
+                  nameof(piq),
+                  nameof(status),
+                  // last message (could contains commas, so skipping)
+                  nameof(security_key),
+                  nameof(order_key),
+                  nameof(parent_order_key),
+               });
+
       // Core
       public OrderSecurityRootPair order_tuple { get; private set; }
       public OrderRecordImmutable order => order_tuple.order.order;

src/client/spark/Modules/Trading/OrderBook/OrderBookWindow.cs

@@ -6,6 +6,7 @@ using bts.shell.fills;
 using bts.shell.orderbook;
 using bts.spark;
 using bts.view;
+using bts.utils.csv;
 using mbts.persist;
 using mbts.spark.utilities;
 using mbts.ui;
@@ -231,6 +232,7 @@ namespace mbts.spark {
             toggle_collapse_all_command,
             toggle_expand_all_command,
             show_grid_settings_command,
+            new SparkCommandCommand("Export to csv", Icons.Export, FileDialogCommand.export_csv(() => _vm.rows.ToCsv(OrderBookRowVM.csv_ordered_properties), "OrderBook")),
             // hidden cmds (i.e., keyboard shortcuts at window level)
             hidden_cmd(new SparkCommandCommand(OrderBookView.CommandDescriptions.ModifyOrders, null, _vm.modify_selected_orders_cmd, OrderBookView.KeyboardShortcuts.ModifyOrders)),
             hidden_cmd(new SparkCommandCommand(OrderBookView.CommandDescriptions.RevertOrders, null, _vm.revert_selected_orders_cmd, OrderBookView.KeyboardShortcuts.RevertOrders)),

src/client/spark/view/Extensions/Command/FileDialogCommand.cs

@@ -64,6 +64,25 @@ namespace mbts.ui {
             }
          }, can_execute == null ? null : new Func<object, bool>(_ => can_execute()));
 
+      public static IDialogCommand export_csv(
+         Func<string> get_file_content,
+         string source_window_name) =>
+         new AnonymousFileDialogCommand<object>(_ =>
+            _create_save_file_dialog(
+               Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
+               $"BTS_Spark_{source_window_name}_{DateTime.Now.ToString("yyyyMMdd_HHmm")}.csv",
+               new[] { ("CSV (comma delimited)", new string[] { "csv" }) }
+            ),
+            (_, file) => {
+               try {
+                  File.WriteAllText(file, get_file_content.Invoke());
+               } catch (Exception ex) {
+                  BTSMessageBox.Show($"Error exporting data to csv: {ex}.", "CSV Export Error", BTSMessageBoxButtons.OK, System.Windows.MessageBoxImage.Error, true, false, true);
+               }
+            },
+            // we are always able to perform an export, even when no rows (it will just be a header)
+            (_) => true);
+
       static TDialog _create_file_dialog<TDialog>(string initial_dir = null, IReadOnlyList<(string name, string[] extensions)> filter_items = null) where TDialog : FileDialog, new() {
          var rv = new TDialog();
          if (!string.IsNullOrEmpty(initial_dir))

src/client/spark_core/utils/CsvHelper.cs

@@ -0,0 +1,52 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Reflection;
+
+namespace bts.utils.csv {
+   public static class CsvHelper {
+
+      public static string ToCsv<T>(this IEnumerable<T> items, OrderedDictionary properties = null) where T : class {
+         var output = "";
+         var delimiter = ",";
+         if (properties == null) {
+            properties = new OrderedDictionary();
+            foreach (var pi in typeof(T).GetProperties()) {
+               properties.Add(pi.Name, pi);
+            }
+         }
+
+         using (var sw = new StringWriter()) {
+            var dict_values = properties.Values.OfType<PropertyInfo>();
+            var header = dict_values.Select(n => n.Name).Aggregate((first, second) => first + delimiter + second);
+            sw.WriteLine(header);
+            foreach (var i in items) {
+               var row = dict_values.Select(x => x.GetValue(i, null))
+                  .Select(x => x == null ? "null" : x.ToString())
+                  .Aggregate((first, second) => first + delimiter + second);
+               sw.WriteLine(row);
+            }
+            output = sw.ToString();
+         }
+         return output;
+      }
+
+      public static OrderedDictionary create_ordering_maintainer(Type t, string[] property_names_in_order) {
+         OrderedDictionary od = new OrderedDictionary();
+         var props = t.GetProperties();
+         foreach (var n in property_names_in_order) {
+            var query = props.Where(pi => pi.Name == n);
+            if (query.Any()) {
+               var property_info = query.First();
+               if (!od.Contains(property_info)) {
+                  od.Add(n, property_info);
+               }
+            }
+         }
+         return od;
+      }
+
+   }
+}

src/lib/config/defaults/keycode.conf

@@ -1,10 +1,10 @@
-#nusers: 1
+#nusers: 100
 #allow concurrent : true
-#expires: 2021-Jan-01 00:00:00   637450560000000000
-#generation_time: 2020-Apr-03 18:39:31.010863   5248901378137496534
+#expires: 2022-Jun-01 00:00:00   637896384000000000
+#generation_time: 2021-Mar-25 15:21:51.824504   5249208843545632944
 EncryptedKeyCode {
    value {
-      keycode: "BJBQWsbdTXWa/iLmOf3ekE8vP/NYkf0Q/nUsp/rJ78Ze3W9pNXICCMabmmsr1xOM7aqRIclPgZd955uSSfvFkdNWFTxwPQ5IfnDGopj3QdhUVxhzgVLaXHN+vC0H/MWrDQ5K4WY5J/6VXgUn1LSN/2HNb5iR2sKXeh3Alamg87YtCWEi+scelffE7HK5ERT/3A3Y/e0pqUFhP6xouIjHRhC2FRBb6OoJQVvFwVDADSuKZNo9B6GhC3H0YdHqjFhGDoky5ecgzeKIX8uWJEQNnQXQJ0iTgQ95+YR5IMU+XWdlVfSrc0fuTmj3YWcBQ8Kl2ItEcobyZzJYega3tu6Ftw=="
+      keycode: "HdVz7cDRyofLl3vA8TPulaIHkquYzq24QTXThZccEpZkvk5mDF5dKkQa9fWG5JOWnswNZVfVct0bpHG99X3XHDTdhHyZy0xb+eEI4PS50vaHQGw3fHmFh/ku9EwLxMZZYCEnhelsg2LADjIG8ebqsgmVi6asHZo70nZCaIXzwu8KCjak/sD7K2EP5odhnRpPL4JdsSkgUAwmrr0V17pFxH1RmTS6pXYUvko3DTOIM8yudWabVlSrdmcsnCEzHN5WbZiMdPNEykhEdEtKM58TR9tVnk+JuDIU8uczEQsLK2tT1VVoleGLc5TM/p8jhWokkvr8WdbToIGaalhp72VG6g=="
    }
 }
 

src/lib/config/protos/jetfix.proto

@@ -88,6 +88,7 @@ message JetFIX {
     optional uint32 max_connection_attempts = 346               [default=10];
     optional bool auto_fix_seq_num = 347                        [default=false];
     optional bool use_ilink3       = 348                        [default=false] ;
+    optional uint32 uuid_offset = 349                           [default=0];
    }
 
   repeated Connection connection = 10;

src/lib/jetfix/store/session_name.cpp

@@ -129,11 +129,14 @@ SessionName session_name (config::JetFIX::Connection const &session_cfg)
    
    if (session_cfg.has_start_day ()) {
       bts_assert (session_cfg.has_end_day ());
-      return session_name (now,
-                           parse_weekday (session_cfg.start_day ()),
-                           parse_time (session_cfg.start_time ()),
-                           parse_weekday (session_cfg.end_day ()),
-                           parse_time (session_cfg.end_time ()));
+      auto sn = 
+         session_name (now,
+                       parse_weekday (session_cfg.start_day ()),
+                       parse_time (session_cfg.start_time ()),
+                       parse_weekday (session_cfg.end_day ()),
+                       parse_time (session_cfg.end_time ()));
+      sn.as_uint64_t += session_cfg.uuid_offset();
+      return sn;
    } else 
       return session_name (now,
                            parse_time (session_cfg.start_time ()),

src/lib/orderman/actors/ilink3/generated/AvgPxInd.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,26 +94,26 @@ class AvgPxInd
 public:
     enum Value
     {
-        NoAveragePricing = (std::uint8_t)0,
-        TradeispartofanAveragePriceGroupIdentifiedbytheAvgPxGrpID = (std::uint8_t)1,
-        TradeispartofaNotionalValueAveragePriceGroup = (std::uint8_t)3,
-        NULL_VALUE = (std::uint8_t)255
+        NoAveragePricing = static_cast<std::uint8_t>(0),
+        TradeispartofanAveragePriceGroupIdentifiedbytheAvgPxGrpID = static_cast<std::uint8_t>(1),
+        TradeispartofaNotionalValueAveragePriceGroup = static_cast<std::uint8_t>(3),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static AvgPxInd::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 0: return NoAveragePricing;
-            case 1: return TradeispartofanAveragePriceGroupIdentifiedbytheAvgPxGrpID;
-            case 3: return TradeispartofaNotionalValueAveragePriceGroup;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(0): return NoAveragePricing;
+            case static_cast<std::uint8_t>(1): return TradeispartofanAveragePriceGroupIdentifiedbytheAvgPxGrpID;
+            case static_cast<std::uint8_t>(3): return TradeispartofaNotionalValueAveragePriceGroup;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum AvgPxInd [E103]");
     }
 
-    static const char* c_str(const AvgPxInd::Value value)
+    static const char *c_str(const AvgPxInd::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/BooleanFlag.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class BooleanFlag
 public:
     enum Value
     {
-        False = (std::uint8_t)0,
-        True = (std::uint8_t)1,
-        NULL_VALUE = (std::uint8_t)255
+        False = static_cast<std::uint8_t>(0),
+        True = static_cast<std::uint8_t>(1),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static BooleanFlag::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 0: return False;
-            case 1: return True;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(0): return False;
+            case static_cast<std::uint8_t>(1): return True;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum BooleanFlag [E103]");
     }
 
-    static const char* c_str(const BooleanFlag::Value value)
+    static const char *c_str(const BooleanFlag::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/BooleanNULL.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class BooleanNULL
 public:
     enum Value
     {
-        False = (std::uint8_t)0,
-        True = (std::uint8_t)1,
-        NULL_VALUE = (std::uint8_t)255
+        False = static_cast<std::uint8_t>(0),
+        True = static_cast<std::uint8_t>(1),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static BooleanNULL::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 0: return False;
-            case 1: return True;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(0): return False;
+            case static_cast<std::uint8_t>(1): return True;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum BooleanNULL [E103]");
     }
 
-    static const char* c_str(const BooleanNULL::Value value)
+    static const char *c_str(const BooleanNULL::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/BusinessReject521.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(330);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(521);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     BusinessReject521() = default;
 
     BusinessReject521(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)330;
+        return static_cast<std::uint16_t>(330);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)521;
+        return static_cast<std::uint16_t>(521);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "j";
     }
@@ -258,7 +260,7 @@ public:
 
     BusinessReject521 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = BusinessReject521(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        BusinessReject521 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        BusinessReject521 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -381,12 +382,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -452,12 +453,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -518,17 +519,17 @@ public:
 
     static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT
@@ -582,7 +583,7 @@ public:
             throw std::runtime_error("length too large for getText [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -595,7 +596,7 @@ public:
     SBE_NODISCARD std::string getTextAsString() const
     {
         const char *buffer = m_buffer + m_offset + 12;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 256 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -640,7 +641,7 @@ public:
     SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 12;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 256 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -652,14 +653,14 @@ public:
     #if __cplusplus >= 201703L
     BusinessReject521 &putText(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 256)
         {
             throw std::runtime_error("string too large for putText [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength);
-        for (size_t start = srcLength; start < 256; ++start)
+        for (std::size_t start = srcLength; start < 256; ++start)
         {
             m_buffer[m_offset + 12 + start] = 0;
         }
@@ -669,14 +670,14 @@ public:
     #else
     BusinessReject521 &putText(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 256)
         {
             throw std::runtime_error("string too large for putText [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 256; ++start)
+        for (std::size_t start = srcLength; start < 256; ++start)
         {
             m_buffer[m_offset + 12 + start] = 0;
         }
@@ -685,7 +686,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -724,17 +725,17 @@ public:
 
     static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -788,7 +789,7 @@ public:
             throw std::runtime_error("length too large for getSenderID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 268, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 268, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -801,7 +802,7 @@ public:
     SBE_NODISCARD std::string getSenderIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 268;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -846,7 +847,7 @@ public:
     SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 268;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -858,14 +859,14 @@ public:
     #if __cplusplus >= 201703L
     BusinessReject521 &putSenderID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 268 + start] = 0;
         }
@@ -875,14 +876,14 @@ public:
     #else
     BusinessReject521 &putSenderID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 268 + start] = 0;
         }
@@ -891,7 +892,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -930,17 +931,17 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT
     {
-        return 0xffffffffffffffffL;
+        return UINT64_C(0xffffffffffffffff);
     }
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -962,7 +963,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1006,12 +1007,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1033,7 +1034,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * BusinessRejectRefIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *BusinessRejectRefIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1072,17 +1073,17 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t businessRejectRefIDNullValue() SBE_NOEXCEPT
     {
-        return 0xffffffffffffffffL;
+        return UINT64_C(0xffffffffffffffff);
     }
 
     static SBE_CONSTEXPR std::uint64_t businessRejectRefIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t businessRejectRefIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t businessRejectRefIDEncodingLength() SBE_NOEXCEPT
@@ -1104,7 +1105,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1143,17 +1144,17 @@ public:
 
     static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1207,7 +1208,7 @@ public:
             throw std::runtime_error("length too large for getLocation [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 312, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 312, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1220,7 +1221,7 @@ public:
     SBE_NODISCARD std::string getLocationAsString() const
     {
         const char *buffer = m_buffer + m_offset + 312;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1265,7 +1266,7 @@ public:
     SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 312;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1277,14 +1278,14 @@ public:
     #if __cplusplus >= 201703L
     BusinessReject521 &putLocation(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 312, str.data(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 312 + start] = 0;
         }
@@ -1294,14 +1295,14 @@ public:
     #else
     BusinessReject521 &putLocation(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 312, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 312 + start] = 0;
         }
@@ -1310,7 +1311,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * RefSeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *RefSeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1349,17 +1350,17 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t refSeqNumNullValue() SBE_NOEXCEPT
     {
-        return 4294967295;
+        return UINT32_C(0xffffffff);
     }
 
     static SBE_CONSTEXPR std::uint32_t refSeqNumMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t refSeqNumMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t refSeqNumEncodingLength() SBE_NOEXCEPT
@@ -1381,7 +1382,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * RefTagIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *RefTagIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1420,17 +1421,17 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t refTagIDNullValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65535;
+        return static_cast<std::uint16_t>(65535);
     }
 
     static SBE_CONSTEXPR std::uint16_t refTagIDMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t refTagIDMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t refTagIDEncodingLength() SBE_NOEXCEPT
@@ -1452,7 +1453,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * BusinessRejectReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *BusinessRejectReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1496,12 +1497,12 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t businessRejectReasonMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t businessRejectReasonMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t businessRejectReasonEncodingLength() SBE_NOEXCEPT
@@ -1523,7 +1524,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * RefMsgTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *RefMsgTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1562,17 +1563,17 @@ public:
 
     static SBE_CONSTEXPR char refMsgTypeNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char refMsgTypeMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char refMsgTypeMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t refMsgTypeEncodingLength() SBE_NOEXCEPT
@@ -1626,7 +1627,7 @@ public:
             throw std::runtime_error("length too large for getRefMsgType [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 325, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 325, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1651,7 +1652,7 @@ public:
     SBE_NODISCARD std::string getRefMsgTypeAsString() const
     {
         const char *buffer = m_buffer + m_offset + 325;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 2 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1696,7 +1697,7 @@ public:
     SBE_NODISCARD std::string_view getRefMsgTypeAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 325;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 2 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1708,14 +1709,14 @@ public:
     #if __cplusplus >= 201703L
     BusinessReject521 &putRefMsgType(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 2)
         {
             throw std::runtime_error("string too large for putRefMsgType [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 325, str.data(), srcLength);
-        for (size_t start = srcLength; start < 2; ++start)
+        for (std::size_t start = srcLength; start < 2; ++start)
         {
             m_buffer[m_offset + 325 + start] = 0;
         }
@@ -1725,14 +1726,14 @@ public:
     #else
     BusinessReject521 &putRefMsgType(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 2)
         {
             throw std::runtime_error("string too large for putRefMsgType [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 325, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 2; ++start)
+        for (std::size_t start = srcLength; start < 2; ++start)
         {
             m_buffer[m_offset + 325 + start] = 0;
         }
@@ -1741,7 +1742,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1783,7 +1784,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 327, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD BooleanFlag::Value possRetransFlag() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 327, sizeof(std::uint8_t));
@@ -1797,7 +1805,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1839,7 +1847,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ManualOrdInd::Value manualOrderIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 328, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ManualOrdInd::Value manualOrderIndicator() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 328, sizeof(std::uint8_t));
@@ -1853,7 +1868,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1895,7 +1910,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 329, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD SplitMsg::Value splitMsg() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 329, sizeof(std::uint8_t));
@@ -1998,13 +2020,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return true;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+SBE_NODISCARD static std::size_t computeLength()
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
+    std::size_t length = sbeBlockLength();
 
     return length;
 #if defined(__GNUG__) && !defined(__clang__)

src/lib/orderman/actors/ilink3/generated/ClearingAcctType.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class ClearingAcctType
 public:
     enum Value
     {
-        Customer = (std::uint8_t)0,
-        Firm = (std::uint8_t)1,
-        NULL_VALUE = (std::uint8_t)255
+        Customer = static_cast<std::uint8_t>(0),
+        Firm = static_cast<std::uint8_t>(1),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static ClearingAcctType::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 0: return Customer;
-            case 1: return Firm;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(0): return Customer;
+            case static_cast<std::uint8_t>(1): return Firm;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum ClearingAcctType [E103]");
     }
 
-    static const char* c_str(const ClearingAcctType::Value value)
+    static const char *c_str(const ClearingAcctType::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/CmtaGiveUpCD.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class CmtaGiveUpCD
 public:
     enum Value
     {
-        GiveUp = (char)71,
-        SGXoffset = (char)83,
-        NULL_VALUE = (char)0
+        GiveUp = static_cast<char>(71),
+        SGXoffset = static_cast<char>(83),
+        NULL_VALUE = static_cast<char>(0)
     };
 
     static CmtaGiveUpCD::Value get(const char value)
     {
         switch (value)
         {
-            case 71: return GiveUp;
-            case 83: return SGXoffset;
-            case 0: return NULL_VALUE;
+            case static_cast<char>(71): return GiveUp;
+            case static_cast<char>(83): return SGXoffset;
+            case static_cast<char>(0): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum CmtaGiveUpCD [E103]");
     }
 
-    static const char* c_str(const CmtaGiveUpCD::Value value)
+    static const char *c_str(const CmtaGiveUpCD::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/CustOrdHandlInst.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,32 +94,32 @@ class CustOrdHandlInst
 public:
     enum Value
     {
-        FCMprovidedscreen = (char)67,
-        Otherprovidedscreen = (char)68,
-        FCMAPIorFIX = (char)71,
-        AlgoEngine = (char)72,
-        DeskElectronic = (char)87,
-        ClientElectronic = (char)89,
-        NULL_VALUE = (char)0
+        FCMprovidedscreen = static_cast<char>(67),
+        Otherprovidedscreen = static_cast<char>(68),
+        FCMAPIorFIX = static_cast<char>(71),
+        AlgoEngine = static_cast<char>(72),
+        DeskElectronic = static_cast<char>(87),
+        ClientElectronic = static_cast<char>(89),
+        NULL_VALUE = static_cast<char>(0)
     };
 
     static CustOrdHandlInst::Value get(const char value)
     {
         switch (value)
         {
-            case 67: return FCMprovidedscreen;
-            case 68: return Otherprovidedscreen;
-            case 71: return FCMAPIorFIX;
-            case 72: return AlgoEngine;
-            case 87: return DeskElectronic;
-            case 89: return ClientElectronic;
-            case 0: return NULL_VALUE;
+            case static_cast<char>(67): return FCMprovidedscreen;
+            case static_cast<char>(68): return Otherprovidedscreen;
+            case static_cast<char>(71): return FCMAPIorFIX;
+            case static_cast<char>(72): return AlgoEngine;
+            case static_cast<char>(87): return DeskElectronic;
+            case static_cast<char>(89): return ClientElectronic;
+            case static_cast<char>(0): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum CustOrdHandlInst [E103]");
     }
 
-    static const char* c_str(const CustOrdHandlInst::Value value)
+    static const char *c_str(const CustOrdHandlInst::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/CustOrderCapacity.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,28 +94,28 @@ class CustOrderCapacity
 public:
     enum Value
     {
-        Membertradingfortheirownaccount = (std::uint8_t)1,
-        Clearingfirmtradingforitsproprietaryaccount = (std::uint8_t)2,
-        Membertradingforanothermember = (std::uint8_t)3,
-        Allother = (std::uint8_t)4,
-        NULL_VALUE = (std::uint8_t)255
+        Membertradingfortheirownaccount = static_cast<std::uint8_t>(1),
+        Clearingfirmtradingforitsproprietaryaccount = static_cast<std::uint8_t>(2),
+        Membertradingforanothermember = static_cast<std::uint8_t>(3),
+        Allother = static_cast<std::uint8_t>(4),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static CustOrderCapacity::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 1: return Membertradingfortheirownaccount;
-            case 2: return Clearingfirmtradingforitsproprietaryaccount;
-            case 3: return Membertradingforanothermember;
-            case 4: return Allother;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(1): return Membertradingfortheirownaccount;
+            case static_cast<std::uint8_t>(2): return Clearingfirmtradingforitsproprietaryaccount;
+            case static_cast<std::uint8_t>(3): return Membertradingforanothermember;
+            case static_cast<std::uint8_t>(4): return Allother;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum CustOrderCapacity [E103]");
     }
 
-    static const char* c_str(const CustOrderCapacity::Value value)
+    static const char *c_str(const CustOrderCapacity::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/DATA.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -172,12 +167,12 @@ public:
         return m_offset;
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -194,15 +189,15 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static const char * lengthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *lengthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -245,12 +240,12 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t lengthMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t lengthMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t lengthEncodingLength() SBE_NOEXCEPT
@@ -272,7 +267,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * varDataMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *varDataMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -310,17 +305,17 @@ public:
 
     static SBE_CONSTEXPR char varDataNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char varDataMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char varDataMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t varDataEncodingLength() SBE_NOEXCEPT

src/lib/orderman/actors/ilink3/generated/DKReason.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,36 +94,36 @@ class DKReason
 public:
     enum Value
     {
-        UnknownSecurity = (char)65,
-        WrongSide = (char)66,
-        QuantityExceedsOrder = (char)67,
-        NoMatchingOrder = (char)68,
-        PriceExceedsLimit = (char)69,
-        CalculationDifference = (char)70,
-        NoMatchingExecutionReport = (char)71,
-        Other = (char)90,
-        NULL_VALUE = (char)0
+        UnknownSecurity = static_cast<char>(65),
+        WrongSide = static_cast<char>(66),
+        QuantityExceedsOrder = static_cast<char>(67),
+        NoMatchingOrder = static_cast<char>(68),
+        PriceExceedsLimit = static_cast<char>(69),
+        CalculationDifference = static_cast<char>(70),
+        NoMatchingExecutionReport = static_cast<char>(71),
+        Other = static_cast<char>(90),
+        NULL_VALUE = static_cast<char>(0)
     };
 
     static DKReason::Value get(const char value)
     {
         switch (value)
         {
-            case 65: return UnknownSecurity;
-            case 66: return WrongSide;
-            case 67: return QuantityExceedsOrder;
-            case 68: return NoMatchingOrder;
-            case 69: return PriceExceedsLimit;
-            case 70: return CalculationDifference;
-            case 71: return NoMatchingExecutionReport;
-            case 90: return Other;
-            case 0: return NULL_VALUE;
+            case static_cast<char>(65): return UnknownSecurity;
+            case static_cast<char>(66): return WrongSide;
+            case static_cast<char>(67): return QuantityExceedsOrder;
+            case static_cast<char>(68): return NoMatchingOrder;
+            case static_cast<char>(69): return PriceExceedsLimit;
+            case static_cast<char>(70): return CalculationDifference;
+            case static_cast<char>(71): return NoMatchingExecutionReport;
+            case static_cast<char>(90): return Other;
+            case static_cast<char>(0): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum DKReason [E103]");
     }
 
-    static const char* c_str(const DKReason::Value value)
+    static const char *c_str(const DKReason::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/Decimal32NULL.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -172,12 +167,12 @@ public:
         return m_offset;
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -194,15 +189,15 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static const char * mantissaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *mantissaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -240,17 +235,17 @@ public:
 
     static SBE_CONSTEXPR std::int32_t mantissaNullValue() SBE_NOEXCEPT
     {
-        return 2147483647;
+        return INT32_C(2147483647);
     }
 
     static SBE_CONSTEXPR std::int32_t mantissaMinValue() SBE_NOEXCEPT
     {
-        return -2147483647;
+        return INT32_C(-2147483647);
     }
 
     static SBE_CONSTEXPR std::int32_t mantissaMaxValue() SBE_NOEXCEPT
     {
-        return 2147483647;
+        return INT32_C(2147483647);
     }
 
     static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT
@@ -272,7 +267,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * exponentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *exponentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -310,17 +305,17 @@ public:
 
     static SBE_CONSTEXPR std::int8_t exponentNullValue() SBE_NOEXCEPT
     {
-        return (std::int8_t)127;
+        return static_cast<std::int8_t>(127);
     }
 
     static SBE_CONSTEXPR std::int8_t exponentMinValue() SBE_NOEXCEPT
     {
-        return (std::int8_t)-127;
+        return static_cast<std::int8_t>(-127);
     }
 
     static SBE_CONSTEXPR std::int8_t exponentMaxValue() SBE_NOEXCEPT
     {
-        return (std::int8_t)127;
+        return static_cast<std::int8_t>(127);
     }
 
     static SBE_CONSTEXPR std::size_t exponentEncodingLength() SBE_NOEXCEPT

src/lib/orderman/actors/ilink3/generated/Decimal64NULL.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -172,12 +167,12 @@ public:
         return m_offset;
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -194,15 +189,15 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static const char * mantissaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *mantissaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -240,17 +235,17 @@ public:
 
     static SBE_CONSTEXPR std::int64_t mantissaNullValue() SBE_NOEXCEPT
     {
-        return 9223372036854775807L;
+        return INT64_C(9223372036854775807);
     }
 
     static SBE_CONSTEXPR std::int64_t mantissaMinValue() SBE_NOEXCEPT
     {
-        return -9223372036854775807L;
+        return INT64_C(-9223372036854775807);
     }
 
     static SBE_CONSTEXPR std::int64_t mantissaMaxValue() SBE_NOEXCEPT
     {
-        return 9223372036854775807L;
+        return INT64_C(9223372036854775807);
     }
 
     static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT
@@ -272,7 +267,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * exponentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *exponentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -310,17 +305,17 @@ public:
 
     static SBE_CONSTEXPR std::int8_t exponentNullValue() SBE_NOEXCEPT
     {
-        return (std::int8_t)127;
+        return static_cast<std::int8_t>(127);
     }
 
     static SBE_CONSTEXPR std::int8_t exponentMinValue() SBE_NOEXCEPT
     {
-        return (std::int8_t)-127;
+        return static_cast<std::int8_t>(-127);
     }
 
     static SBE_CONSTEXPR std::int8_t exponentMaxValue() SBE_NOEXCEPT
     {
-        return (std::int8_t)127;
+        return static_cast<std::int8_t>(127);
     }
 
     static SBE_CONSTEXPR std::size_t exponentEncodingLength() SBE_NOEXCEPT

src/lib/orderman/actors/ilink3/generated/Establish503.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(132);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(503);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     Establish503() = default;
 
     Establish503(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)132;
+        return static_cast<std::uint16_t>(132);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)503;
+        return static_cast<std::uint16_t>(503);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "Establish";
     }
@@ -258,7 +260,7 @@ public:
 
     Establish503 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = Establish503(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        Establish503 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        Establish503 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * HMACVersionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *HMACVersionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -376,17 +377,17 @@ public:
 
     static SBE_CONSTEXPR char hMACVersionNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char hMACVersionMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char hMACVersionMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t hMACVersionEncodingLength() SBE_NOEXCEPT
@@ -401,14 +402,14 @@ public:
 
     SBE_NODISCARD const char *hMACVersion() const
     {
-        static const std::uint8_t hMACVersionValues[] = { 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54 };
+        static const std::uint8_t hMACVersionValues[] = { 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54, 0 };
 
         return (const char *)hMACVersionValues;
     }
 
     SBE_NODISCARD char hMACVersion(const std::uint64_t index) const
     {
-        static const std::uint8_t hMACVersionValues[] = { 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54 };
+        static const std::uint8_t hMACVersionValues[] = { 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54, 0 };
 
         return (char)hMACVersionValues[index];
     }
@@ -418,7 +419,7 @@ public:
         static std::uint8_t hMACVersionValues[] = { 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54 };
         std::uint64_t bytesToCopy = length < sizeof(hMACVersionValues) ? length : sizeof(hMACVersionValues);
 
-        std::memcpy(dst, hMACVersionValues, static_cast<size_t>(bytesToCopy));
+        std::memcpy(dst, hMACVersionValues, static_cast<std::size_t>(bytesToCopy));
         return bytesToCopy;
     }
 
@@ -462,7 +463,7 @@ public:
         return oss.str();
     }
 
-    SBE_NODISCARD static const char * HMACSignatureMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *HMACSignatureMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -501,17 +502,17 @@ public:
 
     static SBE_CONSTEXPR char hMACSignatureNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char hMACSignatureMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char hMACSignatureMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t hMACSignatureEncodingLength() SBE_NOEXCEPT
@@ -565,7 +566,7 @@ public:
             throw std::runtime_error("length too large for getHMACSignature [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -578,7 +579,7 @@ public:
     SBE_NODISCARD std::string getHMACSignatureAsString() const
     {
         const char *buffer = m_buffer + m_offset + 0;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 32 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -623,7 +624,7 @@ public:
     SBE_NODISCARD std::string_view getHMACSignatureAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 0;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 32 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -635,14 +636,14 @@ public:
     #if __cplusplus >= 201703L
     Establish503 &putHMACSignature(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 32)
         {
             throw std::runtime_error("string too large for putHMACSignature [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength);
-        for (size_t start = srcLength; start < 32; ++start)
+        for (std::size_t start = srcLength; start < 32; ++start)
         {
             m_buffer[m_offset + 0 + start] = 0;
         }
@@ -652,14 +653,14 @@ public:
     #else
     Establish503 &putHMACSignature(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 32)
         {
             throw std::runtime_error("string too large for putHMACSignature [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 32; ++start)
+        for (std::size_t start = srcLength; start < 32; ++start)
         {
             m_buffer[m_offset + 0 + start] = 0;
         }
@@ -668,7 +669,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * AccessKeyIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *AccessKeyIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -707,17 +708,17 @@ public:
 
     static SBE_CONSTEXPR char accessKeyIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char accessKeyIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char accessKeyIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t accessKeyIDEncodingLength() SBE_NOEXCEPT
@@ -771,7 +772,7 @@ public:
             throw std::runtime_error("length too large for getAccessKeyID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 32, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 32, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -784,7 +785,7 @@ public:
     SBE_NODISCARD std::string getAccessKeyIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 32;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -829,7 +830,7 @@ public:
     SBE_NODISCARD std::string_view getAccessKeyIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 32;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -841,14 +842,14 @@ public:
     #if __cplusplus >= 201703L
     Establish503 &putAccessKeyID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putAccessKeyID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 32, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 32 + start] = 0;
         }
@@ -858,14 +859,14 @@ public:
     #else
     Establish503 &putAccessKeyID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putAccessKeyID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 32, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 32 + start] = 0;
         }
@@ -874,7 +875,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * TradingSystemNameMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *TradingSystemNameMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -913,17 +914,17 @@ public:
 
     static SBE_CONSTEXPR char tradingSystemNameNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char tradingSystemNameMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char tradingSystemNameMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t tradingSystemNameEncodingLength() SBE_NOEXCEPT
@@ -977,7 +978,7 @@ public:
             throw std::runtime_error("length too large for getTradingSystemName [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 52, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 52, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -990,7 +991,7 @@ public:
     SBE_NODISCARD std::string getTradingSystemNameAsString() const
     {
         const char *buffer = m_buffer + m_offset + 52;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 30 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1035,7 +1036,7 @@ public:
     SBE_NODISCARD std::string_view getTradingSystemNameAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 52;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 30 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1047,14 +1048,14 @@ public:
     #if __cplusplus >= 201703L
     Establish503 &putTradingSystemName(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 30)
         {
             throw std::runtime_error("string too large for putTradingSystemName [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength);
-        for (size_t start = srcLength; start < 30; ++start)
+        for (std::size_t start = srcLength; start < 30; ++start)
         {
             m_buffer[m_offset + 52 + start] = 0;
         }
@@ -1064,14 +1065,14 @@ public:
     #else
     Establish503 &putTradingSystemName(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 30)
         {
             throw std::runtime_error("string too large for putTradingSystemName [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 30; ++start)
+        for (std::size_t start = srcLength; start < 30; ++start)
         {
             m_buffer[m_offset + 52 + start] = 0;
         }
@@ -1080,7 +1081,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * TradingSystemVersionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *TradingSystemVersionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1119,17 +1120,17 @@ public:
 
     static SBE_CONSTEXPR char tradingSystemVersionNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char tradingSystemVersionMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char tradingSystemVersionMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t tradingSystemVersionEncodingLength() SBE_NOEXCEPT
@@ -1183,7 +1184,7 @@ public:
             throw std::runtime_error("length too large for getTradingSystemVersion [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 82, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 82, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1196,7 +1197,7 @@ public:
     SBE_NODISCARD std::string getTradingSystemVersionAsString() const
     {
         const char *buffer = m_buffer + m_offset + 82;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 10 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1241,7 +1242,7 @@ public:
     SBE_NODISCARD std::string_view getTradingSystemVersionAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 82;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 10 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1253,14 +1254,14 @@ public:
     #if __cplusplus >= 201703L
     Establish503 &putTradingSystemVersion(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 10)
         {
             throw std::runtime_error("string too large for putTradingSystemVersion [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 82, str.data(), srcLength);
-        for (size_t start = srcLength; start < 10; ++start)
+        for (std::size_t start = srcLength; start < 10; ++start)
         {
             m_buffer[m_offset + 82 + start] = 0;
         }
@@ -1270,14 +1271,14 @@ public:
     #else
     Establish503 &putTradingSystemVersion(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 10)
         {
             throw std::runtime_error("string too large for putTradingSystemVersion [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 82, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 10; ++start)
+        for (std::size_t start = srcLength; start < 10; ++start)
         {
             m_buffer[m_offset + 82 + start] = 0;
         }
@@ -1286,7 +1287,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * TradingSystemVendorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *TradingSystemVendorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1325,17 +1326,17 @@ public:
 
     static SBE_CONSTEXPR char tradingSystemVendorNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char tradingSystemVendorMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char tradingSystemVendorMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t tradingSystemVendorEncodingLength() SBE_NOEXCEPT
@@ -1389,7 +1390,7 @@ public:
             throw std::runtime_error("length too large for getTradingSystemVendor [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 92, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 92, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1402,7 +1403,7 @@ public:
     SBE_NODISCARD std::string getTradingSystemVendorAsString() const
     {
         const char *buffer = m_buffer + m_offset + 92;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 10 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1447,7 +1448,7 @@ public:
     SBE_NODISCARD std::string_view getTradingSystemVendorAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 92;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 10 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1459,14 +1460,14 @@ public:
     #if __cplusplus >= 201703L
     Establish503 &putTradingSystemVendor(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 10)
         {
             throw std::runtime_error("string too large for putTradingSystemVendor [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 92, str.data(), srcLength);
-        for (size_t start = srcLength; start < 10; ++start)
+        for (std::size_t start = srcLength; start < 10; ++start)
         {
             m_buffer[m_offset + 92 + start] = 0;
         }
@@ -1476,14 +1477,14 @@ public:
     #else
     Establish503 &putTradingSystemVendor(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 10)
         {
             throw std::runtime_error("string too large for putTradingSystemVendor [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 92, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 10; ++start)
+        for (std::size_t start = srcLength; start < 10; ++start)
         {
             m_buffer[m_offset + 92 + start] = 0;
         }
@@ -1492,7 +1493,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1536,12 +1537,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -1563,7 +1564,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1607,12 +1608,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT
@@ -1634,7 +1635,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * NextSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *NextSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1678,12 +1679,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t nextSeqNoMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t nextSeqNoMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t nextSeqNoEncodingLength() SBE_NOEXCEPT
@@ -1705,7 +1706,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SessionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SessionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1744,17 +1745,17 @@ public:
 
     static SBE_CONSTEXPR char sessionNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char sessionMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char sessionMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t sessionEncodingLength() SBE_NOEXCEPT
@@ -1808,7 +1809,7 @@ public:
             throw std::runtime_error("length too large for getSession [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 122, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 122, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1836,7 +1837,7 @@ public:
     SBE_NODISCARD std::string getSessionAsString() const
     {
         const char *buffer = m_buffer + m_offset + 122;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 3 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1881,7 +1882,7 @@ public:
     SBE_NODISCARD std::string_view getSessionAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 122;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 3 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1893,14 +1894,14 @@ public:
     #if __cplusplus >= 201703L
     Establish503 &putSession(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 3)
         {
             throw std::runtime_error("string too large for putSession [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 122, str.data(), srcLength);
-        for (size_t start = srcLength; start < 3; ++start)
+        for (std::size_t start = srcLength; start < 3; ++start)
         {
             m_buffer[m_offset + 122 + start] = 0;
         }
@@ -1910,14 +1911,14 @@ public:
     #else
     Establish503 &putSession(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 3)
         {
             throw std::runtime_error("string too large for putSession [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 122, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 3; ++start)
+        for (std::size_t start = srcLength; start < 3; ++start)
         {
             m_buffer[m_offset + 122 + start] = 0;
         }
@@ -1926,7 +1927,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * FirmMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *FirmMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1965,17 +1966,17 @@ public:
 
     static SBE_CONSTEXPR char firmNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char firmMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char firmMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t firmEncodingLength() SBE_NOEXCEPT
@@ -2029,7 +2030,7 @@ public:
             throw std::runtime_error("length too large for getFirm [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 125, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 125, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -2042,7 +2043,7 @@ public:
     SBE_NODISCARD std::string getFirmAsString() const
     {
         const char *buffer = m_buffer + m_offset + 125;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -2087,7 +2088,7 @@ public:
     SBE_NODISCARD std::string_view getFirmAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 125;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -2099,14 +2100,14 @@ public:
     #if __cplusplus >= 201703L
     Establish503 &putFirm(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putFirm [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 125, str.data(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 125 + start] = 0;
         }
@@ -2116,14 +2117,14 @@ public:
     #else
     Establish503 &putFirm(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putFirm [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 125, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 125 + start] = 0;
         }
@@ -2132,7 +2133,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * KeepAliveIntervalMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *KeepAliveIntervalMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2176,12 +2177,12 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t keepAliveIntervalMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t keepAliveIntervalMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t keepAliveIntervalEncodingLength() SBE_NOEXCEPT
@@ -2203,7 +2204,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * CredentialsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *CredentialsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2283,7 +2284,7 @@ public:
         std::uint64_t bytesToCopy = length < dataLength ? length : dataLength;
         std::uint64_t pos = sbePosition();
         sbePosition(pos + dataLength);
-        std::memcpy(dst, m_buffer + pos, static_cast<size_t>(bytesToCopy));
+        std::memcpy(dst, m_buffer + pos, static_cast<std::size_t>(bytesToCopy));
         return bytesToCopy;
     }
 
@@ -2372,7 +2373,8 @@ public:
         {
             throw std::runtime_error("std::string too long for length type [E109]");
         }
-        return putCredentials(str.data(), static_cast<std::uint16_t>(str.length()));    }
+        return putCredentials(str.data(), static_cast<std::uint16_t>(str.length()));
+    }
 
     #if __cplusplus >= 201703L
     Establish503 &putCredentials(const std::string_view str)
@@ -2381,7 +2383,8 @@ public:
         {
             throw std::runtime_error("std::string too long for length type [E109]");
         }
-        return putCredentials(str.data(), static_cast<std::uint16_t>(str.length()));    }
+        return putCredentials(str.data(), static_cast<std::uint16_t>(str.length()));
+    }
     #endif
 
 template<typename CharT, typename Traits>
@@ -2466,21 +2469,21 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return false;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength(std::size_t CredentialsLength = 0)
+SBE_NODISCARD static std::size_t computeLength(std::size_t credentialsLength = 0)
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
-
+    std::size_t length = sbeBlockLength();
 
     length += credentialsHeaderLength();
-    if (CredentialsLength > 65534)
+    if (credentialsLength > 65534LL)
     {
-        throw std::runtime_error("CredentialsLength too long for length type [E109]");
+        throw std::runtime_error("credentialsLength too long for length type [E109]");
     }
-    length += CredentialsLength;
+    length += credentialsLength;
+
     return length;
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic pop

src/lib/orderman/actors/ilink3/generated/EstablishmentAck504.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(38);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(504);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     EstablishmentAck504() = default;
 
     EstablishmentAck504(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)38;
+        return static_cast<std::uint16_t>(38);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)504;
+        return static_cast<std::uint16_t>(504);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "EstablishmentAck";
     }
@@ -258,7 +260,7 @@ public:
 
     EstablishmentAck504 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = EstablishmentAck504(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        EstablishmentAck504 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        EstablishmentAck504 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -381,12 +382,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -452,12 +453,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * NextSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *NextSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -523,12 +524,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t nextSeqNoMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t nextSeqNoMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t nextSeqNoEncodingLength() SBE_NOEXCEPT
@@ -550,7 +551,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * PreviousSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PreviousSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -594,12 +595,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t previousSeqNoMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t previousSeqNoMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t previousSeqNoEncodingLength() SBE_NOEXCEPT
@@ -621,7 +622,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * PreviousUUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PreviousUUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -665,12 +666,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t previousUUIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t previousUUIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t previousUUIDEncodingLength() SBE_NOEXCEPT
@@ -692,7 +693,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * KeepAliveIntervalMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *KeepAliveIntervalMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -736,12 +737,12 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t keepAliveIntervalMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t keepAliveIntervalMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t keepAliveIntervalEncodingLength() SBE_NOEXCEPT
@@ -763,7 +764,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SecretKeySecureIDExpirationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SecretKeySecureIDExpirationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -802,17 +803,17 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t secretKeySecureIDExpirationNullValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65535;
+        return static_cast<std::uint16_t>(65535);
     }
 
     static SBE_CONSTEXPR std::uint16_t secretKeySecureIDExpirationMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t secretKeySecureIDExpirationMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t secretKeySecureIDExpirationEncodingLength() SBE_NOEXCEPT
@@ -834,7 +835,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * FaultToleranceIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *FaultToleranceIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -876,7 +877,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD FTI::Value faultToleranceIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t faultToleranceIndicatorRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 36, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD FTI::Value faultToleranceIndicator() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 36, sizeof(std::uint8_t));
@@ -890,7 +898,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -932,7 +940,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 37, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD SplitMsg::Value splitMsg() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 37, sizeof(std::uint8_t));
@@ -1007,13 +1022,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return true;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+SBE_NODISCARD static std::size_t computeLength()
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
+    std::size_t length = sbeBlockLength();
 
     return length;
 #if defined(__GNUG__) && !defined(__clang__)

src/lib/orderman/actors/ilink3/generated/EstablishmentReject505.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(72);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(505);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     EstablishmentReject505() = default;
 
     EstablishmentReject505(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)72;
+        return static_cast<std::uint16_t>(72);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)505;
+        return static_cast<std::uint16_t>(505);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "EstablishmentReject";
     }
@@ -258,7 +260,7 @@ public:
 
     EstablishmentReject505 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = EstablishmentReject505(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        EstablishmentReject505 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        EstablishmentReject505 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * ReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -376,17 +377,17 @@ public:
 
     static SBE_CONSTEXPR char reasonNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char reasonMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char reasonMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t reasonEncodingLength() SBE_NOEXCEPT
@@ -440,7 +441,7 @@ public:
             throw std::runtime_error("length too large for getReason [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -453,7 +454,7 @@ public:
     SBE_NODISCARD std::string getReasonAsString() const
     {
         const char *buffer = m_buffer + m_offset + 0;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 48 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -498,7 +499,7 @@ public:
     SBE_NODISCARD std::string_view getReasonAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 0;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 48 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -510,14 +511,14 @@ public:
     #if __cplusplus >= 201703L
     EstablishmentReject505 &putReason(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 48)
         {
             throw std::runtime_error("string too large for putReason [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength);
-        for (size_t start = srcLength; start < 48; ++start)
+        for (std::size_t start = srcLength; start < 48; ++start)
         {
             m_buffer[m_offset + 0 + start] = 0;
         }
@@ -527,14 +528,14 @@ public:
     #else
     EstablishmentReject505 &putReason(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 48)
         {
             throw std::runtime_error("string too large for putReason [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 48; ++start)
+        for (std::size_t start = srcLength; start < 48; ++start)
         {
             m_buffer[m_offset + 0 + start] = 0;
         }
@@ -543,7 +544,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -587,12 +588,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -614,7 +615,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -658,12 +659,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT
@@ -685,7 +686,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * NextSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *NextSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -729,12 +730,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t nextSeqNoMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t nextSeqNoMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t nextSeqNoEncodingLength() SBE_NOEXCEPT
@@ -756,7 +757,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ErrorCodesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ErrorCodesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -800,12 +801,12 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t errorCodesMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t errorCodesMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t errorCodesEncodingLength() SBE_NOEXCEPT
@@ -827,7 +828,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * FaultToleranceIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *FaultToleranceIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -869,7 +870,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD FTI::Value faultToleranceIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t faultToleranceIndicatorRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 70, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD FTI::Value faultToleranceIndicator() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 70, sizeof(std::uint8_t));
@@ -883,7 +891,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -925,7 +933,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 71, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD SplitMsg::Value splitMsg() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 71, sizeof(std::uint8_t));
@@ -993,13 +1008,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return true;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+SBE_NODISCARD static std::size_t computeLength()
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
+    std::size_t length = sbeBlockLength();
 
     return length;
 #if defined(__GNUG__) && !defined(__clang__)

src/lib/orderman/actors/ilink3/generated/ExecAckStatus.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class ExecAckStatus
 public:
     enum Value
     {
-        Accepted = (std::uint8_t)1,
-        Rejected = (std::uint8_t)2,
-        NULL_VALUE = (std::uint8_t)255
+        Accepted = static_cast<std::uint8_t>(1),
+        Rejected = static_cast<std::uint8_t>(2),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static ExecAckStatus::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 1: return Accepted;
-            case 2: return Rejected;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(1): return Accepted;
+            case static_cast<std::uint8_t>(2): return Rejected;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum ExecAckStatus [E103]");
     }
 
-    static const char* c_str(const ExecAckStatus::Value value)
+    static const char *c_str(const ExecAckStatus::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/ExecInst.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -172,12 +167,12 @@ public:
         return m_offset;
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -194,12 +189,12 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
     ExecInst &clear()
@@ -231,208 +226,208 @@ public:
 
     static bool aON(const std::uint8_t bits)
     {
-        return (bits & (1u << 0u)) != 0;
+        return (bits & (static_cast<std::uint8_t>(1) << 0u)) != 0;
     }
 
     static std::uint8_t aON(const std::uint8_t bits, const bool value)
     {
-        return value ? static_cast<std::uint8_t>(bits | (1u << 0u)) : static_cast<std::uint8_t>(bits & ~(1u << 0u));
+        return value ? static_cast<std::uint8_t>(bits | (static_cast<std::uint8_t>(1) << 0u)) : static_cast<std::uint8_t>(bits & ~(static_cast<std::uint8_t>(1) << 0u));
     }
 
     SBE_NODISCARD bool aON() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t));
-        return ((val) & (1u << 0u)) != 0;
+        return ((val) & (static_cast<std::uint8_t>(1) << 0u)) != 0;
     }
 
     ExecInst &aON(const bool value)
     {
         std::uint8_t bits;
         std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t));
-        bits = (value ? static_cast<std::uint8_t>((bits) | (1u << 0u)) : static_cast<std::uint8_t>((bits) & ~(1u << 0u)));
+        bits = (value ? static_cast<std::uint8_t>((bits) | (static_cast<std::uint8_t>(1) << 0u)) : static_cast<std::uint8_t>((bits) & ~(static_cast<std::uint8_t>(1) << 0u)));
         std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t));
         return *this;
     }
 
     static bool oB(const std::uint8_t bits)
     {
-        return (bits & (1u << 1u)) != 0;
+        return (bits & (static_cast<std::uint8_t>(1) << 1u)) != 0;
     }
 
     static std::uint8_t oB(const std::uint8_t bits, const bool value)
     {
-        return value ? static_cast<std::uint8_t>(bits | (1u << 1u)) : static_cast<std::uint8_t>(bits & ~(1u << 1u));
+        return value ? static_cast<std::uint8_t>(bits | (static_cast<std::uint8_t>(1) << 1u)) : static_cast<std::uint8_t>(bits & ~(static_cast<std::uint8_t>(1) << 1u));
     }
 
     SBE_NODISCARD bool oB() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t));
-        return ((val) & (1u << 1u)) != 0;
+        return ((val) & (static_cast<std::uint8_t>(1) << 1u)) != 0;
     }
 
     ExecInst &oB(const bool value)
     {
         std::uint8_t bits;
         std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t));
-        bits = (value ? static_cast<std::uint8_t>((bits) | (1u << 1u)) : static_cast<std::uint8_t>((bits) & ~(1u << 1u)));
+        bits = (value ? static_cast<std::uint8_t>((bits) | (static_cast<std::uint8_t>(1) << 1u)) : static_cast<std::uint8_t>((bits) & ~(static_cast<std::uint8_t>(1) << 1u)));
         std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t));
         return *this;
     }
 
     static bool nH(const std::uint8_t bits)
     {
-        return (bits & (1u << 2u)) != 0;
+        return (bits & (static_cast<std::uint8_t>(1) << 2u)) != 0;
     }
 
     static std::uint8_t nH(const std::uint8_t bits, const bool value)
     {
-        return value ? static_cast<std::uint8_t>(bits | (1u << 2u)) : static_cast<std::uint8_t>(bits & ~(1u << 2u));
+        return value ? static_cast<std::uint8_t>(bits | (static_cast<std::uint8_t>(1) << 2u)) : static_cast<std::uint8_t>(bits & ~(static_cast<std::uint8_t>(1) << 2u));
     }
 
     SBE_NODISCARD bool nH() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t));
-        return ((val) & (1u << 2u)) != 0;
+        return ((val) & (static_cast<std::uint8_t>(1) << 2u)) != 0;
     }
 
     ExecInst &nH(const bool value)
     {
         std::uint8_t bits;
         std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t));
-        bits = (value ? static_cast<std::uint8_t>((bits) | (1u << 2u)) : static_cast<std::uint8_t>((bits) & ~(1u << 2u)));
+        bits = (value ? static_cast<std::uint8_t>((bits) | (static_cast<std::uint8_t>(1) << 2u)) : static_cast<std::uint8_t>((bits) & ~(static_cast<std::uint8_t>(1) << 2u)));
         std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t));
         return *this;
     }
 
     static bool reserved1(const std::uint8_t bits)
     {
-        return (bits & (1u << 3u)) != 0;
+        return (bits & (static_cast<std::uint8_t>(1) << 3u)) != 0;
     }
 
     static std::uint8_t reserved1(const std::uint8_t bits, const bool value)
     {
-        return value ? static_cast<std::uint8_t>(bits | (1u << 3u)) : static_cast<std::uint8_t>(bits & ~(1u << 3u));
+        return value ? static_cast<std::uint8_t>(bits | (static_cast<std::uint8_t>(1) << 3u)) : static_cast<std::uint8_t>(bits & ~(static_cast<std::uint8_t>(1) << 3u));
     }
 
     SBE_NODISCARD bool reserved1() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t));
-        return ((val) & (1u << 3u)) != 0;
+        return ((val) & (static_cast<std::uint8_t>(1) << 3u)) != 0;
     }
 
     ExecInst &reserved1(const bool value)
     {
         std::uint8_t bits;
         std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t));
-        bits = (value ? static_cast<std::uint8_t>((bits) | (1u << 3u)) : static_cast<std::uint8_t>((bits) & ~(1u << 3u)));
+        bits = (value ? static_cast<std::uint8_t>((bits) | (static_cast<std::uint8_t>(1) << 3u)) : static_cast<std::uint8_t>((bits) & ~(static_cast<std::uint8_t>(1) << 3u)));
         std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t));
         return *this;
     }
 
     static bool reserved2(const std::uint8_t bits)
     {
-        return (bits & (1u << 4u)) != 0;
+        return (bits & (static_cast<std::uint8_t>(1) << 4u)) != 0;
     }
 
     static std::uint8_t reserved2(const std::uint8_t bits, const bool value)
     {
-        return value ? static_cast<std::uint8_t>(bits | (1u << 4u)) : static_cast<std::uint8_t>(bits & ~(1u << 4u));
+        return value ? static_cast<std::uint8_t>(bits | (static_cast<std::uint8_t>(1) << 4u)) : static_cast<std::uint8_t>(bits & ~(static_cast<std::uint8_t>(1) << 4u));
     }
 
     SBE_NODISCARD bool reserved2() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t));
-        return ((val) & (1u << 4u)) != 0;
+        return ((val) & (static_cast<std::uint8_t>(1) << 4u)) != 0;
     }
 
     ExecInst &reserved2(const bool value)
     {
         std::uint8_t bits;
         std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t));
-        bits = (value ? static_cast<std::uint8_t>((bits) | (1u << 4u)) : static_cast<std::uint8_t>((bits) & ~(1u << 4u)));
+        bits = (value ? static_cast<std::uint8_t>((bits) | (static_cast<std::uint8_t>(1) << 4u)) : static_cast<std::uint8_t>((bits) & ~(static_cast<std::uint8_t>(1) << 4u)));
         std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t));
         return *this;
     }
 
     static bool reserved3(const std::uint8_t bits)
     {
-        return (bits & (1u << 5u)) != 0;
+        return (bits & (static_cast<std::uint8_t>(1) << 5u)) != 0;
     }
 
     static std::uint8_t reserved3(const std::uint8_t bits, const bool value)
     {
-        return value ? static_cast<std::uint8_t>(bits | (1u << 5u)) : static_cast<std::uint8_t>(bits & ~(1u << 5u));
+        return value ? static_cast<std::uint8_t>(bits | (static_cast<std::uint8_t>(1) << 5u)) : static_cast<std::uint8_t>(bits & ~(static_cast<std::uint8_t>(1) << 5u));
     }
 
     SBE_NODISCARD bool reserved3() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t));
-        return ((val) & (1u << 5u)) != 0;
+        return ((val) & (static_cast<std::uint8_t>(1) << 5u)) != 0;
     }
 
     ExecInst &reserved3(const bool value)
     {
         std::uint8_t bits;
         std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t));
-        bits = (value ? static_cast<std::uint8_t>((bits) | (1u << 5u)) : static_cast<std::uint8_t>((bits) & ~(1u << 5u)));
+        bits = (value ? static_cast<std::uint8_t>((bits) | (static_cast<std::uint8_t>(1) << 5u)) : static_cast<std::uint8_t>((bits) & ~(static_cast<std::uint8_t>(1) << 5u)));
         std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t));
         return *this;
     }
 
     static bool reserved4(const std::uint8_t bits)
     {
-        return (bits & (1u << 6u)) != 0;
+        return (bits & (static_cast<std::uint8_t>(1) << 6u)) != 0;
     }
 
     static std::uint8_t reserved4(const std::uint8_t bits, const bool value)
     {
-        return value ? static_cast<std::uint8_t>(bits | (1u << 6u)) : static_cast<std::uint8_t>(bits & ~(1u << 6u));
+        return value ? static_cast<std::uint8_t>(bits | (static_cast<std::uint8_t>(1) << 6u)) : static_cast<std::uint8_t>(bits & ~(static_cast<std::uint8_t>(1) << 6u));
     }
 
     SBE_NODISCARD bool reserved4() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t));
-        return ((val) & (1u << 6u)) != 0;
+        return ((val) & (static_cast<std::uint8_t>(1) << 6u)) != 0;
     }
 
     ExecInst &reserved4(const bool value)
     {
         std::uint8_t bits;
         std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t));
-        bits = (value ? static_cast<std::uint8_t>((bits) | (1u << 6u)) : static_cast<std::uint8_t>((bits) & ~(1u << 6u)));
+        bits = (value ? static_cast<std::uint8_t>((bits) | (static_cast<std::uint8_t>(1) << 6u)) : static_cast<std::uint8_t>((bits) & ~(static_cast<std::uint8_t>(1) << 6u)));
         std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t));
         return *this;
     }
 
     static bool reserved5(const std::uint8_t bits)
     {
-        return (bits & (1u << 7u)) != 0;
+        return (bits & (static_cast<std::uint8_t>(1) << 7u)) != 0;
     }
 
     static std::uint8_t reserved5(const std::uint8_t bits, const bool value)
     {
-        return value ? static_cast<std::uint8_t>(bits | (1u << 7u)) : static_cast<std::uint8_t>(bits & ~(1u << 7u));
+        return value ? static_cast<std::uint8_t>(bits | (static_cast<std::uint8_t>(1) << 7u)) : static_cast<std::uint8_t>(bits & ~(static_cast<std::uint8_t>(1) << 7u));
     }
 
     SBE_NODISCARD bool reserved5() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t));
-        return ((val) & (1u << 7u)) != 0;
+        return ((val) & (static_cast<std::uint8_t>(1) << 7u)) != 0;
     }
 
     ExecInst &reserved5(const bool value)
     {
         std::uint8_t bits;
         std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t));
-        bits = (value ? static_cast<std::uint8_t>((bits) | (1u << 7u)) : static_cast<std::uint8_t>((bits) & ~(1u << 7u)));
+        bits = (value ? static_cast<std::uint8_t>((bits) | (static_cast<std::uint8_t>(1) << 7u)) : static_cast<std::uint8_t>((bits) & ~(static_cast<std::uint8_t>(1) << 7u)));
         std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t));
         return *this;
     }

src/lib/orderman/actors/ilink3/generated/ExecMode.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class ExecMode
 public:
     enum Value
     {
-        Aggressive = (char)65,
-        Passive = (char)80,
-        NULL_VALUE = (char)0
+        Aggressive = static_cast<char>(65),
+        Passive = static_cast<char>(80),
+        NULL_VALUE = static_cast<char>(0)
     };
 
     static ExecMode::Value get(const char value)
     {
         switch (value)
         {
-            case 65: return Aggressive;
-            case 80: return Passive;
-            case 0: return NULL_VALUE;
+            case static_cast<char>(65): return Aggressive;
+            case static_cast<char>(80): return Passive;
+            case static_cast<char>(0): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum ExecMode [E103]");
     }
 
-    static const char* c_str(const ExecMode::Value value)
+    static const char *c_str(const ExecMode::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/ExecReason.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,38 +94,38 @@ class ExecReason
 public:
     enum Value
     {
-        MarketExchangeOption = (std::uint8_t)8,
-        CancelledNotBest = (std::uint8_t)9,
-        CancelOnDisconnect = (std::uint8_t)100,
-        SelfMatchPreventionOldestOrderCancelled = (std::uint8_t)103,
-        CancelOnGlobexCreditControlsViolation = (std::uint8_t)104,
-        CancelFromFirmsoft = (std::uint8_t)105,
-        CancelFromRiskManagementAPI = (std::uint8_t)106,
-        SelfMatchPreventionNewestOrderCancelled = (std::uint8_t)107,
-        Cancelduetovolquotedoptionorderrestedqtylessthanminordersize = (std::uint8_t)108,
-        NULL_VALUE = (std::uint8_t)255
+        MarketExchangeOption = static_cast<std::uint8_t>(8),
+        CancelledNotBest = static_cast<std::uint8_t>(9),
+        CancelOnDisconnect = static_cast<std::uint8_t>(100),
+        SelfMatchPreventionOldestOrderCancelled = static_cast<std::uint8_t>(103),
+        CancelOnGlobexCreditControlsViolation = static_cast<std::uint8_t>(104),
+        CancelFromFirmsoft = static_cast<std::uint8_t>(105),
+        CancelFromRiskManagementAPI = static_cast<std::uint8_t>(106),
+        SelfMatchPreventionNewestOrderCancelled = static_cast<std::uint8_t>(107),
+        Cancelduetovolquotedoptionorderrestedqtylessthanminordersize = static_cast<std::uint8_t>(108),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static ExecReason::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 8: return MarketExchangeOption;
-            case 9: return CancelledNotBest;
-            case 100: return CancelOnDisconnect;
-            case 103: return SelfMatchPreventionOldestOrderCancelled;
-            case 104: return CancelOnGlobexCreditControlsViolation;
-            case 105: return CancelFromFirmsoft;
-            case 106: return CancelFromRiskManagementAPI;
-            case 107: return SelfMatchPreventionNewestOrderCancelled;
-            case 108: return Cancelduetovolquotedoptionorderrestedqtylessthanminordersize;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(8): return MarketExchangeOption;
+            case static_cast<std::uint8_t>(9): return CancelledNotBest;
+            case static_cast<std::uint8_t>(100): return CancelOnDisconnect;
+            case static_cast<std::uint8_t>(103): return SelfMatchPreventionOldestOrderCancelled;
+            case static_cast<std::uint8_t>(104): return CancelOnGlobexCreditControlsViolation;
+            case static_cast<std::uint8_t>(105): return CancelFromFirmsoft;
+            case static_cast<std::uint8_t>(106): return CancelFromRiskManagementAPI;
+            case static_cast<std::uint8_t>(107): return SelfMatchPreventionNewestOrderCancelled;
+            case static_cast<std::uint8_t>(108): return Cancelduetovolquotedoptionorderrestedqtylessthanminordersize;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum ExecReason [E103]");
     }
 
-    static const char* c_str(const ExecReason::Value value)
+    static const char *c_str(const ExecReason::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/ExecTypTrdCxl.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class ExecTypTrdCxl
 public:
     enum Value
     {
-        TradeCorrection = (char)71,
-        TradeCancel = (char)72,
-        NULL_VALUE = (char)0
+        TradeCorrection = static_cast<char>(71),
+        TradeCancel = static_cast<char>(72),
+        NULL_VALUE = static_cast<char>(0)
     };
 
     static ExecTypTrdCxl::Value get(const char value)
     {
         switch (value)
         {
-            case 71: return TradeCorrection;
-            case 72: return TradeCancel;
-            case 0: return NULL_VALUE;
+            case static_cast<char>(71): return TradeCorrection;
+            case static_cast<char>(72): return TradeCancel;
+            case static_cast<char>(0): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum ExecTypTrdCxl [E103]");
     }
 
-    static const char* c_str(const ExecTypTrdCxl::Value value)
+    static const char *c_str(const ExecTypTrdCxl::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/ExecutionAck539.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(101);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(539);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     ExecutionAck539() = default;
 
     ExecutionAck539(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)101;
+        return static_cast<std::uint16_t>(101);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)539;
+        return static_cast<std::uint16_t>(539);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "BN";
     }
@@ -258,7 +260,7 @@ public:
 
     ExecutionAck539 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = ExecutionAck539(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        ExecutionAck539 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        ExecutionAck539 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -381,12 +382,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -452,12 +453,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ExecAckStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ExecAckStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -521,7 +522,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ExecAckStatus::Value execAckStatus() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t execAckStatusRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ExecAckStatus::Value execAckStatus() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -535,7 +543,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -579,12 +587,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -606,7 +614,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -645,17 +653,17 @@ public:
 
     static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT
@@ -709,7 +717,7 @@ public:
             throw std::runtime_error("length too large for getClOrdID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -722,7 +730,7 @@ public:
     SBE_NODISCARD std::string getClOrdIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -767,7 +775,7 @@ public:
     SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -779,14 +787,14 @@ public:
     #if __cplusplus >= 201703L
     ExecutionAck539 &putClOrdID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putClOrdID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -796,14 +804,14 @@ public:
     #else
     ExecutionAck539 &putClOrdID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putClOrdID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -812,7 +820,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * SecExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SecExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -856,12 +864,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t secExecIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t secExecIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t secExecIDEncodingLength() SBE_NOEXCEPT
@@ -883,7 +891,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -930,7 +938,7 @@ public:
         return m_lastPx;
     }
 
-    SBE_NODISCARD static const char * SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -974,12 +982,12 @@ public:
 
     static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
     {
-        return -2147483647;
+        return INT32_C(-2147483647);
     }
 
     static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
     {
-        return 2147483647;
+        return INT32_C(2147483647);
     }
 
     static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -1001,7 +1009,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1045,12 +1053,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t lastQtyMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t lastQtyMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT
@@ -1072,7 +1080,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * DKReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *DKReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1114,7 +1122,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD DKReason::Value dKReason() const SBE_NOEXCEPT
+    SBE_NODISCARD char dKReasonRaw() const SBE_NOEXCEPT
+    {
+        char val;
+        std::memcpy(&val, m_buffer + m_offset + 65, sizeof(char));
+        return (val);
+    }
+
+    SBE_NODISCARD DKReason::Value dKReason() const
     {
         char val;
         std::memcpy(&val, m_buffer + m_offset + 65, sizeof(char));
@@ -1128,7 +1143,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1170,7 +1185,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD SideReq::Value side() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t));
@@ -1184,7 +1206,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1223,17 +1245,17 @@ public:
 
     static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -1275,7 +1297,7 @@ public:
 
         if (m_actingVersion < 4)
         {
-            return (char)0;
+            return static_cast<char>(0);
         }
 
         char val;
@@ -1307,7 +1329,7 @@ public:
             return 0;
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 67, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 67, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1320,7 +1342,7 @@ public:
     SBE_NODISCARD std::string getSenderIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 67;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1365,7 +1387,7 @@ public:
     SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 67;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1377,14 +1399,14 @@ public:
     #if __cplusplus >= 201703L
     ExecutionAck539 &putSenderID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 67, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 67 + start] = 0;
         }
@@ -1394,14 +1416,14 @@ public:
     #else
     ExecutionAck539 &putSenderID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 67, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 67 + start] = 0;
         }
@@ -1410,7 +1432,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1454,12 +1476,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1471,7 +1493,7 @@ public:
     {
         if (m_actingVersion < 5)
         {
-            return 0xffffffffffffffffL;
+            return UINT64_C(0xffffffffffffffff);
         }
 
         std::uint64_t val;
@@ -1486,7 +1508,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1525,17 +1547,17 @@ public:
 
     static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1577,7 +1599,7 @@ public:
 
         if (m_actingVersion < 5)
         {
-            return (char)0;
+            return static_cast<char>(0);
         }
 
         char val;
@@ -1609,7 +1631,7 @@ public:
             return 0;
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 95, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 95, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1622,7 +1644,7 @@ public:
     SBE_NODISCARD std::string getLocationAsString() const
     {
         const char *buffer = m_buffer + m_offset + 95;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1667,7 +1689,7 @@ public:
     SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 95;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1679,14 +1701,14 @@ public:
     #if __cplusplus >= 201703L
     ExecutionAck539 &putLocation(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 95, str.data(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 95 + start] = 0;
         }
@@ -1696,14 +1718,14 @@ public:
     #else
     ExecutionAck539 &putLocation(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 95, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 95 + start] = 0;
         }
@@ -1712,7 +1734,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1754,7 +1776,19 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT
+    {
+        if (m_actingVersion < 5)
+        {
+            return static_cast<std::uint8_t>(255);
+        }
+
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 100, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const
     {
         if (m_actingVersion < 5)
         {
@@ -1861,13 +1895,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return true;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+SBE_NODISCARD static std::size_t computeLength()
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
+    std::size_t length = sbeBlockLength();
 
     return length;
 #if defined(__GNUG__) && !defined(__clang__)

src/lib/orderman/actors/ilink3/generated/ExpCycle.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class ExpCycle
 public:
     enum Value
     {
-        ExpireOnTradingSessionClose = (std::uint8_t)0,
-        Expirationatgivendate = (std::uint8_t)2,
-        NULL_VALUE = (std::uint8_t)255
+        ExpireOnTradingSessionClose = static_cast<std::uint8_t>(0),
+        Expirationatgivendate = static_cast<std::uint8_t>(2),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static ExpCycle::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 0: return ExpireOnTradingSessionClose;
-            case 2: return Expirationatgivendate;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(0): return ExpireOnTradingSessionClose;
+            case static_cast<std::uint8_t>(2): return Expirationatgivendate;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum ExpCycle [E103]");
     }
 
-    static const char* c_str(const ExpCycle::Value value)
+    static const char *c_str(const ExpCycle::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/FTI.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class FTI
 public:
     enum Value
     {
-        Backup = (std::uint8_t)0,
-        Primary = (std::uint8_t)1,
-        NULL_VALUE = (std::uint8_t)255
+        Backup = static_cast<std::uint8_t>(0),
+        Primary = static_cast<std::uint8_t>(1),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static FTI::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 0: return Backup;
-            case 1: return Primary;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(0): return Backup;
+            case static_cast<std::uint8_t>(1): return Primary;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum FTI [E103]");
     }
 
-    static const char* c_str(const FTI::Value value)
+    static const char *c_str(const FTI::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/GroupSize.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -172,12 +167,12 @@ public:
         return m_offset;
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -194,15 +189,15 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static const char * blockLengthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *blockLengthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -245,12 +240,12 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t blockLengthMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t blockLengthMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t blockLengthEncodingLength() SBE_NOEXCEPT
@@ -272,7 +267,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * numInGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *numInGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -315,12 +310,12 @@ public:
 
     static SBE_CONSTEXPR std::uint8_t numInGroupMinValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)0;
+        return static_cast<std::uint8_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint8_t numInGroupMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)254;
+        return static_cast<std::uint8_t>(254);
     }
 
     static SBE_CONSTEXPR std::size_t numInGroupEncodingLength() SBE_NOEXCEPT

src/lib/orderman/actors/ilink3/generated/KeepAliveLapsed.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class KeepAliveLapsed
 public:
     enum Value
     {
-        NotLapsed = (std::uint8_t)0,
-        Lapsed = (std::uint8_t)1,
-        NULL_VALUE = (std::uint8_t)255
+        NotLapsed = static_cast<std::uint8_t>(0),
+        Lapsed = static_cast<std::uint8_t>(1),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static KeepAliveLapsed::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 0: return NotLapsed;
-            case 1: return Lapsed;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(0): return NotLapsed;
+            case static_cast<std::uint8_t>(1): return Lapsed;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum KeepAliveLapsed [E103]");
     }
 
-    static const char* c_str(const KeepAliveLapsed::Value value)
+    static const char *c_str(const KeepAliveLapsed::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/ListUpdAct.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class ListUpdAct
 public:
     enum Value
     {
-        Add = (char)65,
-        Delete = (char)68,
-        NULL_VALUE = (char)0
+        Add = static_cast<char>(65),
+        Delete = static_cast<char>(68),
+        NULL_VALUE = static_cast<char>(0)
     };
 
     static ListUpdAct::Value get(const char value)
     {
         switch (value)
         {
-            case 65: return Add;
-            case 68: return Delete;
-            case 0: return NULL_VALUE;
+            case static_cast<char>(65): return Add;
+            case static_cast<char>(68): return Delete;
+            case static_cast<char>(0): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum ListUpdAct [E103]");
     }
 
-    static const char* c_str(const ListUpdAct::Value value)
+    static const char *c_str(const ListUpdAct::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/ManualOrdInd.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class ManualOrdInd
 public:
     enum Value
     {
-        Automated = (std::uint8_t)0,
-        Manual = (std::uint8_t)1,
-        NULL_VALUE = (std::uint8_t)255
+        Automated = static_cast<std::uint8_t>(0),
+        Manual = static_cast<std::uint8_t>(1),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static ManualOrdInd::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 0: return Automated;
-            case 1: return Manual;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(0): return Automated;
+            case static_cast<std::uint8_t>(1): return Manual;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum ManualOrdInd [E103]");
     }
 
-    static const char* c_str(const ManualOrdInd::Value value)
+    static const char *c_str(const ManualOrdInd::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/ManualOrdIndReq.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class ManualOrdIndReq
 public:
     enum Value
     {
-        Automated = (std::uint8_t)0,
-        Manual = (std::uint8_t)1,
-        NULL_VALUE = (std::uint8_t)255
+        Automated = static_cast<std::uint8_t>(0),
+        Manual = static_cast<std::uint8_t>(1),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static ManualOrdIndReq::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 0: return Automated;
-            case 1: return Manual;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(0): return Automated;
+            case static_cast<std::uint8_t>(1): return Manual;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum ManualOrdIndReq [E103]");
     }
 
-    static const char* c_str(const ManualOrdIndReq::Value value)
+    static const char *c_str(const ManualOrdIndReq::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/MassActionOrdTyp.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class MassActionOrdTyp
 public:
     enum Value
     {
-        Limit = (char)50,
-        StopLimit = (char)52,
-        NULL_VALUE = (char)0
+        Limit = static_cast<char>(50),
+        StopLimit = static_cast<char>(52),
+        NULL_VALUE = static_cast<char>(0)
     };
 
     static MassActionOrdTyp::Value get(const char value)
     {
         switch (value)
         {
-            case 50: return Limit;
-            case 52: return StopLimit;
-            case 0: return NULL_VALUE;
+            case static_cast<char>(50): return Limit;
+            case static_cast<char>(52): return StopLimit;
+            case static_cast<char>(0): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum MassActionOrdTyp [E103]");
     }
 
-    static const char* c_str(const MassActionOrdTyp::Value value)
+    static const char *c_str(const MassActionOrdTyp::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/MassActionResponse.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class MassActionResponse
 public:
     enum Value
     {
-        Rejected = (std::uint8_t)0,
-        Accepted = (std::uint8_t)1,
-        NULL_VALUE = (std::uint8_t)255
+        Rejected = static_cast<std::uint8_t>(0),
+        Accepted = static_cast<std::uint8_t>(1),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static MassActionResponse::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 0: return Rejected;
-            case 1: return Accepted;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(0): return Rejected;
+            case static_cast<std::uint8_t>(1): return Accepted;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum MassActionResponse [E103]");
     }
 
-    static const char* c_str(const MassActionResponse::Value value)
+    static const char *c_str(const MassActionResponse::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/MassActionScope.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,30 +94,30 @@ class MassActionScope
 public:
     enum Value
     {
-        Instrument = (std::uint8_t)1,
-        All = (std::uint8_t)7,
-        MarketSegmentID = (std::uint8_t)9,
-        InstrumentGroup = (std::uint8_t)10,
-        QuoteSetID = (std::uint8_t)100,
-        NULL_VALUE = (std::uint8_t)255
+        Instrument = static_cast<std::uint8_t>(1),
+        All = static_cast<std::uint8_t>(7),
+        MarketSegmentID = static_cast<std::uint8_t>(9),
+        InstrumentGroup = static_cast<std::uint8_t>(10),
+        QuoteSetID = static_cast<std::uint8_t>(100),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static MassActionScope::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 1: return Instrument;
-            case 7: return All;
-            case 9: return MarketSegmentID;
-            case 10: return InstrumentGroup;
-            case 100: return QuoteSetID;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(1): return Instrument;
+            case static_cast<std::uint8_t>(7): return All;
+            case static_cast<std::uint8_t>(9): return MarketSegmentID;
+            case static_cast<std::uint8_t>(10): return InstrumentGroup;
+            case static_cast<std::uint8_t>(100): return QuoteSetID;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum MassActionScope [E103]");
     }
 
-    static const char* c_str(const MassActionScope::Value value)
+    static const char *c_str(const MassActionScope::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/MassCancelTIF.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,26 +94,26 @@ class MassCancelTIF
 public:
     enum Value
     {
-        Day = (std::uint8_t)0,
-        GoodTillCancel = (std::uint8_t)1,
-        GoodTillDate = (std::uint8_t)6,
-        NULL_VALUE = (std::uint8_t)255
+        Day = static_cast<std::uint8_t>(0),
+        GoodTillCancel = static_cast<std::uint8_t>(1),
+        GoodTillDate = static_cast<std::uint8_t>(6),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static MassCancelTIF::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 0: return Day;
-            case 1: return GoodTillCancel;
-            case 6: return GoodTillDate;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(0): return Day;
+            case static_cast<std::uint8_t>(1): return GoodTillCancel;
+            case static_cast<std::uint8_t>(6): return GoodTillDate;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum MassCancelTIF [E103]");
     }
 
-    static const char* c_str(const MassCancelTIF::Value value)
+    static const char *c_str(const MassCancelTIF::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/MassCxlReqTyp.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class MassCxlReqTyp
 public:
     enum Value
     {
-        SenderSubID = (std::uint8_t)100,
-        Account = (std::uint8_t)101,
-        NULL_VALUE = (std::uint8_t)255
+        SenderSubID = static_cast<std::uint8_t>(100),
+        Account = static_cast<std::uint8_t>(101),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static MassCxlReqTyp::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 100: return SenderSubID;
-            case 101: return Account;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(100): return SenderSubID;
+            case static_cast<std::uint8_t>(101): return Account;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum MassCxlReqTyp [E103]");
     }
 
-    static const char* c_str(const MassCxlReqTyp::Value value)
+    static const char *c_str(const MassCxlReqTyp::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/MassQuote517.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(92);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(517);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     MassQuote517() = default;
 
     MassQuote517(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)92;
+        return static_cast<std::uint16_t>(92);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)517;
+        return static_cast<std::uint16_t>(517);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "i";
     }
@@ -258,7 +260,7 @@ public:
 
     MassQuote517 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = MassQuote517(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        MassQuote517 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        MassQuote517 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -381,12 +382,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -452,12 +453,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -521,7 +522,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -535,7 +543,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -579,12 +587,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -606,7 +614,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -645,17 +653,17 @@ public:
 
     static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -709,7 +717,7 @@ public:
             throw std::runtime_error("length too large for getSenderID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -722,7 +730,7 @@ public:
     SBE_NODISCARD std::string getSenderIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -767,7 +775,7 @@ public:
     SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -779,14 +787,14 @@ public:
     #if __cplusplus >= 201703L
     MassQuote517 &putSenderID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -796,14 +804,14 @@ public:
     #else
     MassQuote517 &putSenderID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -812,7 +820,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * QuoteReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *QuoteReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -851,17 +859,17 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t quoteReqIDNullValue() SBE_NOEXCEPT
     {
-        return 0xffffffffffffffffL;
+        return UINT64_C(0xffffffffffffffff);
     }
 
     static SBE_CONSTEXPR std::uint64_t quoteReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t quoteReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t quoteReqIDEncodingLength() SBE_NOEXCEPT
@@ -883,7 +891,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -922,17 +930,17 @@ public:
 
     static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -986,7 +994,7 @@ public:
             throw std::runtime_error("length too large for getLocation [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 49, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 49, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -999,7 +1007,7 @@ public:
     SBE_NODISCARD std::string getLocationAsString() const
     {
         const char *buffer = m_buffer + m_offset + 49;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1044,7 +1052,7 @@ public:
     SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 49;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1056,14 +1064,14 @@ public:
     #if __cplusplus >= 201703L
     MassQuote517 &putLocation(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 49, str.data(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 49 + start] = 0;
         }
@@ -1073,14 +1081,14 @@ public:
     #else
     MassQuote517 &putLocation(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 49, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 49 + start] = 0;
         }
@@ -1089,7 +1097,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * QuoteIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *QuoteIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1133,12 +1141,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t quoteIDMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t quoteIDMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t quoteIDEncodingLength() SBE_NOEXCEPT
@@ -1160,7 +1168,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * TotNoQuoteEntriesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *TotNoQuoteEntriesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1204,12 +1212,12 @@ public:
 
     static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesMinValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)0;
+        return static_cast<std::uint8_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)254;
+        return static_cast<std::uint8_t>(254);
     }
 
     static SBE_CONSTEXPR std::size_t totNoQuoteEntriesEncodingLength() SBE_NOEXCEPT
@@ -1231,7 +1239,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * MMProtectionResetMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *MMProtectionResetMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1273,7 +1281,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD BooleanFlag::Value mMProtectionReset() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t mMProtectionResetRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 59, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD BooleanFlag::Value mMProtectionReset() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 59, sizeof(std::uint8_t));
@@ -1287,7 +1302,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1329,7 +1344,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 60, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD BooleanNULL::Value liquidityFlag() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 60, sizeof(std::uint8_t));
@@ -1343,7 +1365,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1385,7 +1407,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ShortSaleType::Value shortSaleType() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t shortSaleTypeRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 61, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ShortSaleType::Value shortSaleType() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 61, sizeof(std::uint8_t));
@@ -1399,7 +1428,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ReservedMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ReservedMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1438,17 +1467,17 @@ public:
 
     static SBE_CONSTEXPR char reservedNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char reservedMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char reservedMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t reservedEncodingLength() SBE_NOEXCEPT
@@ -1490,7 +1519,7 @@ public:
 
         if (m_actingVersion < 5)
         {
-            return (char)0;
+            return static_cast<char>(0);
         }
 
         char val;
@@ -1522,7 +1551,7 @@ public:
             return 0;
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 62, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 62, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1535,7 +1564,7 @@ public:
     SBE_NODISCARD std::string getReservedAsString() const
     {
         const char *buffer = m_buffer + m_offset + 62;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 30 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1580,7 +1609,7 @@ public:
     SBE_NODISCARD std::string_view getReservedAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 62;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 30 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1592,14 +1621,14 @@ public:
     #if __cplusplus >= 201703L
     MassQuote517 &putReserved(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 30)
         {
             throw std::runtime_error("string too large for putReserved [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 62, str.data(), srcLength);
-        for (size_t start = srcLength; start < 30; ++start)
+        for (std::size_t start = srcLength; start < 30; ++start)
         {
             m_buffer[m_offset + 62 + start] = 0;
         }
@@ -1609,14 +1638,14 @@ public:
     #else
     MassQuote517 &putReserved(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 30)
         {
             throw std::runtime_error("string too large for putReserved [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 62, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 30; ++start)
+        for (std::size_t start = srcLength; start < 30; ++start)
         {
             m_buffer[m_offset + 62 + start] = 0;
         }
@@ -1683,8 +1712,8 @@ public:
             m_buffer = buffer;
             m_bufferLength = bufferLength;
             GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
-            dimensions.blockLength((std::uint16_t)38);
-            dimensions.numInGroup((std::uint8_t)count);
+            dimensions.blockLength(static_cast<std::uint16_t>(38));
+            dimensions.numInGroup(static_cast<std::uint8_t>(count));
             m_index = 0;
             m_count = count;
             m_blockLength = 38;
@@ -1755,7 +1784,7 @@ public:
         {
             m_count = m_index;
             GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion);
-            dimensions.numInGroup((std::uint8_t)m_count);
+            dimensions.numInGroup(static_cast<std::uint8_t>(m_count));
             return m_count;
         }
 
@@ -1781,7 +1810,7 @@ public:
 
     #endif
 
-        SBE_NODISCARD static const char * BidPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *BidPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -1828,7 +1857,7 @@ public:
             return m_bidPx;
         }
 
-        SBE_NODISCARD static const char * OfferPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *OfferPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -1875,7 +1904,7 @@ public:
             return m_offerPx;
         }
 
-        SBE_NODISCARD static const char * QuoteEntryIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *QuoteEntryIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -1919,12 +1948,12 @@ public:
 
         static SBE_CONSTEXPR std::uint32_t quoteEntryIDMinValue() SBE_NOEXCEPT
         {
-            return 0;
+            return UINT32_C(0x0);
         }
 
         static SBE_CONSTEXPR std::uint32_t quoteEntryIDMaxValue() SBE_NOEXCEPT
         {
-            return 4294967294;
+            return UINT32_C(0xfffffffe);
         }
 
         static SBE_CONSTEXPR std::size_t quoteEntryIDEncodingLength() SBE_NOEXCEPT
@@ -1946,7 +1975,7 @@ public:
             return *this;
         }
 
-        SBE_NODISCARD static const char * SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -1990,12 +2019,12 @@ public:
 
         static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
         {
-            return -2147483647;
+            return INT32_C(-2147483647);
         }
 
         static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
         {
-            return 2147483647;
+            return INT32_C(2147483647);
         }
 
         static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -2017,7 +2046,7 @@ public:
             return *this;
         }
 
-        SBE_NODISCARD static const char * BidSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *BidSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2056,17 +2085,17 @@ public:
 
         static SBE_CONSTEXPR std::uint32_t bidSizeNullValue() SBE_NOEXCEPT
         {
-            return 4294967295;
+            return UINT32_C(0xffffffff);
         }
 
         static SBE_CONSTEXPR std::uint32_t bidSizeMinValue() SBE_NOEXCEPT
         {
-            return 0;
+            return UINT32_C(0x0);
         }
 
         static SBE_CONSTEXPR std::uint32_t bidSizeMaxValue() SBE_NOEXCEPT
         {
-            return 4294967294;
+            return UINT32_C(0xfffffffe);
         }
 
         static SBE_CONSTEXPR std::size_t bidSizeEncodingLength() SBE_NOEXCEPT
@@ -2088,7 +2117,7 @@ public:
             return *this;
         }
 
-        SBE_NODISCARD static const char * OfferSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *OfferSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2127,17 +2156,17 @@ public:
 
         static SBE_CONSTEXPR std::uint32_t offerSizeNullValue() SBE_NOEXCEPT
         {
-            return 4294967295;
+            return UINT32_C(0xffffffff);
         }
 
         static SBE_CONSTEXPR std::uint32_t offerSizeMinValue() SBE_NOEXCEPT
         {
-            return 0;
+            return UINT32_C(0x0);
         }
 
         static SBE_CONSTEXPR std::uint32_t offerSizeMaxValue() SBE_NOEXCEPT
         {
-            return 4294967294;
+            return UINT32_C(0xfffffffe);
         }
 
         static SBE_CONSTEXPR std::size_t offerSizeEncodingLength() SBE_NOEXCEPT
@@ -2159,7 +2188,7 @@ public:
             return *this;
         }
 
-        SBE_NODISCARD static const char * UnderlyingSecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *UnderlyingSecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2198,17 +2227,17 @@ public:
 
         static SBE_CONSTEXPR std::int32_t underlyingSecurityIDNullValue() SBE_NOEXCEPT
         {
-            return 2147483647;
+            return INT32_C(2147483647);
         }
 
         static SBE_CONSTEXPR std::int32_t underlyingSecurityIDMinValue() SBE_NOEXCEPT
         {
-            return -2147483647;
+            return INT32_C(-2147483647);
         }
 
         static SBE_CONSTEXPR std::int32_t underlyingSecurityIDMaxValue() SBE_NOEXCEPT
         {
-            return 2147483647;
+            return INT32_C(2147483647);
         }
 
         static SBE_CONSTEXPR std::size_t underlyingSecurityIDEncodingLength() SBE_NOEXCEPT
@@ -2230,7 +2259,7 @@ public:
             return *this;
         }
 
-        SBE_NODISCARD static const char * QuoteSetIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *QuoteSetIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2274,12 +2303,12 @@ public:
 
         static SBE_CONSTEXPR std::uint16_t quoteSetIDMinValue() SBE_NOEXCEPT
         {
-            return (std::uint16_t)0;
+            return static_cast<std::uint16_t>(0);
         }
 
         static SBE_CONSTEXPR std::uint16_t quoteSetIDMaxValue() SBE_NOEXCEPT
         {
-            return (std::uint16_t)65534;
+            return static_cast<std::uint16_t>(65534);
         }
 
         static SBE_CONSTEXPR std::size_t quoteSetIDEncodingLength() SBE_NOEXCEPT
@@ -2351,13 +2380,13 @@ public:
             return true;
         }
 
-        SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+        SBE_NODISCARD static std::size_t computeLength()
         {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-            size_t length = sbeBlockLength();
+            std::size_t length = sbeBlockLength();
 
             return length;
 #if defined(__GNUG__) && !defined(__clang__)
@@ -2504,21 +2533,21 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return false;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength(std::size_t NoQuoteEntriesLength = 0)
+SBE_NODISCARD static std::size_t computeLength(std::size_t noQuoteEntriesLength = 0)
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
-
+    std::size_t length = sbeBlockLength();
 
     length += NoQuoteEntries::sbeHeaderSize();
-    if (NoQuoteEntriesLength > 254)
+    if (noQuoteEntriesLength > 254LL)
     {
-        throw std::runtime_error("NoQuoteEntriesLength outside of allowed range [E110]");
+        throw std::runtime_error("noQuoteEntriesLength outside of allowed range [E110]");
     }
-    length += NoQuoteEntriesLength * NoQuoteEntries::sbeBlockLength();
+    length += noQuoteEntriesLength *NoQuoteEntries::sbeBlockLength();
+
     return length;
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic pop

src/lib/orderman/actors/ilink3/generated/MassQuoteAck545.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(350);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(545);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     MassQuoteAck545() = default;
 
     MassQuoteAck545(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)350;
+        return static_cast<std::uint16_t>(350);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)545;
+        return static_cast<std::uint16_t>(545);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "b";
     }
@@ -258,7 +260,7 @@ public:
 
     MassQuoteAck545 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = MassQuoteAck545(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        MassQuoteAck545 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        MassQuoteAck545 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -381,12 +382,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -452,12 +453,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -518,17 +519,17 @@ public:
 
     static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT
@@ -582,7 +583,7 @@ public:
             throw std::runtime_error("length too large for getText [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -595,7 +596,7 @@ public:
     SBE_NODISCARD std::string getTextAsString() const
     {
         const char *buffer = m_buffer + m_offset + 12;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 256 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -640,7 +641,7 @@ public:
     SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 12;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 256 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -652,14 +653,14 @@ public:
     #if __cplusplus >= 201703L
     MassQuoteAck545 &putText(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 256)
         {
             throw std::runtime_error("string too large for putText [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength);
-        for (size_t start = srcLength; start < 256; ++start)
+        for (std::size_t start = srcLength; start < 256; ++start)
         {
             m_buffer[m_offset + 12 + start] = 0;
         }
@@ -669,14 +670,14 @@ public:
     #else
     MassQuoteAck545 &putText(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 256)
         {
             throw std::runtime_error("string too large for putText [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 256; ++start)
+        for (std::size_t start = srcLength; start < 256; ++start)
         {
             m_buffer[m_offset + 12 + start] = 0;
         }
@@ -685,7 +686,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -724,17 +725,17 @@ public:
 
     static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -788,7 +789,7 @@ public:
             throw std::runtime_error("length too large for getSenderID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 268, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 268, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -801,7 +802,7 @@ public:
     SBE_NODISCARD std::string getSenderIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 268;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -846,7 +847,7 @@ public:
     SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 268;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -858,14 +859,14 @@ public:
     #if __cplusplus >= 201703L
     MassQuoteAck545 &putSenderID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 268 + start] = 0;
         }
@@ -875,14 +876,14 @@ public:
     #else
     MassQuoteAck545 &putSenderID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 268 + start] = 0;
         }
@@ -891,7 +892,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -935,12 +936,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -962,7 +963,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * RequestTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *RequestTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1006,12 +1007,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t requestTimeMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t requestTimeMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t requestTimeEncodingLength() SBE_NOEXCEPT
@@ -1033,7 +1034,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1077,12 +1078,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1104,7 +1105,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * QuoteReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *QuoteReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1143,17 +1144,17 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t quoteReqIDNullValue() SBE_NOEXCEPT
     {
-        return 0xffffffffffffffffL;
+        return UINT64_C(0xffffffffffffffff);
     }
 
     static SBE_CONSTEXPR std::uint64_t quoteReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t quoteReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t quoteReqIDEncodingLength() SBE_NOEXCEPT
@@ -1175,7 +1176,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1214,17 +1215,17 @@ public:
 
     static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1278,7 +1279,7 @@ public:
             throw std::runtime_error("length too large for getLocation [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 320, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 320, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1291,7 +1292,7 @@ public:
     SBE_NODISCARD std::string getLocationAsString() const
     {
         const char *buffer = m_buffer + m_offset + 320;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1336,7 +1337,7 @@ public:
     SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 320;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1348,14 +1349,14 @@ public:
     #if __cplusplus >= 201703L
     MassQuoteAck545 &putLocation(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 320, str.data(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 320 + start] = 0;
         }
@@ -1365,14 +1366,14 @@ public:
     #else
     MassQuoteAck545 &putLocation(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 320, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 320 + start] = 0;
         }
@@ -1381,7 +1382,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * QuoteIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *QuoteIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1425,12 +1426,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t quoteIDMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t quoteIDMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t quoteIDEncodingLength() SBE_NOEXCEPT
@@ -1452,7 +1453,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * QuoteRejectReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *QuoteRejectReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1491,17 +1492,17 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t quoteRejectReasonNullValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65535;
+        return static_cast<std::uint16_t>(65535);
     }
 
     static SBE_CONSTEXPR std::uint16_t quoteRejectReasonMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t quoteRejectReasonMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t quoteRejectReasonEncodingLength() SBE_NOEXCEPT
@@ -1523,7 +1524,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1562,17 +1563,17 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65535;
+        return static_cast<std::uint16_t>(65535);
     }
 
     static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT
@@ -1594,7 +1595,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * QuoteStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *QuoteStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1636,7 +1637,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD QuoteAckStatus::Value quoteStatus() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t quoteStatusRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 333, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD QuoteAckStatus::Value quoteStatus() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 333, sizeof(std::uint8_t));
@@ -1650,7 +1658,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1692,7 +1700,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 334, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 334, sizeof(std::uint8_t));
@@ -1706,7 +1721,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * NoProcessedEntriesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *NoProcessedEntriesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1750,12 +1765,12 @@ public:
 
     static SBE_CONSTEXPR std::uint8_t noProcessedEntriesMinValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)0;
+        return static_cast<std::uint8_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint8_t noProcessedEntriesMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)254;
+        return static_cast<std::uint8_t>(254);
     }
 
     static SBE_CONSTEXPR std::size_t noProcessedEntriesEncodingLength() SBE_NOEXCEPT
@@ -1777,7 +1792,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * MMProtectionResetMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *MMProtectionResetMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1819,7 +1834,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD BooleanFlag::Value mMProtectionReset() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t mMProtectionResetRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 336, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD BooleanFlag::Value mMProtectionReset() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 336, sizeof(std::uint8_t));
@@ -1833,7 +1855,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1875,7 +1897,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 337, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD SplitMsg::Value splitMsg() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 337, sizeof(std::uint8_t));
@@ -1889,7 +1918,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1931,7 +1960,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 338, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD BooleanNULL::Value liquidityFlag() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 338, sizeof(std::uint8_t));
@@ -1945,7 +1981,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1987,7 +2023,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ShortSaleType::Value shortSaleType() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t shortSaleTypeRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 339, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ShortSaleType::Value shortSaleType() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 339, sizeof(std::uint8_t));
@@ -2001,7 +2044,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * TotNoQuoteEntriesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *TotNoQuoteEntriesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2040,17 +2083,17 @@ public:
 
     static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesNullValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)255;
+        return static_cast<std::uint8_t>(255);
     }
 
     static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesMinValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)0;
+        return static_cast<std::uint8_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)254;
+        return static_cast<std::uint8_t>(254);
     }
 
     static SBE_CONSTEXPR std::size_t totNoQuoteEntriesEncodingLength() SBE_NOEXCEPT
@@ -2072,7 +2115,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2114,7 +2157,19 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT
+    {
+        if (m_actingVersion < 2)
+        {
+            return static_cast<std::uint8_t>(255);
+        }
+
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 341, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD BooleanFlag::Value possRetransFlag() const
     {
         if (m_actingVersion < 2)
         {
@@ -2133,7 +2188,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2172,17 +2227,17 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT
     {
-        return 0xffffffffffffffffL;
+        return UINT64_C(0xffffffffffffffff);
     }
 
     static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT
@@ -2194,7 +2249,7 @@ public:
     {
         if (m_actingVersion < 4)
         {
-            return 0xffffffffffffffffL;
+            return UINT64_C(0xffffffffffffffff);
         }
 
         std::uint64_t val;
@@ -2267,8 +2322,8 @@ public:
             m_buffer = buffer;
             m_bufferLength = bufferLength;
             GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
-            dimensions.blockLength((std::uint16_t)11);
-            dimensions.numInGroup((std::uint8_t)count);
+            dimensions.blockLength(static_cast<std::uint16_t>(11));
+            dimensions.numInGroup(static_cast<std::uint8_t>(count));
             m_index = 0;
             m_count = count;
             m_blockLength = 11;
@@ -2339,7 +2394,7 @@ public:
         {
             m_count = m_index;
             GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion);
-            dimensions.numInGroup((std::uint8_t)m_count);
+            dimensions.numInGroup(static_cast<std::uint8_t>(m_count));
             return m_count;
         }
 
@@ -2365,7 +2420,7 @@ public:
 
     #endif
 
-        SBE_NODISCARD static const char * QuoteEntryIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *QuoteEntryIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2409,12 +2464,12 @@ public:
 
         static SBE_CONSTEXPR std::uint32_t quoteEntryIDMinValue() SBE_NOEXCEPT
         {
-            return 0;
+            return UINT32_C(0x0);
         }
 
         static SBE_CONSTEXPR std::uint32_t quoteEntryIDMaxValue() SBE_NOEXCEPT
         {
-            return 4294967294;
+            return UINT32_C(0xfffffffe);
         }
 
         static SBE_CONSTEXPR std::size_t quoteEntryIDEncodingLength() SBE_NOEXCEPT
@@ -2436,7 +2491,7 @@ public:
             return *this;
         }
 
-        SBE_NODISCARD static const char * SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2480,12 +2535,12 @@ public:
 
         static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
         {
-            return -2147483647;
+            return INT32_C(-2147483647);
         }
 
         static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
         {
-            return 2147483647;
+            return INT32_C(2147483647);
         }
 
         static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -2507,7 +2562,7 @@ public:
             return *this;
         }
 
-        SBE_NODISCARD static const char * QuoteSetIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *QuoteSetIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2551,12 +2606,12 @@ public:
 
         static SBE_CONSTEXPR std::uint16_t quoteSetIDMinValue() SBE_NOEXCEPT
         {
-            return (std::uint16_t)0;
+            return static_cast<std::uint16_t>(0);
         }
 
         static SBE_CONSTEXPR std::uint16_t quoteSetIDMaxValue() SBE_NOEXCEPT
         {
-            return (std::uint16_t)65534;
+            return static_cast<std::uint16_t>(65534);
         }
 
         static SBE_CONSTEXPR std::size_t quoteSetIDEncodingLength() SBE_NOEXCEPT
@@ -2578,7 +2633,7 @@ public:
             return *this;
         }
 
-        SBE_NODISCARD static const char * QuoteEntryRejectReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *QuoteEntryRejectReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2622,12 +2677,12 @@ public:
 
         static SBE_CONSTEXPR std::uint8_t quoteEntryRejectReasonMinValue() SBE_NOEXCEPT
         {
-            return (std::uint8_t)0;
+            return static_cast<std::uint8_t>(0);
         }
 
         static SBE_CONSTEXPR std::uint8_t quoteEntryRejectReasonMaxValue() SBE_NOEXCEPT
         {
-            return (std::uint8_t)254;
+            return static_cast<std::uint8_t>(254);
         }
 
         static SBE_CONSTEXPR std::size_t quoteEntryRejectReasonEncodingLength() SBE_NOEXCEPT
@@ -2683,13 +2738,13 @@ public:
             return true;
         }
 
-        SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+        SBE_NODISCARD static std::size_t computeLength()
         {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-            size_t length = sbeBlockLength();
+            std::size_t length = sbeBlockLength();
 
             return length;
 #if defined(__GNUG__) && !defined(__clang__)
@@ -2872,21 +2927,21 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return false;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength(std::size_t NoQuoteEntriesLength = 0)
+SBE_NODISCARD static std::size_t computeLength(std::size_t noQuoteEntriesLength = 0)
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
-
+    std::size_t length = sbeBlockLength();
 
     length += NoQuoteEntries::sbeHeaderSize();
-    if (NoQuoteEntriesLength > 254)
+    if (noQuoteEntriesLength > 254LL)
     {
-        throw std::runtime_error("NoQuoteEntriesLength outside of allowed range [E110]");
+        throw std::runtime_error("noQuoteEntriesLength outside of allowed range [E110]");
     }
-    length += NoQuoteEntriesLength * NoQuoteEntries::sbeBlockLength();
+    length += noQuoteEntriesLength *NoQuoteEntries::sbeBlockLength();
+
     return length;
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic pop

src/lib/orderman/actors/ilink3/generated/MassStatusOrdTyp.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class MassStatusOrdTyp
 public:
     enum Value
     {
-        SenderSubID = (std::uint8_t)100,
-        Account = (std::uint8_t)101,
-        NULL_VALUE = (std::uint8_t)255
+        SenderSubID = static_cast<std::uint8_t>(100),
+        Account = static_cast<std::uint8_t>(101),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static MassStatusOrdTyp::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 100: return SenderSubID;
-            case 101: return Account;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(100): return SenderSubID;
+            case static_cast<std::uint8_t>(101): return Account;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum MassStatusOrdTyp [E103]");
     }
 
-    static const char* c_str(const MassStatusOrdTyp::Value value)
+    static const char *c_str(const MassStatusOrdTyp::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/MassStatusReqTyp.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,26 +94,26 @@ class MassStatusReqTyp
 public:
     enum Value
     {
-        Instrument = (std::uint8_t)1,
-        InstrumentGroup = (std::uint8_t)3,
-        MarketSegment = (std::uint8_t)100,
-        NULL_VALUE = (std::uint8_t)255
+        Instrument = static_cast<std::uint8_t>(1),
+        InstrumentGroup = static_cast<std::uint8_t>(3),
+        MarketSegment = static_cast<std::uint8_t>(100),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static MassStatusReqTyp::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 1: return Instrument;
-            case 3: return InstrumentGroup;
-            case 100: return MarketSegment;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(1): return Instrument;
+            case static_cast<std::uint8_t>(3): return InstrumentGroup;
+            case static_cast<std::uint8_t>(100): return MarketSegment;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum MassStatusReqTyp [E103]");
     }
 
-    static const char* c_str(const MassStatusReqTyp::Value value)
+    static const char *c_str(const MassStatusReqTyp::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/MassStatusTIF.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,32 +94,35 @@ class MassStatusTIF
 public:
     enum Value
     {
-        Day = (std::uint8_t)0,
-        GTC = (std::uint8_t)1,
-        GTD = (std::uint8_t)6,
-        NULL_VALUE = (std::uint8_t)255
+        Day = static_cast<std::uint8_t>(0),
+        GTC = static_cast<std::uint8_t>(1),
+        GTD = static_cast<std::uint8_t>(6),
+        GFS = static_cast<std::uint8_t>(99),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static MassStatusTIF::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 0: return Day;
-            case 1: return GTC;
-            case 6: return GTD;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(0): return Day;
+            case static_cast<std::uint8_t>(1): return GTC;
+            case static_cast<std::uint8_t>(6): return GTD;
+            case static_cast<std::uint8_t>(99): return GFS;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum MassStatusTIF [E103]");
     }
 
-    static const char* c_str(const MassStatusTIF::Value value)
+    static const char *c_str(const MassStatusTIF::Value value)
     {
         switch (value)
         {
             case Day: return "Day";
             case GTC: return "GTC";
             case GTD: return "GTD";
+            case GFS: return "GFS";
             case NULL_VALUE: return "NULL_VALUE";
         }
 

src/lib/orderman/actors/ilink3/generated/MaturityMonthYear.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -172,12 +167,12 @@ public:
         return m_offset;
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -194,15 +189,15 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static const char * yearMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *yearMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -240,17 +235,17 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t yearNullValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65535;
+        return static_cast<std::uint16_t>(65535);
     }
 
     static SBE_CONSTEXPR std::uint16_t yearMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t yearMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t yearEncodingLength() SBE_NOEXCEPT
@@ -272,7 +267,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * monthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *monthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -310,17 +305,17 @@ public:
 
     static SBE_CONSTEXPR std::uint8_t monthNullValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)255;
+        return static_cast<std::uint8_t>(255);
     }
 
     static SBE_CONSTEXPR std::uint8_t monthMinValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)0;
+        return static_cast<std::uint8_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint8_t monthMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)254;
+        return static_cast<std::uint8_t>(254);
     }
 
     static SBE_CONSTEXPR std::size_t monthEncodingLength() SBE_NOEXCEPT
@@ -342,7 +337,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * dayMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *dayMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -380,17 +375,17 @@ public:
 
     static SBE_CONSTEXPR std::uint8_t dayNullValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)255;
+        return static_cast<std::uint8_t>(255);
     }
 
     static SBE_CONSTEXPR std::uint8_t dayMinValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)0;
+        return static_cast<std::uint8_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint8_t dayMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)254;
+        return static_cast<std::uint8_t>(254);
     }
 
     static SBE_CONSTEXPR std::size_t dayEncodingLength() SBE_NOEXCEPT
@@ -412,7 +407,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * weekMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *weekMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -450,17 +445,17 @@ public:
 
     static SBE_CONSTEXPR std::uint8_t weekNullValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)255;
+        return static_cast<std::uint8_t>(255);
     }
 
     static SBE_CONSTEXPR std::uint8_t weekMinValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)0;
+        return static_cast<std::uint8_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint8_t weekMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)254;
+        return static_cast<std::uint8_t>(254);
     }
 
     static SBE_CONSTEXPR std::size_t weekEncodingLength() SBE_NOEXCEPT

src/lib/orderman/actors/ilink3/generated/MessageHeader.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -172,12 +167,12 @@ public:
         return m_offset;
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -194,15 +189,15 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static const char * blockLengthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *blockLengthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -245,12 +240,12 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t blockLengthMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t blockLengthMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t blockLengthEncodingLength() SBE_NOEXCEPT
@@ -272,7 +267,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * templateIdMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *templateIdMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -315,12 +310,12 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t templateIdMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t templateIdMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t templateIdEncodingLength() SBE_NOEXCEPT
@@ -342,7 +337,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * schemaIdMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *schemaIdMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -385,12 +380,12 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t schemaIdMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t schemaIdMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t schemaIdEncodingLength() SBE_NOEXCEPT
@@ -412,7 +407,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * versionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *versionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -455,12 +450,12 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t versionMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t versionMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t versionEncodingLength() SBE_NOEXCEPT

src/lib/orderman/actors/ilink3/generated/Negotiate500.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(76);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(500);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     Negotiate500() = default;
 
     Negotiate500(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)76;
+        return static_cast<std::uint16_t>(76);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)500;
+        return static_cast<std::uint16_t>(500);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "Negotiate";
     }
@@ -258,7 +260,7 @@ public:
 
     Negotiate500 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = Negotiate500(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        Negotiate500 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        Negotiate500 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * CustomerFlowMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *CustomerFlowMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -376,17 +377,17 @@ public:
 
     static SBE_CONSTEXPR char customerFlowNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char customerFlowMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char customerFlowMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t customerFlowEncodingLength() SBE_NOEXCEPT
@@ -401,14 +402,14 @@ public:
 
     SBE_NODISCARD const char *customerFlow() const
     {
-        static const std::uint8_t customerFlowValues[] = { 73, 68, 69, 77, 80, 79, 84, 69, 78, 84 };
+        static const std::uint8_t customerFlowValues[] = { 73, 68, 69, 77, 80, 79, 84, 69, 78, 84, 0 };
 
         return (const char *)customerFlowValues;
     }
 
     SBE_NODISCARD char customerFlow(const std::uint64_t index) const
     {
-        static const std::uint8_t customerFlowValues[] = { 73, 68, 69, 77, 80, 79, 84, 69, 78, 84 };
+        static const std::uint8_t customerFlowValues[] = { 73, 68, 69, 77, 80, 79, 84, 69, 78, 84, 0 };
 
         return (char)customerFlowValues[index];
     }
@@ -418,7 +419,7 @@ public:
         static std::uint8_t customerFlowValues[] = { 73, 68, 69, 77, 80, 79, 84, 69, 78, 84 };
         std::uint64_t bytesToCopy = length < sizeof(customerFlowValues) ? length : sizeof(customerFlowValues);
 
-        std::memcpy(dst, customerFlowValues, static_cast<size_t>(bytesToCopy));
+        std::memcpy(dst, customerFlowValues, static_cast<std::size_t>(bytesToCopy));
         return bytesToCopy;
     }
 
@@ -462,7 +463,7 @@ public:
         return oss.str();
     }
 
-    SBE_NODISCARD static const char * HMACVersionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *HMACVersionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -501,17 +502,17 @@ public:
 
     static SBE_CONSTEXPR char hMACVersionNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char hMACVersionMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char hMACVersionMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t hMACVersionEncodingLength() SBE_NOEXCEPT
@@ -526,14 +527,14 @@ public:
 
     SBE_NODISCARD const char *hMACVersion() const
     {
-        static const std::uint8_t hMACVersionValues[] = { 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54 };
+        static const std::uint8_t hMACVersionValues[] = { 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54, 0 };
 
         return (const char *)hMACVersionValues;
     }
 
     SBE_NODISCARD char hMACVersion(const std::uint64_t index) const
     {
-        static const std::uint8_t hMACVersionValues[] = { 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54 };
+        static const std::uint8_t hMACVersionValues[] = { 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54, 0 };
 
         return (char)hMACVersionValues[index];
     }
@@ -543,7 +544,7 @@ public:
         static std::uint8_t hMACVersionValues[] = { 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54 };
         std::uint64_t bytesToCopy = length < sizeof(hMACVersionValues) ? length : sizeof(hMACVersionValues);
 
-        std::memcpy(dst, hMACVersionValues, static_cast<size_t>(bytesToCopy));
+        std::memcpy(dst, hMACVersionValues, static_cast<std::size_t>(bytesToCopy));
         return bytesToCopy;
     }
 
@@ -587,7 +588,7 @@ public:
         return oss.str();
     }
 
-    SBE_NODISCARD static const char * HMACSignatureMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *HMACSignatureMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -626,17 +627,17 @@ public:
 
     static SBE_CONSTEXPR char hMACSignatureNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char hMACSignatureMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char hMACSignatureMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t hMACSignatureEncodingLength() SBE_NOEXCEPT
@@ -690,7 +691,7 @@ public:
             throw std::runtime_error("length too large for getHMACSignature [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -703,7 +704,7 @@ public:
     SBE_NODISCARD std::string getHMACSignatureAsString() const
     {
         const char *buffer = m_buffer + m_offset + 0;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 32 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -748,7 +749,7 @@ public:
     SBE_NODISCARD std::string_view getHMACSignatureAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 0;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 32 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -760,14 +761,14 @@ public:
     #if __cplusplus >= 201703L
     Negotiate500 &putHMACSignature(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 32)
         {
             throw std::runtime_error("string too large for putHMACSignature [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength);
-        for (size_t start = srcLength; start < 32; ++start)
+        for (std::size_t start = srcLength; start < 32; ++start)
         {
             m_buffer[m_offset + 0 + start] = 0;
         }
@@ -777,14 +778,14 @@ public:
     #else
     Negotiate500 &putHMACSignature(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 32)
         {
             throw std::runtime_error("string too large for putHMACSignature [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 32; ++start)
+        for (std::size_t start = srcLength; start < 32; ++start)
         {
             m_buffer[m_offset + 0 + start] = 0;
         }
@@ -793,7 +794,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * AccessKeyIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *AccessKeyIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -832,17 +833,17 @@ public:
 
     static SBE_CONSTEXPR char accessKeyIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char accessKeyIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char accessKeyIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t accessKeyIDEncodingLength() SBE_NOEXCEPT
@@ -896,7 +897,7 @@ public:
             throw std::runtime_error("length too large for getAccessKeyID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 32, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 32, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -909,7 +910,7 @@ public:
     SBE_NODISCARD std::string getAccessKeyIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 32;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -954,7 +955,7 @@ public:
     SBE_NODISCARD std::string_view getAccessKeyIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 32;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -966,14 +967,14 @@ public:
     #if __cplusplus >= 201703L
     Negotiate500 &putAccessKeyID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putAccessKeyID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 32, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 32 + start] = 0;
         }
@@ -983,14 +984,14 @@ public:
     #else
     Negotiate500 &putAccessKeyID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putAccessKeyID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 32, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 32 + start] = 0;
         }
@@ -999,7 +1000,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1043,12 +1044,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -1070,7 +1071,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1114,12 +1115,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT
@@ -1141,7 +1142,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SessionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SessionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1180,17 +1181,17 @@ public:
 
     static SBE_CONSTEXPR char sessionNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char sessionMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char sessionMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t sessionEncodingLength() SBE_NOEXCEPT
@@ -1244,7 +1245,7 @@ public:
             throw std::runtime_error("length too large for getSession [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 68, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 68, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1272,7 +1273,7 @@ public:
     SBE_NODISCARD std::string getSessionAsString() const
     {
         const char *buffer = m_buffer + m_offset + 68;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 3 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1317,7 +1318,7 @@ public:
     SBE_NODISCARD std::string_view getSessionAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 68;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 3 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1329,14 +1330,14 @@ public:
     #if __cplusplus >= 201703L
     Negotiate500 &putSession(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 3)
         {
             throw std::runtime_error("string too large for putSession [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 68, str.data(), srcLength);
-        for (size_t start = srcLength; start < 3; ++start)
+        for (std::size_t start = srcLength; start < 3; ++start)
         {
             m_buffer[m_offset + 68 + start] = 0;
         }
@@ -1346,14 +1347,14 @@ public:
     #else
     Negotiate500 &putSession(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 3)
         {
             throw std::runtime_error("string too large for putSession [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 68, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 3; ++start)
+        for (std::size_t start = srcLength; start < 3; ++start)
         {
             m_buffer[m_offset + 68 + start] = 0;
         }
@@ -1362,7 +1363,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * FirmMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *FirmMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1401,17 +1402,17 @@ public:
 
     static SBE_CONSTEXPR char firmNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char firmMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char firmMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t firmEncodingLength() SBE_NOEXCEPT
@@ -1465,7 +1466,7 @@ public:
             throw std::runtime_error("length too large for getFirm [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 71, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 71, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1478,7 +1479,7 @@ public:
     SBE_NODISCARD std::string getFirmAsString() const
     {
         const char *buffer = m_buffer + m_offset + 71;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1523,7 +1524,7 @@ public:
     SBE_NODISCARD std::string_view getFirmAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 71;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1535,14 +1536,14 @@ public:
     #if __cplusplus >= 201703L
     Negotiate500 &putFirm(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putFirm [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 71, str.data(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 71 + start] = 0;
         }
@@ -1552,14 +1553,14 @@ public:
     #else
     Negotiate500 &putFirm(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putFirm [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 71, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 71 + start] = 0;
         }
@@ -1568,7 +1569,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * CredentialsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *CredentialsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1648,7 +1649,7 @@ public:
         std::uint64_t bytesToCopy = length < dataLength ? length : dataLength;
         std::uint64_t pos = sbePosition();
         sbePosition(pos + dataLength);
-        std::memcpy(dst, m_buffer + pos, static_cast<size_t>(bytesToCopy));
+        std::memcpy(dst, m_buffer + pos, static_cast<std::size_t>(bytesToCopy));
         return bytesToCopy;
     }
 
@@ -1737,7 +1738,8 @@ public:
         {
             throw std::runtime_error("std::string too long for length type [E109]");
         }
-        return putCredentials(str.data(), static_cast<std::uint16_t>(str.length()));    }
+        return putCredentials(str.data(), static_cast<std::uint16_t>(str.length()));
+    }
 
     #if __cplusplus >= 201703L
     Negotiate500 &putCredentials(const std::string_view str)
@@ -1746,7 +1748,8 @@ public:
         {
             throw std::runtime_error("std::string too long for length type [E109]");
         }
-        return putCredentials(str.data(), static_cast<std::uint16_t>(str.length()));    }
+        return putCredentials(str.data(), static_cast<std::uint16_t>(str.length()));
+    }
     #endif
 
 template<typename CharT, typename Traits>
@@ -1808,21 +1811,21 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return false;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength(std::size_t CredentialsLength = 0)
+SBE_NODISCARD static std::size_t computeLength(std::size_t credentialsLength = 0)
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
-
+    std::size_t length = sbeBlockLength();
 
     length += credentialsHeaderLength();
-    if (CredentialsLength > 65534)
+    if (credentialsLength > 65534LL)
     {
-        throw std::runtime_error("CredentialsLength too long for length type [E109]");
+        throw std::runtime_error("credentialsLength too long for length type [E109]");
     }
-    length += CredentialsLength;
+    length += credentialsLength;
+
     return length;
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic pop

src/lib/orderman/actors/ilink3/generated/NegotiationReject502.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(68);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(502);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     NegotiationReject502() = default;
 
     NegotiationReject502(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)68;
+        return static_cast<std::uint16_t>(68);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)502;
+        return static_cast<std::uint16_t>(502);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "NegotiationReject";
     }
@@ -258,7 +260,7 @@ public:
 
     NegotiationReject502 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = NegotiationReject502(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        NegotiationReject502 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        NegotiationReject502 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * ReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -376,17 +377,17 @@ public:
 
     static SBE_CONSTEXPR char reasonNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char reasonMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char reasonMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t reasonEncodingLength() SBE_NOEXCEPT
@@ -440,7 +441,7 @@ public:
             throw std::runtime_error("length too large for getReason [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -453,7 +454,7 @@ public:
     SBE_NODISCARD std::string getReasonAsString() const
     {
         const char *buffer = m_buffer + m_offset + 0;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 48 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -498,7 +499,7 @@ public:
     SBE_NODISCARD std::string_view getReasonAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 0;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 48 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -510,14 +511,14 @@ public:
     #if __cplusplus >= 201703L
     NegotiationReject502 &putReason(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 48)
         {
             throw std::runtime_error("string too large for putReason [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength);
-        for (size_t start = srcLength; start < 48; ++start)
+        for (std::size_t start = srcLength; start < 48; ++start)
         {
             m_buffer[m_offset + 0 + start] = 0;
         }
@@ -527,14 +528,14 @@ public:
     #else
     NegotiationReject502 &putReason(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 48)
         {
             throw std::runtime_error("string too large for putReason [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 48; ++start)
+        for (std::size_t start = srcLength; start < 48; ++start)
         {
             m_buffer[m_offset + 0 + start] = 0;
         }
@@ -543,7 +544,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -587,12 +588,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -614,7 +615,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -658,12 +659,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT
@@ -685,7 +686,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ErrorCodesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ErrorCodesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -729,12 +730,12 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t errorCodesMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t errorCodesMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t errorCodesEncodingLength() SBE_NOEXCEPT
@@ -756,7 +757,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * FaultToleranceIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *FaultToleranceIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -798,7 +799,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD FTI::Value faultToleranceIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t faultToleranceIndicatorRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD FTI::Value faultToleranceIndicator() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t));
@@ -812,7 +820,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -854,7 +862,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD SplitMsg::Value splitMsg() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t));
@@ -918,13 +933,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return true;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+SBE_NODISCARD static std::size_t computeLength()
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
+    std::size_t length = sbeBlockLength();
 
     return length;
 #if defined(__GNUG__) && !defined(__clang__)

src/lib/orderman/actors/ilink3/generated/NegotiationResponse501.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(32);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(501);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     NegotiationResponse501() = default;
 
     NegotiationResponse501(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)32;
+        return static_cast<std::uint16_t>(32);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)501;
+        return static_cast<std::uint16_t>(501);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "NegotiationResponse";
     }
@@ -258,7 +260,7 @@ public:
 
     NegotiationResponse501 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = NegotiationResponse501(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        NegotiationResponse501 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        NegotiationResponse501 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * ServerFlowMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ServerFlowMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -376,17 +377,17 @@ public:
 
     static SBE_CONSTEXPR char serverFlowNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char serverFlowMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char serverFlowMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t serverFlowEncodingLength() SBE_NOEXCEPT
@@ -401,14 +402,14 @@ public:
 
     SBE_NODISCARD const char *serverFlow() const
     {
-        static const std::uint8_t serverFlowValues[] = { 82, 69, 67, 79, 86, 69, 82, 65, 66, 76, 69 };
+        static const std::uint8_t serverFlowValues[] = { 82, 69, 67, 79, 86, 69, 82, 65, 66, 76, 69, 0 };
 
         return (const char *)serverFlowValues;
     }
 
     SBE_NODISCARD char serverFlow(const std::uint64_t index) const
     {
-        static const std::uint8_t serverFlowValues[] = { 82, 69, 67, 79, 86, 69, 82, 65, 66, 76, 69 };
+        static const std::uint8_t serverFlowValues[] = { 82, 69, 67, 79, 86, 69, 82, 65, 66, 76, 69, 0 };
 
         return (char)serverFlowValues[index];
     }
@@ -418,7 +419,7 @@ public:
         static std::uint8_t serverFlowValues[] = { 82, 69, 67, 79, 86, 69, 82, 65, 66, 76, 69 };
         std::uint64_t bytesToCopy = length < sizeof(serverFlowValues) ? length : sizeof(serverFlowValues);
 
-        std::memcpy(dst, serverFlowValues, static_cast<size_t>(bytesToCopy));
+        std::memcpy(dst, serverFlowValues, static_cast<std::size_t>(bytesToCopy));
         return bytesToCopy;
     }
 
@@ -462,7 +463,7 @@ public:
         return oss.str();
     }
 
-    SBE_NODISCARD static const char * UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -506,12 +507,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -533,7 +534,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -577,12 +578,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT
@@ -604,7 +605,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SecretKeySecureIDExpirationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SecretKeySecureIDExpirationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -643,17 +644,17 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t secretKeySecureIDExpirationNullValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65535;
+        return static_cast<std::uint16_t>(65535);
     }
 
     static SBE_CONSTEXPR std::uint16_t secretKeySecureIDExpirationMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t secretKeySecureIDExpirationMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t secretKeySecureIDExpirationEncodingLength() SBE_NOEXCEPT
@@ -675,7 +676,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * FaultToleranceIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *FaultToleranceIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -717,7 +718,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD FTI::Value faultToleranceIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t faultToleranceIndicatorRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD FTI::Value faultToleranceIndicator() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t));
@@ -731,7 +739,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -773,7 +781,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 19, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD SplitMsg::Value splitMsg() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 19, sizeof(std::uint8_t));
@@ -787,7 +802,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * PreviousSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PreviousSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -831,12 +846,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t previousSeqNoMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t previousSeqNoMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t previousSeqNoEncodingLength() SBE_NOEXCEPT
@@ -858,7 +873,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * PreviousUUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PreviousUUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -902,12 +917,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t previousUUIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t previousUUIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t previousUUIDEncodingLength() SBE_NOEXCEPT
@@ -929,7 +944,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * CredentialsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *CredentialsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1009,7 +1024,7 @@ public:
         std::uint64_t bytesToCopy = length < dataLength ? length : dataLength;
         std::uint64_t pos = sbePosition();
         sbePosition(pos + dataLength);
-        std::memcpy(dst, m_buffer + pos, static_cast<size_t>(bytesToCopy));
+        std::memcpy(dst, m_buffer + pos, static_cast<std::size_t>(bytesToCopy));
         return bytesToCopy;
     }
 
@@ -1098,7 +1113,8 @@ public:
         {
             throw std::runtime_error("std::string too long for length type [E109]");
         }
-        return putCredentials(str.data(), static_cast<std::uint16_t>(str.length()));    }
+        return putCredentials(str.data(), static_cast<std::uint16_t>(str.length()));
+    }
 
     #if __cplusplus >= 201703L
     NegotiationResponse501 &putCredentials(const std::string_view str)
@@ -1107,7 +1123,8 @@ public:
         {
             throw std::runtime_error("std::string too long for length type [E109]");
         }
-        return putCredentials(str.data(), static_cast<std::uint16_t>(str.length()));    }
+        return putCredentials(str.data(), static_cast<std::uint16_t>(str.length()));
+    }
     #endif
 
 template<typename CharT, typename Traits>
@@ -1169,21 +1186,21 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return false;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength(std::size_t CredentialsLength = 0)
+SBE_NODISCARD static std::size_t computeLength(std::size_t credentialsLength = 0)
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
-
+    std::size_t length = sbeBlockLength();
 
     length += credentialsHeaderLength();
-    if (CredentialsLength > 65534)
+    if (credentialsLength > 65534LL)
     {
-        throw std::runtime_error("CredentialsLength too long for length type [E109]");
+        throw std::runtime_error("credentialsLength too long for length type [E109]");
     }
-    length += CredentialsLength;
+    length += credentialsLength;
+
     return length;
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic pop

src/lib/orderman/actors/ilink3/generated/NewOrderCross544.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(74);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(544);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     NewOrderCross544() = default;
 
     NewOrderCross544(
@@ -218,32 +220,32 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)74;
+        return static_cast<std::uint16_t>(74);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)544;
+        return static_cast<std::uint16_t>(544);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
-        return "c";
+        return "s";
     }
 
     SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT
@@ -258,7 +260,7 @@ public:
 
     NewOrderCross544 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = NewOrderCross544(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        NewOrderCross544 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        NewOrderCross544 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -381,12 +382,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -452,12 +453,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -521,7 +522,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -535,7 +543,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -579,12 +587,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -606,7 +614,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -645,17 +653,17 @@ public:
 
     static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -709,7 +717,7 @@ public:
             throw std::runtime_error("length too large for getSenderID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -722,7 +730,7 @@ public:
     SBE_NODISCARD std::string getSenderIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -767,7 +775,7 @@ public:
     SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -779,14 +787,14 @@ public:
     #if __cplusplus >= 201703L
     NewOrderCross544 &putSenderID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -796,14 +804,14 @@ public:
     #else
     NewOrderCross544 &putSenderID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -812,7 +820,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -851,17 +859,17 @@ public:
 
     static SBE_CONSTEXPR char ordTypeNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char ordTypeMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char ordTypeMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT
@@ -876,14 +884,14 @@ public:
 
     SBE_NODISCARD const char *ordType() const
     {
-        static const std::uint8_t ordTypeValues[] = { 50 };
+        static const std::uint8_t ordTypeValues[] = { 50, 0 };
 
         return (const char *)ordTypeValues;
     }
 
     SBE_NODISCARD char ordType(const std::uint64_t index) const
     {
-        static const std::uint8_t ordTypeValues[] = { 50 };
+        static const std::uint8_t ordTypeValues[] = { 50, 0 };
 
         return (char)ordTypeValues[index];
     }
@@ -893,7 +901,7 @@ public:
         static std::uint8_t ordTypeValues[] = { 50 };
         std::uint64_t bytesToCopy = length < sizeof(ordTypeValues) ? length : sizeof(ordTypeValues);
 
-        std::memcpy(dst, ordTypeValues, static_cast<size_t>(bytesToCopy));
+        std::memcpy(dst, ordTypeValues, static_cast<std::size_t>(bytesToCopy));
         return bytesToCopy;
     }
 
@@ -937,7 +945,7 @@ public:
         return oss.str();
     }
 
-    SBE_NODISCARD static const char * CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -976,17 +984,17 @@ public:
 
     static SBE_CONSTEXPR char crossTypeNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char crossTypeMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char crossTypeMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT
@@ -1001,14 +1009,14 @@ public:
 
     SBE_NODISCARD const char *crossType() const
     {
-        static const std::uint8_t crossTypeValues[] = { 51 };
+        static const std::uint8_t crossTypeValues[] = { 51, 0 };
 
         return (const char *)crossTypeValues;
     }
 
     SBE_NODISCARD char crossType(const std::uint64_t index) const
     {
-        static const std::uint8_t crossTypeValues[] = { 51 };
+        static const std::uint8_t crossTypeValues[] = { 51, 0 };
 
         return (char)crossTypeValues[index];
     }
@@ -1018,7 +1026,7 @@ public:
         static std::uint8_t crossTypeValues[] = { 51 };
         std::uint64_t bytesToCopy = length < sizeof(crossTypeValues) ? length : sizeof(crossTypeValues);
 
-        std::memcpy(dst, crossTypeValues, static_cast<size_t>(bytesToCopy));
+        std::memcpy(dst, crossTypeValues, static_cast<std::size_t>(bytesToCopy));
         return bytesToCopy;
     }
 
@@ -1062,7 +1070,7 @@ public:
         return oss.str();
     }
 
-    SBE_NODISCARD static const char * CrossPrioritizationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *CrossPrioritizationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1101,17 +1109,17 @@ public:
 
     static SBE_CONSTEXPR char crossPrioritizationNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char crossPrioritizationMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char crossPrioritizationMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t crossPrioritizationEncodingLength() SBE_NOEXCEPT
@@ -1126,14 +1134,14 @@ public:
 
     SBE_NODISCARD const char *crossPrioritization() const
     {
-        static const std::uint8_t crossPrioritizationValues[] = { 48 };
+        static const std::uint8_t crossPrioritizationValues[] = { 48, 0 };
 
         return (const char *)crossPrioritizationValues;
     }
 
     SBE_NODISCARD char crossPrioritization(const std::uint64_t index) const
     {
-        static const std::uint8_t crossPrioritizationValues[] = { 48 };
+        static const std::uint8_t crossPrioritizationValues[] = { 48, 0 };
 
         return (char)crossPrioritizationValues[index];
     }
@@ -1143,7 +1151,7 @@ public:
         static std::uint8_t crossPrioritizationValues[] = { 48 };
         std::uint64_t bytesToCopy = length < sizeof(crossPrioritizationValues) ? length : sizeof(crossPrioritizationValues);
 
-        std::memcpy(dst, crossPrioritizationValues, static_cast<size_t>(bytesToCopy));
+        std::memcpy(dst, crossPrioritizationValues, static_cast<std::size_t>(bytesToCopy));
         return bytesToCopy;
     }
 
@@ -1187,7 +1195,7 @@ public:
         return oss.str();
     }
 
-    SBE_NODISCARD static const char * PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1234,7 +1242,7 @@ public:
         return m_price;
     }
 
-    SBE_NODISCARD static const char * TransBkdTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *TransBkdTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1278,12 +1286,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t transBkdTimeMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t transBkdTimeMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t transBkdTimeEncodingLength() SBE_NOEXCEPT
@@ -1305,7 +1313,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1349,12 +1357,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1376,7 +1384,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1415,17 +1423,17 @@ public:
 
     static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1479,7 +1487,7 @@ public:
             throw std::runtime_error("length too large for getLocation [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 65, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 65, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1492,7 +1500,7 @@ public:
     SBE_NODISCARD std::string getLocationAsString() const
     {
         const char *buffer = m_buffer + m_offset + 65;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1537,7 +1545,7 @@ public:
     SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 65;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1549,14 +1557,14 @@ public:
     #if __cplusplus >= 201703L
     NewOrderCross544 &putLocation(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 65, str.data(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 65 + start] = 0;
         }
@@ -1566,14 +1574,14 @@ public:
     #else
     NewOrderCross544 &putLocation(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 65, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 65 + start] = 0;
         }
@@ -1582,7 +1590,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1626,12 +1634,12 @@ public:
 
     static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
     {
-        return -2147483647;
+        return INT32_C(-2147483647);
     }
 
     static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
     {
-        return 2147483647;
+        return INT32_C(2147483647);
     }
 
     static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -1711,8 +1719,8 @@ public:
             m_buffer = buffer;
             m_bufferLength = bufferLength;
             GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
-            dimensions.blockLength((std::uint16_t)34);
-            dimensions.numInGroup((std::uint8_t)count);
+            dimensions.blockLength(static_cast<std::uint16_t>(34));
+            dimensions.numInGroup(static_cast<std::uint8_t>(count));
             m_index = 0;
             m_count = count;
             m_blockLength = 34;
@@ -1783,7 +1791,7 @@ public:
         {
             m_count = m_index;
             GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion);
-            dimensions.numInGroup((std::uint8_t)m_count);
+            dimensions.numInGroup(static_cast<std::uint8_t>(m_count));
             return m_count;
         }
 
@@ -1809,7 +1817,7 @@ public:
 
     #endif
 
-        SBE_NODISCARD static const char * ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -1848,17 +1856,17 @@ public:
 
         static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT
         {
-            return (char)0;
+            return static_cast<char>(0);
         }
 
         static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT
         {
-            return (char)32;
+            return static_cast<char>(32);
         }
 
         static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT
         {
-            return (char)126;
+            return static_cast<char>(126);
         }
 
         static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT
@@ -1912,7 +1920,7 @@ public:
                 throw std::runtime_error("length too large for getClOrdID [E106]");
             }
 
-            std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast<size_t>(length));
+            std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast<std::size_t>(length));
             return length;
         }
 
@@ -1925,7 +1933,7 @@ public:
         SBE_NODISCARD std::string getClOrdIDAsString() const
         {
             const char *buffer = m_buffer + m_offset + 0;
-            size_t length = 0;
+            std::size_t length = 0;
 
             for (; length < 20 && *(buffer + length) != '\0'; ++length);
             std::string result(buffer, length);
@@ -1970,7 +1978,7 @@ public:
         SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT
         {
             const char *buffer = m_buffer + m_offset + 0;
-            size_t length = 0;
+            std::size_t length = 0;
 
             for (; length < 20 && *(buffer + length) != '\0'; ++length);
             std::string_view result(buffer, length);
@@ -1982,14 +1990,14 @@ public:
         #if __cplusplus >= 201703L
         NoSides &putClOrdID(const std::string_view str)
         {
-            const size_t srcLength = str.length();
+            const std::size_t srcLength = str.length();
             if (srcLength > 20)
             {
                 throw std::runtime_error("string too large for putClOrdID [E106]");
             }
 
             std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength);
-            for (size_t start = srcLength; start < 20; ++start)
+            for (std::size_t start = srcLength; start < 20; ++start)
             {
                 m_buffer[m_offset + 0 + start] = 0;
             }
@@ -1999,14 +2007,14 @@ public:
         #else
         NoSides &putClOrdID(const std::string& str)
         {
-            const size_t srcLength = str.length();
+            const std::size_t srcLength = str.length();
             if (srcLength > 20)
             {
                 throw std::runtime_error("string too large for putClOrdID [E106]");
             }
 
             std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength);
-            for (size_t start = srcLength; start < 20; ++start)
+            for (std::size_t start = srcLength; start < 20; ++start)
             {
                 m_buffer[m_offset + 0 + start] = 0;
             }
@@ -2015,7 +2023,7 @@ public:
         }
         #endif
 
-        SBE_NODISCARD static const char * PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2059,12 +2067,12 @@ public:
 
         static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
         {
-            return 0x0L;
+            return UINT64_C(0x0);
         }
 
         static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
         {
-            return 0xfffffffffffffffeL;
+            return UINT64_C(0xfffffffffffffffe);
         }
 
         static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -2086,7 +2094,7 @@ public:
             return *this;
         }
 
-        SBE_NODISCARD static const char * OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2130,12 +2138,12 @@ public:
 
         static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT
         {
-            return 0;
+            return UINT32_C(0x0);
         }
 
         static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT
         {
-            return 4294967294;
+            return UINT32_C(0xfffffffe);
         }
 
         static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT
@@ -2157,7 +2165,7 @@ public:
             return *this;
         }
 
-        SBE_NODISCARD static const char * SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2199,7 +2207,14 @@ public:
             return 1;
         }
 
-        SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT
+        SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT
+        {
+            std::uint8_t val;
+            std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::uint8_t));
+            return (val);
+        }
+
+        SBE_NODISCARD SideReq::Value side() const
         {
             std::uint8_t val;
             std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::uint8_t));
@@ -2213,7 +2228,7 @@ public:
             return *this;
         }
 
-        SBE_NODISCARD static const char * SideTimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *SideTimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2255,7 +2270,14 @@ public:
             return 1;
         }
 
-        SBE_NODISCARD SideTimeInForce::Value sideTimeInForce() const SBE_NOEXCEPT
+        SBE_NODISCARD std::uint8_t sideTimeInForceRaw() const SBE_NOEXCEPT
+        {
+            std::uint8_t val;
+            std::memcpy(&val, m_buffer + m_offset + 33, sizeof(std::uint8_t));
+            return (val);
+        }
+
+        SBE_NODISCARD SideTimeInForce::Value sideTimeInForce() const
         {
             std::uint8_t val;
             std::memcpy(&val, m_buffer + m_offset + 33, sizeof(std::uint8_t));
@@ -2308,13 +2330,13 @@ public:
             return true;
         }
 
-        SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+        SBE_NODISCARD static std::size_t computeLength()
         {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-            size_t length = sbeBlockLength();
+            std::size_t length = sbeBlockLength();
 
             return length;
 #if defined(__GNUG__) && !defined(__clang__)
@@ -2448,21 +2470,21 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return false;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength(std::size_t NoSidesLength = 0)
+SBE_NODISCARD static std::size_t computeLength(std::size_t noSidesLength = 0)
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
-
+    std::size_t length = sbeBlockLength();
 
     length += NoSides::sbeHeaderSize();
-    if (NoSidesLength > 254)
+    if (noSidesLength > 254LL)
     {
-        throw std::runtime_error("NoSidesLength outside of allowed range [E110]");
+        throw std::runtime_error("noSidesLength outside of allowed range [E110]");
     }
-    length += NoSidesLength * NoSides::sbeBlockLength();
+    length += noSidesLength *NoSides::sbeBlockLength();
+
     return length;
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic pop

src/lib/orderman/actors/ilink3/generated/NewOrderSingle514.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(124);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(514);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     NewOrderSingle514() = default;
 
     NewOrderSingle514(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)116;
+        return static_cast<std::uint16_t>(124);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)514;
+        return static_cast<std::uint16_t>(514);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "D";
     }
@@ -258,7 +260,7 @@ public:
 
     NewOrderSingle514 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = NewOrderSingle514(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        NewOrderSingle514 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        NewOrderSingle514 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -384,7 +385,7 @@ public:
         return m_price;
     }
 
-    SBE_NODISCARD static const char * OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -428,12 +429,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT
@@ -455,7 +456,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -499,12 +500,12 @@ public:
 
     static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
     {
-        return -2147483647;
+        return INT32_C(-2147483647);
     }
 
     static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
     {
-        return 2147483647;
+        return INT32_C(2147483647);
     }
 
     static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -526,7 +527,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -568,7 +569,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD SideReq::Value side() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -582,7 +590,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -626,12 +634,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -653,7 +661,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -692,17 +700,17 @@ public:
 
     static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -756,7 +764,7 @@ public:
             throw std::runtime_error("length too large for getSenderID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -769,7 +777,7 @@ public:
     SBE_NODISCARD std::string getSenderIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -814,7 +822,7 @@ public:
     SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -826,14 +834,14 @@ public:
     #if __cplusplus >= 201703L
     NewOrderSingle514 &putSenderID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -843,14 +851,14 @@ public:
     #else
     NewOrderSingle514 &putSenderID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -859,7 +867,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -898,17 +906,17 @@ public:
 
     static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT
@@ -962,7 +970,7 @@ public:
             throw std::runtime_error("length too large for getClOrdID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 41, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 41, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -975,7 +983,7 @@ public:
     SBE_NODISCARD std::string getClOrdIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 41;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1020,7 +1028,7 @@ public:
     SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 41;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1032,14 +1040,14 @@ public:
     #if __cplusplus >= 201703L
     NewOrderSingle514 &putClOrdID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putClOrdID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 41, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 41 + start] = 0;
         }
@@ -1049,14 +1057,14 @@ public:
     #else
     NewOrderSingle514 &putClOrdID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putClOrdID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 41, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 41 + start] = 0;
         }
@@ -1065,7 +1073,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1109,12 +1117,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -1136,7 +1144,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1180,12 +1188,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT
@@ -1207,7 +1215,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1251,12 +1259,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1278,7 +1286,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1325,7 +1333,7 @@ public:
         return m_stopPx;
     }
 
-    SBE_NODISCARD static const char * LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1364,17 +1372,17 @@ public:
 
     static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1428,7 +1436,7 @@ public:
             throw std::runtime_error("length too large for getLocation [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 93, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 93, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1441,7 +1449,7 @@ public:
     SBE_NODISCARD std::string getLocationAsString() const
     {
         const char *buffer = m_buffer + m_offset + 93;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1486,7 +1494,7 @@ public:
     SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 93;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1498,14 +1506,14 @@ public:
     #if __cplusplus >= 201703L
     NewOrderSingle514 &putLocation(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 93, str.data(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 93 + start] = 0;
         }
@@ -1515,14 +1523,14 @@ public:
     #else
     NewOrderSingle514 &putLocation(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 93, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 93 + start] = 0;
         }
@@ -1531,7 +1539,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1570,17 +1578,17 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT
     {
-        return 4294967295;
+        return UINT32_C(0xffffffff);
     }
 
     static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT
@@ -1602,7 +1610,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1641,17 +1649,17 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT
     {
-        return 4294967295;
+        return UINT32_C(0xffffffff);
     }
 
     static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT
@@ -1673,7 +1681,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1712,17 +1720,17 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65535;
+        return static_cast<std::uint16_t>(65535);
     }
 
     static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT
@@ -1744,7 +1752,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1786,7 +1794,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD OrderTypeReq::Value ordType() const SBE_NOEXCEPT
+    SBE_NODISCARD char ordTypeRaw() const SBE_NOEXCEPT
+    {
+        char val;
+        std::memcpy(&val, m_buffer + m_offset + 108, sizeof(char));
+        return (val);
+    }
+
+    SBE_NODISCARD OrderTypeReq::Value ordType() const
     {
         char val;
         std::memcpy(&val, m_buffer + m_offset + 108, sizeof(char));
@@ -1800,7 +1815,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1842,7 +1857,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD TimeInForce::Value timeInForce() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t timeInForceRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 109, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD TimeInForce::Value timeInForce() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 109, sizeof(std::uint8_t));
@@ -1856,7 +1878,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1898,7 +1920,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 110, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 110, sizeof(std::uint8_t));
@@ -1912,7 +1941,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1964,7 +1993,7 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD static const char * ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2006,7 +2035,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ExecMode::Value executionMode() const SBE_NOEXCEPT
+    SBE_NODISCARD char executionModeRaw() const SBE_NOEXCEPT
+    {
+        char val;
+        std::memcpy(&val, m_buffer + m_offset + 112, sizeof(char));
+        return (val);
+    }
+
+    SBE_NODISCARD ExecMode::Value executionMode() const
     {
         char val;
         std::memcpy(&val, m_buffer + m_offset + 112, sizeof(char));
@@ -2020,7 +2056,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2062,7 +2098,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 113, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD BooleanNULL::Value liquidityFlag() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 113, sizeof(std::uint8_t));
@@ -2076,7 +2119,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2118,7 +2161,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD BooleanNULL::Value managedOrder() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t managedOrderRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 114, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD BooleanNULL::Value managedOrder() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 114, sizeof(std::uint8_t));
@@ -2132,7 +2182,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2174,7 +2224,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ShortSaleType::Value shortSaleType() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t shortSaleTypeRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 115, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ShortSaleType::Value shortSaleType() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 115, sizeof(std::uint8_t));
@@ -2188,6 +2245,53 @@ public:
         return *this;
     }
 
+    SBE_NODISCARD static const char *DiscretionPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    {
+        switch (metaAttribute)
+        {
+            case MetaAttribute::SEMANTIC_TYPE: return "Price";
+            case MetaAttribute::PRESENCE: return "required";
+            default: return "";
+        }
+    }
+
+    static SBE_CONSTEXPR std::uint16_t discretionPriceId() SBE_NOEXCEPT
+    {
+        return 845;
+    }
+
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t discretionPriceSinceVersion() SBE_NOEXCEPT
+    {
+        return 6;
+    }
+
+    SBE_NODISCARD bool discretionPriceInActingVersion() SBE_NOEXCEPT
+    {
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
+        return m_actingVersion >= discretionPriceSinceVersion();
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+    }
+
+    SBE_NODISCARD static SBE_CONSTEXPR std::size_t discretionPriceEncodingOffset() SBE_NOEXCEPT
+    {
+        return 116;
+    }
+
+private:
+    PRICENULL9 m_discretionPrice;
+
+public:
+    SBE_NODISCARD PRICENULL9 &discretionPrice()
+    {
+        m_discretionPrice.wrap(m_buffer, m_offset + 116, m_actingVersion, m_bufferLength);
+        return m_discretionPrice;
+    }
+
 template<typename CharT, typename Traits>
 friend std::basic_ostream<CharT, Traits>& operator << (
     std::basic_ostream<CharT, Traits>& builder, NewOrderSingle514 _writer)
@@ -2294,6 +2398,10 @@ friend std::basic_ostream<CharT, Traits>& operator << (
     builder << R"("ShortSaleType": )";
     builder << '"' << writer.shortSaleType() << '"';
 
+    builder << ", ";
+    builder << R"("DiscretionPrice": )";
+    builder << writer.discretionPrice();
+
     builder << '}';
 
     return builder;
@@ -2308,13 +2416,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return true;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+SBE_NODISCARD static std::size_t computeLength()
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
+    std::size_t length = sbeBlockLength();
 
     return length;
 #if defined(__GNUG__) && !defined(__clang__)

src/lib/orderman/actors/ilink3/generated/NotApplied513.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(17);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(513);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     NotApplied513() = default;
 
     NotApplied513(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)17;
+        return static_cast<std::uint16_t>(17);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)513;
+        return static_cast<std::uint16_t>(513);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "NotApplied";
     }
@@ -258,7 +260,7 @@ public:
 
     NotApplied513 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = NotApplied513(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        NotApplied513 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        NotApplied513 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -381,12 +382,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * FromSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *FromSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -452,12 +453,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t fromSeqNoMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t fromSeqNoMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t fromSeqNoEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * MsgCountMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *MsgCountMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -523,12 +524,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t msgCountMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t msgCountMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t msgCountEncodingLength() SBE_NOEXCEPT
@@ -550,7 +551,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -592,7 +593,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD SplitMsg::Value splitMsg() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -647,13 +655,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return true;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+SBE_NODISCARD static std::size_t computeLength()
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
+    std::size_t length = sbeBlockLength();
 
     return length;
 #if defined(__GNUG__) && !defined(__clang__)

src/lib/orderman/actors/ilink3/generated/OFMOverrideReq.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class OFMOverrideReq
 public:
     enum Value
     {
-        Disabled = (std::uint8_t)0,
-        Enabled = (std::uint8_t)1,
-        NULL_VALUE = (std::uint8_t)255
+        Disabled = static_cast<std::uint8_t>(0),
+        Enabled = static_cast<std::uint8_t>(1),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static OFMOverrideReq::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 0: return Disabled;
-            case 1: return Enabled;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(0): return Disabled;
+            case static_cast<std::uint8_t>(1): return Enabled;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum OFMOverrideReq [E103]");
     }
 
-    static const char* c_str(const OFMOverrideReq::Value value)
+    static const char *c_str(const OFMOverrideReq::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/OrdStatusTrd.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class OrdStatusTrd
 public:
     enum Value
     {
-        PartiallyFilled = (std::uint8_t)1,
-        Filled = (std::uint8_t)2,
-        NULL_VALUE = (std::uint8_t)255
+        PartiallyFilled = static_cast<std::uint8_t>(1),
+        Filled = static_cast<std::uint8_t>(2),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static OrdStatusTrd::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 1: return PartiallyFilled;
-            case 2: return Filled;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(1): return PartiallyFilled;
+            case static_cast<std::uint8_t>(2): return Filled;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum OrdStatusTrd [E103]");
     }
 
-    static const char* c_str(const OrdStatusTrd::Value value)
+    static const char *c_str(const OrdStatusTrd::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/OrdStatusTrdCxl.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class OrdStatusTrdCxl
 public:
     enum Value
     {
-        TradeCorrection = (char)71,
-        TradeCancel = (char)72,
-        NULL_VALUE = (char)0
+        TradeCorrection = static_cast<char>(71),
+        TradeCancel = static_cast<char>(72),
+        NULL_VALUE = static_cast<char>(0)
     };
 
     static OrdStatusTrdCxl::Value get(const char value)
     {
         switch (value)
         {
-            case 71: return TradeCorrection;
-            case 72: return TradeCancel;
-            case 0: return NULL_VALUE;
+            case static_cast<char>(71): return TradeCorrection;
+            case static_cast<char>(72): return TradeCancel;
+            case static_cast<char>(0): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum OrdStatusTrdCxl [E103]");
     }
 
-    static const char* c_str(const OrdStatusTrdCxl::Value value)
+    static const char *c_str(const OrdStatusTrdCxl::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/OrderCancelReject535.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(409);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(535);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     OrderCancelReject535() = default;
 
     OrderCancelReject535(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)409;
+        return static_cast<std::uint16_t>(409);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)535;
+        return static_cast<std::uint16_t>(535);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "9";
     }
@@ -258,7 +260,7 @@ public:
 
     OrderCancelReject535 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = OrderCancelReject535(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        OrderCancelReject535 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        OrderCancelReject535 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -381,12 +382,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -452,12 +453,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -518,17 +519,17 @@ public:
 
     static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT
@@ -582,7 +583,7 @@ public:
             throw std::runtime_error("length too large for getText [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -595,7 +596,7 @@ public:
     SBE_NODISCARD std::string getTextAsString() const
     {
         const char *buffer = m_buffer + m_offset + 12;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 256 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -640,7 +641,7 @@ public:
     SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 12;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 256 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -652,14 +653,14 @@ public:
     #if __cplusplus >= 201703L
     OrderCancelReject535 &putText(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 256)
         {
             throw std::runtime_error("string too large for putText [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength);
-        for (size_t start = srcLength; start < 256; ++start)
+        for (std::size_t start = srcLength; start < 256; ++start)
         {
             m_buffer[m_offset + 12 + start] = 0;
         }
@@ -669,14 +670,14 @@ public:
     #else
     OrderCancelReject535 &putText(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 256)
         {
             throw std::runtime_error("string too large for putText [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 256; ++start)
+        for (std::size_t start = srcLength; start < 256; ++start)
         {
             m_buffer[m_offset + 12 + start] = 0;
         }
@@ -685,7 +686,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -724,17 +725,17 @@ public:
 
     static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT
@@ -788,7 +789,7 @@ public:
             throw std::runtime_error("length too large for getExecID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 268, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 268, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -801,7 +802,7 @@ public:
     SBE_NODISCARD std::string getExecIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 268;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 40 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -846,7 +847,7 @@ public:
     SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 268;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 40 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -858,14 +859,14 @@ public:
     #if __cplusplus >= 201703L
     OrderCancelReject535 &putExecID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 40)
         {
             throw std::runtime_error("string too large for putExecID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength);
-        for (size_t start = srcLength; start < 40; ++start)
+        for (std::size_t start = srcLength; start < 40; ++start)
         {
             m_buffer[m_offset + 268 + start] = 0;
         }
@@ -875,14 +876,14 @@ public:
     #else
     OrderCancelReject535 &putExecID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 40)
         {
             throw std::runtime_error("string too large for putExecID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 40; ++start)
+        for (std::size_t start = srcLength; start < 40; ++start)
         {
             m_buffer[m_offset + 268 + start] = 0;
         }
@@ -891,7 +892,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -930,17 +931,17 @@ public:
 
     static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -994,7 +995,7 @@ public:
             throw std::runtime_error("length too large for getSenderID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 308, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 308, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1007,7 +1008,7 @@ public:
     SBE_NODISCARD std::string getSenderIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 308;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1052,7 +1053,7 @@ public:
     SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 308;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1064,14 +1065,14 @@ public:
     #if __cplusplus >= 201703L
     OrderCancelReject535 &putSenderID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 308, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 308 + start] = 0;
         }
@@ -1081,14 +1082,14 @@ public:
     #else
     OrderCancelReject535 &putSenderID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 308, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 308 + start] = 0;
         }
@@ -1097,7 +1098,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1136,17 +1137,17 @@ public:
 
     static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT
@@ -1200,7 +1201,7 @@ public:
             throw std::runtime_error("length too large for getClOrdID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 328, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 328, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1213,7 +1214,7 @@ public:
     SBE_NODISCARD std::string getClOrdIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 328;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1258,7 +1259,7 @@ public:
     SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 328;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1270,14 +1271,14 @@ public:
     #if __cplusplus >= 201703L
     OrderCancelReject535 &putClOrdID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putClOrdID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 328, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 328 + start] = 0;
         }
@@ -1287,14 +1288,14 @@ public:
     #else
     OrderCancelReject535 &putClOrdID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putClOrdID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 328, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 328 + start] = 0;
         }
@@ -1303,7 +1304,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1347,12 +1348,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -1374,7 +1375,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1413,17 +1414,17 @@ public:
 
     static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT
@@ -1438,14 +1439,14 @@ public:
 
     SBE_NODISCARD const char *ordStatus() const
     {
-        static const std::uint8_t ordStatusValues[] = { 85 };
+        static const std::uint8_t ordStatusValues[] = { 85, 0 };
 
         return (const char *)ordStatusValues;
     }
 
     SBE_NODISCARD char ordStatus(const std::uint64_t index) const
     {
-        static const std::uint8_t ordStatusValues[] = { 85 };
+        static const std::uint8_t ordStatusValues[] = { 85, 0 };
 
         return (char)ordStatusValues[index];
     }
@@ -1455,7 +1456,7 @@ public:
         static std::uint8_t ordStatusValues[] = { 85 };
         std::uint64_t bytesToCopy = length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues);
 
-        std::memcpy(dst, ordStatusValues, static_cast<size_t>(bytesToCopy));
+        std::memcpy(dst, ordStatusValues, static_cast<std::size_t>(bytesToCopy));
         return bytesToCopy;
     }
 
@@ -1499,7 +1500,7 @@ public:
         return oss.str();
     }
 
-    SBE_NODISCARD static const char * CxlRejResponseToMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *CxlRejResponseToMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1538,17 +1539,17 @@ public:
 
     static SBE_CONSTEXPR char cxlRejResponseToNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char cxlRejResponseToMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char cxlRejResponseToMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t cxlRejResponseToEncodingLength() SBE_NOEXCEPT
@@ -1563,14 +1564,14 @@ public:
 
     SBE_NODISCARD const char *cxlRejResponseTo() const
     {
-        static const std::uint8_t cxlRejResponseToValues[] = { 49 };
+        static const std::uint8_t cxlRejResponseToValues[] = { 49, 0 };
 
         return (const char *)cxlRejResponseToValues;
     }
 
     SBE_NODISCARD char cxlRejResponseTo(const std::uint64_t index) const
     {
-        static const std::uint8_t cxlRejResponseToValues[] = { 49 };
+        static const std::uint8_t cxlRejResponseToValues[] = { 49, 0 };
 
         return (char)cxlRejResponseToValues[index];
     }
@@ -1580,7 +1581,7 @@ public:
         static std::uint8_t cxlRejResponseToValues[] = { 49 };
         std::uint64_t bytesToCopy = length < sizeof(cxlRejResponseToValues) ? length : sizeof(cxlRejResponseToValues);
 
-        std::memcpy(dst, cxlRejResponseToValues, static_cast<size_t>(bytesToCopy));
+        std::memcpy(dst, cxlRejResponseToValues, static_cast<std::size_t>(bytesToCopy));
         return bytesToCopy;
     }
 
@@ -1624,7 +1625,7 @@ public:
         return oss.str();
     }
 
-    SBE_NODISCARD static const char * OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1668,12 +1669,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT
@@ -1695,7 +1696,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1739,12 +1740,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT
@@ -1766,7 +1767,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1810,12 +1811,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1837,7 +1838,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1881,12 +1882,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT
@@ -1908,7 +1909,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1947,17 +1948,17 @@ public:
 
     static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -2011,7 +2012,7 @@ public:
             throw std::runtime_error("length too large for getLocation [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 388, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 388, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -2024,7 +2025,7 @@ public:
     SBE_NODISCARD std::string getLocationAsString() const
     {
         const char *buffer = m_buffer + m_offset + 388;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -2069,7 +2070,7 @@ public:
     SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 388;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -2081,14 +2082,14 @@ public:
     #if __cplusplus >= 201703L
     OrderCancelReject535 &putLocation(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 388, str.data(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 388 + start] = 0;
         }
@@ -2098,14 +2099,14 @@ public:
     #else
     OrderCancelReject535 &putLocation(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 388, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 388 + start] = 0;
         }
@@ -2114,7 +2115,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * CxlRejReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *CxlRejReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2158,12 +2159,12 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t cxlRejReasonMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t cxlRejReasonMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t cxlRejReasonEncodingLength() SBE_NOEXCEPT
@@ -2185,7 +2186,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2224,17 +2225,17 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65535;
+        return static_cast<std::uint16_t>(65535);
     }
 
     static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT
@@ -2256,7 +2257,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2298,7 +2299,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 397, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 397, sizeof(std::uint8_t));
@@ -2312,7 +2320,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2354,7 +2362,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 398, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD BooleanFlag::Value possRetransFlag() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 398, sizeof(std::uint8_t));
@@ -2368,7 +2383,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2410,7 +2425,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 399, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD SplitMsg::Value splitMsg() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 399, sizeof(std::uint8_t));
@@ -2424,7 +2446,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2466,7 +2488,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 400, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD BooleanNULL::Value liquidityFlag() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 400, sizeof(std::uint8_t));
@@ -2480,7 +2509,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2519,17 +2548,17 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT
     {
-        return 0xffffffffffffffffL;
+        return UINT64_C(0xffffffffffffffff);
     }
 
     static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT
@@ -2541,7 +2570,7 @@ public:
     {
         if (m_actingVersion < 4)
         {
-            return 0xffffffffffffffffL;
+            return UINT64_C(0xffffffffffffffff);
         }
 
         std::uint64_t val;
@@ -2662,13 +2691,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return true;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+SBE_NODISCARD static std::size_t computeLength()
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
+    std::size_t length = sbeBlockLength();
 
     return length;
 #if defined(__GNUG__) && !defined(__clang__)

src/lib/orderman/actors/ilink3/generated/OrderCancelReplaceReject536.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(409);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(536);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     OrderCancelReplaceReject536() = default;
 
     OrderCancelReplaceReject536(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)409;
+        return static_cast<std::uint16_t>(409);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)536;
+        return static_cast<std::uint16_t>(536);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "9";
     }
@@ -258,7 +260,7 @@ public:
 
     OrderCancelReplaceReject536 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = OrderCancelReplaceReject536(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        OrderCancelReplaceReject536 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        OrderCancelReplaceReject536 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -381,12 +382,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -452,12 +453,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -518,17 +519,17 @@ public:
 
     static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT
@@ -582,7 +583,7 @@ public:
             throw std::runtime_error("length too large for getText [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -595,7 +596,7 @@ public:
     SBE_NODISCARD std::string getTextAsString() const
     {
         const char *buffer = m_buffer + m_offset + 12;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 256 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -640,7 +641,7 @@ public:
     SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 12;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 256 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -652,14 +653,14 @@ public:
     #if __cplusplus >= 201703L
     OrderCancelReplaceReject536 &putText(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 256)
         {
             throw std::runtime_error("string too large for putText [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength);
-        for (size_t start = srcLength; start < 256; ++start)
+        for (std::size_t start = srcLength; start < 256; ++start)
         {
             m_buffer[m_offset + 12 + start] = 0;
         }
@@ -669,14 +670,14 @@ public:
     #else
     OrderCancelReplaceReject536 &putText(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 256)
         {
             throw std::runtime_error("string too large for putText [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 256; ++start)
+        for (std::size_t start = srcLength; start < 256; ++start)
         {
             m_buffer[m_offset + 12 + start] = 0;
         }
@@ -685,7 +686,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -724,17 +725,17 @@ public:
 
     static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT
@@ -788,7 +789,7 @@ public:
             throw std::runtime_error("length too large for getExecID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 268, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 268, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -801,7 +802,7 @@ public:
     SBE_NODISCARD std::string getExecIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 268;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 40 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -846,7 +847,7 @@ public:
     SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 268;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 40 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -858,14 +859,14 @@ public:
     #if __cplusplus >= 201703L
     OrderCancelReplaceReject536 &putExecID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 40)
         {
             throw std::runtime_error("string too large for putExecID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength);
-        for (size_t start = srcLength; start < 40; ++start)
+        for (std::size_t start = srcLength; start < 40; ++start)
         {
             m_buffer[m_offset + 268 + start] = 0;
         }
@@ -875,14 +876,14 @@ public:
     #else
     OrderCancelReplaceReject536 &putExecID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 40)
         {
             throw std::runtime_error("string too large for putExecID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 40; ++start)
+        for (std::size_t start = srcLength; start < 40; ++start)
         {
             m_buffer[m_offset + 268 + start] = 0;
         }
@@ -891,7 +892,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -930,17 +931,17 @@ public:
 
     static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -994,7 +995,7 @@ public:
             throw std::runtime_error("length too large for getSenderID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 308, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 308, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1007,7 +1008,7 @@ public:
     SBE_NODISCARD std::string getSenderIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 308;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1052,7 +1053,7 @@ public:
     SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 308;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1064,14 +1065,14 @@ public:
     #if __cplusplus >= 201703L
     OrderCancelReplaceReject536 &putSenderID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 308, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 308 + start] = 0;
         }
@@ -1081,14 +1082,14 @@ public:
     #else
     OrderCancelReplaceReject536 &putSenderID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 308, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 308 + start] = 0;
         }
@@ -1097,7 +1098,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1136,17 +1137,17 @@ public:
 
     static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT
@@ -1200,7 +1201,7 @@ public:
             throw std::runtime_error("length too large for getClOrdID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 328, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 328, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1213,7 +1214,7 @@ public:
     SBE_NODISCARD std::string getClOrdIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 328;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1258,7 +1259,7 @@ public:
     SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 328;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1270,14 +1271,14 @@ public:
     #if __cplusplus >= 201703L
     OrderCancelReplaceReject536 &putClOrdID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putClOrdID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 328, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 328 + start] = 0;
         }
@@ -1287,14 +1288,14 @@ public:
     #else
     OrderCancelReplaceReject536 &putClOrdID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putClOrdID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 328, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 328 + start] = 0;
         }
@@ -1303,7 +1304,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1347,12 +1348,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -1374,7 +1375,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1418,12 +1419,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT
@@ -1445,7 +1446,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1489,12 +1490,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT
@@ -1516,7 +1517,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1560,12 +1561,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1587,7 +1588,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1631,12 +1632,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT
@@ -1658,7 +1659,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1697,17 +1698,17 @@ public:
 
     static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1761,7 +1762,7 @@ public:
             throw std::runtime_error("length too large for getLocation [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 388, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 388, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1774,7 +1775,7 @@ public:
     SBE_NODISCARD std::string getLocationAsString() const
     {
         const char *buffer = m_buffer + m_offset + 388;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1819,7 +1820,7 @@ public:
     SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 388;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1831,14 +1832,14 @@ public:
     #if __cplusplus >= 201703L
     OrderCancelReplaceReject536 &putLocation(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 388, str.data(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 388 + start] = 0;
         }
@@ -1848,14 +1849,14 @@ public:
     #else
     OrderCancelReplaceReject536 &putLocation(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 388, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 388 + start] = 0;
         }
@@ -1864,7 +1865,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * CxlRejReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *CxlRejReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1908,12 +1909,12 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t cxlRejReasonMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t cxlRejReasonMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t cxlRejReasonEncodingLength() SBE_NOEXCEPT
@@ -1935,7 +1936,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1974,17 +1975,17 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65535;
+        return static_cast<std::uint16_t>(65535);
     }
 
     static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT
@@ -2006,7 +2007,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2045,17 +2046,17 @@ public:
 
     static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT
@@ -2070,14 +2071,14 @@ public:
 
     SBE_NODISCARD const char *ordStatus() const
     {
-        static const std::uint8_t ordStatusValues[] = { 85 };
+        static const std::uint8_t ordStatusValues[] = { 85, 0 };
 
         return (const char *)ordStatusValues;
     }
 
     SBE_NODISCARD char ordStatus(const std::uint64_t index) const
     {
-        static const std::uint8_t ordStatusValues[] = { 85 };
+        static const std::uint8_t ordStatusValues[] = { 85, 0 };
 
         return (char)ordStatusValues[index];
     }
@@ -2087,7 +2088,7 @@ public:
         static std::uint8_t ordStatusValues[] = { 85 };
         std::uint64_t bytesToCopy = length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues);
 
-        std::memcpy(dst, ordStatusValues, static_cast<size_t>(bytesToCopy));
+        std::memcpy(dst, ordStatusValues, static_cast<std::size_t>(bytesToCopy));
         return bytesToCopy;
     }
 
@@ -2131,7 +2132,7 @@ public:
         return oss.str();
     }
 
-    SBE_NODISCARD static const char * CxlRejResponseToMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *CxlRejResponseToMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2170,17 +2171,17 @@ public:
 
     static SBE_CONSTEXPR char cxlRejResponseToNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char cxlRejResponseToMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char cxlRejResponseToMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t cxlRejResponseToEncodingLength() SBE_NOEXCEPT
@@ -2195,14 +2196,14 @@ public:
 
     SBE_NODISCARD const char *cxlRejResponseTo() const
     {
-        static const std::uint8_t cxlRejResponseToValues[] = { 50 };
+        static const std::uint8_t cxlRejResponseToValues[] = { 50, 0 };
 
         return (const char *)cxlRejResponseToValues;
     }
 
     SBE_NODISCARD char cxlRejResponseTo(const std::uint64_t index) const
     {
-        static const std::uint8_t cxlRejResponseToValues[] = { 50 };
+        static const std::uint8_t cxlRejResponseToValues[] = { 50, 0 };
 
         return (char)cxlRejResponseToValues[index];
     }
@@ -2212,7 +2213,7 @@ public:
         static std::uint8_t cxlRejResponseToValues[] = { 50 };
         std::uint64_t bytesToCopy = length < sizeof(cxlRejResponseToValues) ? length : sizeof(cxlRejResponseToValues);
 
-        std::memcpy(dst, cxlRejResponseToValues, static_cast<size_t>(bytesToCopy));
+        std::memcpy(dst, cxlRejResponseToValues, static_cast<std::size_t>(bytesToCopy));
         return bytesToCopy;
     }
 
@@ -2256,7 +2257,7 @@ public:
         return oss.str();
     }
 
-    SBE_NODISCARD static const char * ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2298,7 +2299,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 397, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 397, sizeof(std::uint8_t));
@@ -2312,7 +2320,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2354,7 +2362,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 398, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD BooleanFlag::Value possRetransFlag() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 398, sizeof(std::uint8_t));
@@ -2368,7 +2383,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2410,7 +2425,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 399, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD SplitMsg::Value splitMsg() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 399, sizeof(std::uint8_t));
@@ -2424,7 +2446,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2466,7 +2488,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 400, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD BooleanNULL::Value liquidityFlag() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 400, sizeof(std::uint8_t));
@@ -2480,7 +2509,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2519,17 +2548,17 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT
     {
-        return 0xffffffffffffffffL;
+        return UINT64_C(0xffffffffffffffff);
     }
 
     static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT
@@ -2541,7 +2570,7 @@ public:
     {
         if (m_actingVersion < 4)
         {
-            return 0xffffffffffffffffL;
+            return UINT64_C(0xffffffffffffffff);
         }
 
         std::uint64_t val;
@@ -2662,13 +2691,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return true;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+SBE_NODISCARD static std::size_t computeLength()
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
+    std::size_t length = sbeBlockLength();
 
     return length;
 #if defined(__GNUG__) && !defined(__clang__)

src/lib/orderman/actors/ilink3/generated/OrderCancelReplaceRequest515.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(133);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(515);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     OrderCancelReplaceRequest515() = default;
 
     OrderCancelReplaceRequest515(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)125;
+        return static_cast<std::uint16_t>(133);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)515;
+        return static_cast<std::uint16_t>(515);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "G";
     }
@@ -258,7 +260,7 @@ public:
 
     OrderCancelReplaceRequest515 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = OrderCancelReplaceRequest515(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        OrderCancelReplaceRequest515 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        OrderCancelReplaceRequest515 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -384,7 +385,7 @@ public:
         return m_price;
     }
 
-    SBE_NODISCARD static const char * OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -428,12 +429,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT
@@ -455,7 +456,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -499,12 +500,12 @@ public:
 
     static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
     {
-        return -2147483647;
+        return INT32_C(-2147483647);
     }
 
     static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
     {
-        return 2147483647;
+        return INT32_C(2147483647);
     }
 
     static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -526,7 +527,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -568,7 +569,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD SideReq::Value side() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -582,7 +590,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -626,12 +634,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -653,7 +661,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -692,17 +700,17 @@ public:
 
     static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -756,7 +764,7 @@ public:
             throw std::runtime_error("length too large for getSenderID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -769,7 +777,7 @@ public:
     SBE_NODISCARD std::string getSenderIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -814,7 +822,7 @@ public:
     SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -826,14 +834,14 @@ public:
     #if __cplusplus >= 201703L
     OrderCancelReplaceRequest515 &putSenderID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -843,14 +851,14 @@ public:
     #else
     OrderCancelReplaceRequest515 &putSenderID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -859,7 +867,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -898,17 +906,17 @@ public:
 
     static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT
@@ -962,7 +970,7 @@ public:
             throw std::runtime_error("length too large for getClOrdID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 41, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 41, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -975,7 +983,7 @@ public:
     SBE_NODISCARD std::string getClOrdIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 41;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1020,7 +1028,7 @@ public:
     SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 41;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1032,14 +1040,14 @@ public:
     #if __cplusplus >= 201703L
     OrderCancelReplaceRequest515 &putClOrdID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putClOrdID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 41, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 41 + start] = 0;
         }
@@ -1049,14 +1057,14 @@ public:
     #else
     OrderCancelReplaceRequest515 &putClOrdID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putClOrdID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 41, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 41 + start] = 0;
         }
@@ -1065,7 +1073,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1109,12 +1117,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -1136,12 +1144,12 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
             case MetaAttribute::SEMANTIC_TYPE: return "int";
-            case MetaAttribute::PRESENCE: return "required";
+            case MetaAttribute::PRESENCE: return "optional";
             default: return "";
         }
     }
@@ -1175,17 +1183,17 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT
     {
-        return SBE_NULLVALUE_UINT64;
+        return UINT64_C(0xffffffffffffffff);
     }
 
     static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT
@@ -1207,7 +1215,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1254,7 +1262,7 @@ public:
         return m_stopPx;
     }
 
-    SBE_NODISCARD static const char * OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1298,12 +1306,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT
@@ -1325,7 +1333,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1369,12 +1377,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1396,7 +1404,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1435,17 +1443,17 @@ public:
 
     static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1499,7 +1507,7 @@ public:
             throw std::runtime_error("length too large for getLocation [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 101, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 101, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1512,7 +1520,7 @@ public:
     SBE_NODISCARD std::string getLocationAsString() const
     {
         const char *buffer = m_buffer + m_offset + 101;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1557,7 +1565,7 @@ public:
     SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 101;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1569,14 +1577,14 @@ public:
     #if __cplusplus >= 201703L
     OrderCancelReplaceRequest515 &putLocation(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 101, str.data(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 101 + start] = 0;
         }
@@ -1586,14 +1594,14 @@ public:
     #else
     OrderCancelReplaceRequest515 &putLocation(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 101, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 101 + start] = 0;
         }
@@ -1602,7 +1610,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1641,17 +1649,17 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT
     {
-        return 4294967295;
+        return UINT32_C(0xffffffff);
     }
 
     static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT
@@ -1673,7 +1681,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1712,17 +1720,17 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT
     {
-        return 4294967295;
+        return UINT32_C(0xffffffff);
     }
 
     static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT
@@ -1744,7 +1752,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1783,17 +1791,17 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65535;
+        return static_cast<std::uint16_t>(65535);
     }
 
     static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT
@@ -1815,7 +1823,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1857,7 +1865,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD OrderTypeReq::Value ordType() const SBE_NOEXCEPT
+    SBE_NODISCARD char ordTypeRaw() const SBE_NOEXCEPT
+    {
+        char val;
+        std::memcpy(&val, m_buffer + m_offset + 116, sizeof(char));
+        return (val);
+    }
+
+    SBE_NODISCARD OrderTypeReq::Value ordType() const
     {
         char val;
         std::memcpy(&val, m_buffer + m_offset + 116, sizeof(char));
@@ -1871,7 +1886,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1913,7 +1928,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD TimeInForce::Value timeInForce() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t timeInForceRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 117, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD TimeInForce::Value timeInForce() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 117, sizeof(std::uint8_t));
@@ -1927,7 +1949,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1969,7 +1991,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 118, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 118, sizeof(std::uint8_t));
@@ -1983,7 +2012,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * OFMOverrideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OFMOverrideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2025,7 +2054,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD OFMOverrideReq::Value oFMOverride() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t oFMOverrideRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 119, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD OFMOverrideReq::Value oFMOverride() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 119, sizeof(std::uint8_t));
@@ -2039,7 +2075,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2091,7 +2127,7 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD static const char * ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2133,7 +2169,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ExecMode::Value executionMode() const SBE_NOEXCEPT
+    SBE_NODISCARD char executionModeRaw() const SBE_NOEXCEPT
+    {
+        char val;
+        std::memcpy(&val, m_buffer + m_offset + 121, sizeof(char));
+        return (val);
+    }
+
+    SBE_NODISCARD ExecMode::Value executionMode() const
     {
         char val;
         std::memcpy(&val, m_buffer + m_offset + 121, sizeof(char));
@@ -2147,7 +2190,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2189,7 +2232,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 122, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD BooleanNULL::Value liquidityFlag() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 122, sizeof(std::uint8_t));
@@ -2203,7 +2253,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2245,7 +2295,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD BooleanNULL::Value managedOrder() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t managedOrderRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 123, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD BooleanNULL::Value managedOrder() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 123, sizeof(std::uint8_t));
@@ -2259,7 +2316,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -2301,7 +2358,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ShortSaleType::Value shortSaleType() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t shortSaleTypeRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ShortSaleType::Value shortSaleType() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint8_t));
@@ -2315,6 +2379,53 @@ public:
         return *this;
     }
 
+    SBE_NODISCARD static const char *DiscretionPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    {
+        switch (metaAttribute)
+        {
+            case MetaAttribute::SEMANTIC_TYPE: return "Price";
+            case MetaAttribute::PRESENCE: return "required";
+            default: return "";
+        }
+    }
+
+    static SBE_CONSTEXPR std::uint16_t discretionPriceId() SBE_NOEXCEPT
+    {
+        return 845;
+    }
+
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t discretionPriceSinceVersion() SBE_NOEXCEPT
+    {
+        return 6;
+    }
+
+    SBE_NODISCARD bool discretionPriceInActingVersion() SBE_NOEXCEPT
+    {
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
+        return m_actingVersion >= discretionPriceSinceVersion();
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+    }
+
+    SBE_NODISCARD static SBE_CONSTEXPR std::size_t discretionPriceEncodingOffset() SBE_NOEXCEPT
+    {
+        return 125;
+    }
+
+private:
+    PRICENULL9 m_discretionPrice;
+
+public:
+    SBE_NODISCARD PRICENULL9 &discretionPrice()
+    {
+        m_discretionPrice.wrap(m_buffer, m_offset + 125, m_actingVersion, m_bufferLength);
+        return m_discretionPrice;
+    }
+
 template<typename CharT, typename Traits>
 friend std::basic_ostream<CharT, Traits>& operator << (
     std::basic_ostream<CharT, Traits>& builder, OrderCancelReplaceRequest515 _writer)
@@ -2429,6 +2540,10 @@ friend std::basic_ostream<CharT, Traits>& operator << (
     builder << R"("ShortSaleType": )";
     builder << '"' << writer.shortSaleType() << '"';
 
+    builder << ", ";
+    builder << R"("DiscretionPrice": )";
+    builder << writer.discretionPrice();
+
     builder << '}';
 
     return builder;
@@ -2443,13 +2558,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return true;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+SBE_NODISCARD static std::size_t computeLength()
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
+    std::size_t length = sbeBlockLength();
 
     return length;
 #if defined(__GNUG__) && !defined(__clang__)

src/lib/orderman/actors/ilink3/generated/OrderCancelRequest516.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(88);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(516);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     OrderCancelRequest516() = default;
 
     OrderCancelRequest516(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)88;
+        return static_cast<std::uint16_t>(88);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)516;
+        return static_cast<std::uint16_t>(516);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "F";
     }
@@ -258,7 +260,7 @@ public:
 
     OrderCancelRequest516 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = OrderCancelRequest516(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        OrderCancelRequest516 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        OrderCancelRequest516 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,12 +338,12 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
             case MetaAttribute::SEMANTIC_TYPE: return "int";
-            case MetaAttribute::PRESENCE: return "required";
+            case MetaAttribute::PRESENCE: return "optional";
             default: return "";
         }
     }
@@ -376,17 +377,17 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT
     {
-        return SBE_NULLVALUE_UINT64;
+        return UINT64_C(0xffffffffffffffff);
     }
 
     static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -452,12 +453,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -521,7 +522,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -535,7 +543,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -579,12 +587,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -606,7 +614,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -645,17 +653,17 @@ public:
 
     static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -709,7 +717,7 @@ public:
             throw std::runtime_error("length too large for getSenderID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -722,7 +730,7 @@ public:
     SBE_NODISCARD std::string getSenderIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -767,7 +775,7 @@ public:
     SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -779,14 +787,14 @@ public:
     #if __cplusplus >= 201703L
     OrderCancelRequest516 &putSenderID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -796,14 +804,14 @@ public:
     #else
     OrderCancelRequest516 &putSenderID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -812,7 +820,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -851,17 +859,17 @@ public:
 
     static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT
@@ -915,7 +923,7 @@ public:
             throw std::runtime_error("length too large for getClOrdID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 41, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 41, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -928,7 +936,7 @@ public:
     SBE_NODISCARD std::string getClOrdIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 41;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -973,7 +981,7 @@ public:
     SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 41;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -985,14 +993,14 @@ public:
     #if __cplusplus >= 201703L
     OrderCancelRequest516 &putClOrdID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putClOrdID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 41, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 41 + start] = 0;
         }
@@ -1002,14 +1010,14 @@ public:
     #else
     OrderCancelRequest516 &putClOrdID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putClOrdID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 41, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 41 + start] = 0;
         }
@@ -1018,7 +1026,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1062,12 +1070,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT
@@ -1089,7 +1097,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1133,12 +1141,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1160,7 +1168,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1199,17 +1207,17 @@ public:
 
     static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1263,7 +1271,7 @@ public:
             throw std::runtime_error("length too large for getLocation [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 77, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 77, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1276,7 +1284,7 @@ public:
     SBE_NODISCARD std::string getLocationAsString() const
     {
         const char *buffer = m_buffer + m_offset + 77;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1321,7 +1329,7 @@ public:
     SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 77;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1333,14 +1341,14 @@ public:
     #if __cplusplus >= 201703L
     OrderCancelRequest516 &putLocation(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 77, str.data(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 77 + start] = 0;
         }
@@ -1350,14 +1358,14 @@ public:
     #else
     OrderCancelRequest516 &putLocation(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 77, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 77 + start] = 0;
         }
@@ -1366,7 +1374,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1410,12 +1418,12 @@ public:
 
     static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
     {
-        return -2147483647;
+        return INT32_C(-2147483647);
     }
 
     static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
     {
-        return 2147483647;
+        return INT32_C(2147483647);
     }
 
     static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -1437,7 +1445,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1479,7 +1487,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 86, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD SideReq::Value side() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 86, sizeof(std::uint8_t));
@@ -1493,7 +1508,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1535,7 +1550,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 87, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD BooleanNULL::Value liquidityFlag() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 87, sizeof(std::uint8_t));
@@ -1625,13 +1647,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return true;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+SBE_NODISCARD static std::size_t computeLength()
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
+    std::size_t length = sbeBlockLength();
 
     return length;
 #if defined(__GNUG__) && !defined(__clang__)

src/lib/orderman/actors/ilink3/generated/OrderEventType.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class OrderEventType
 public:
     enum Value
     {
-        PartiallyFilled = (std::uint8_t)4,
-        Filled = (std::uint8_t)5,
-        NULL_VALUE = (std::uint8_t)255
+        PartiallyFilled = static_cast<std::uint8_t>(4),
+        Filled = static_cast<std::uint8_t>(5),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static OrderEventType::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 4: return PartiallyFilled;
-            case 5: return Filled;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(4): return PartiallyFilled;
+            case static_cast<std::uint8_t>(5): return Filled;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum OrderEventType [E103]");
     }
 
-    static const char* c_str(const OrderEventType::Value value)
+    static const char *c_str(const OrderEventType::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/OrderMassActionRequest529.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(71);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(529);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     OrderMassActionRequest529() = default;
 
     OrderMassActionRequest529(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)71;
+        return static_cast<std::uint16_t>(71);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)529;
+        return static_cast<std::uint16_t>(529);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "CA";
     }
@@ -258,7 +260,7 @@ public:
 
     OrderMassActionRequest529 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = OrderMassActionRequest529(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        OrderMassActionRequest529 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        OrderMassActionRequest529 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -381,12 +382,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -452,12 +453,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -521,7 +522,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -535,7 +543,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -579,12 +587,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -606,7 +614,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -645,17 +653,17 @@ public:
 
     static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -709,7 +717,7 @@ public:
             throw std::runtime_error("length too large for getSenderID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -722,7 +730,7 @@ public:
     SBE_NODISCARD std::string getSenderIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -767,7 +775,7 @@ public:
     SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -779,14 +787,14 @@ public:
     #if __cplusplus >= 201703L
     OrderMassActionRequest529 &putSenderID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -796,14 +804,14 @@ public:
     #else
     OrderMassActionRequest529 &putSenderID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -812,7 +820,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * MassActionTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *MassActionTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -851,17 +859,17 @@ public:
 
     static SBE_CONSTEXPR char massActionTypeNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char massActionTypeMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char massActionTypeMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t massActionTypeEncodingLength() SBE_NOEXCEPT
@@ -876,14 +884,14 @@ public:
 
     SBE_NODISCARD const char *massActionType() const
     {
-        static const std::uint8_t massActionTypeValues[] = { 51 };
+        static const std::uint8_t massActionTypeValues[] = { 51, 0 };
 
         return (const char *)massActionTypeValues;
     }
 
     SBE_NODISCARD char massActionType(const std::uint64_t index) const
     {
-        static const std::uint8_t massActionTypeValues[] = { 51 };
+        static const std::uint8_t massActionTypeValues[] = { 51, 0 };
 
         return (char)massActionTypeValues[index];
     }
@@ -893,7 +901,7 @@ public:
         static std::uint8_t massActionTypeValues[] = { 51 };
         std::uint64_t bytesToCopy = length < sizeof(massActionTypeValues) ? length : sizeof(massActionTypeValues);
 
-        std::memcpy(dst, massActionTypeValues, static_cast<size_t>(bytesToCopy));
+        std::memcpy(dst, massActionTypeValues, static_cast<std::size_t>(bytesToCopy));
         return bytesToCopy;
     }
 
@@ -937,7 +945,7 @@ public:
         return oss.str();
     }
 
-    SBE_NODISCARD static const char * SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -981,12 +989,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1008,7 +1016,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SecurityGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SecurityGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1047,17 +1055,17 @@ public:
 
     static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t securityGroupEncodingLength() SBE_NOEXCEPT
@@ -1111,7 +1119,7 @@ public:
             throw std::runtime_error("length too large for getSecurityGroup [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 49, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 49, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1124,7 +1132,7 @@ public:
     SBE_NODISCARD std::string getSecurityGroupAsString() const
     {
         const char *buffer = m_buffer + m_offset + 49;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 6 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1169,7 +1177,7 @@ public:
     SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 49;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 6 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1181,14 +1189,14 @@ public:
     #if __cplusplus >= 201703L
     OrderMassActionRequest529 &putSecurityGroup(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 6)
         {
             throw std::runtime_error("string too large for putSecurityGroup [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 49, str.data(), srcLength);
-        for (size_t start = srcLength; start < 6; ++start)
+        for (std::size_t start = srcLength; start < 6; ++start)
         {
             m_buffer[m_offset + 49 + start] = 0;
         }
@@ -1198,14 +1206,14 @@ public:
     #else
     OrderMassActionRequest529 &putSecurityGroup(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 6)
         {
             throw std::runtime_error("string too large for putSecurityGroup [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 49, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 6; ++start)
+        for (std::size_t start = srcLength; start < 6; ++start)
         {
             m_buffer[m_offset + 49 + start] = 0;
         }
@@ -1214,7 +1222,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1253,17 +1261,17 @@ public:
 
     static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1317,7 +1325,7 @@ public:
             throw std::runtime_error("length too large for getLocation [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 55, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 55, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1330,7 +1338,7 @@ public:
     SBE_NODISCARD std::string getLocationAsString() const
     {
         const char *buffer = m_buffer + m_offset + 55;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1375,7 +1383,7 @@ public:
     SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 55;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1387,14 +1395,14 @@ public:
     #if __cplusplus >= 201703L
     OrderMassActionRequest529 &putLocation(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 55, str.data(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 55 + start] = 0;
         }
@@ -1404,14 +1412,14 @@ public:
     #else
     OrderMassActionRequest529 &putLocation(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 55, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 55 + start] = 0;
         }
@@ -1420,7 +1428,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1459,17 +1467,17 @@ public:
 
     static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT
     {
-        return 2147483647;
+        return INT32_C(2147483647);
     }
 
     static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
     {
-        return -2147483647;
+        return INT32_C(-2147483647);
     }
 
     static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
     {
-        return 2147483647;
+        return INT32_C(2147483647);
     }
 
     static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -1491,7 +1499,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * MassActionScopeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *MassActionScopeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1533,7 +1541,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD MassActionScope::Value massActionScope() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t massActionScopeRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD MassActionScope::Value massActionScope() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint8_t));
@@ -1547,7 +1562,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * MarketSegmentIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *MarketSegmentIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1586,17 +1601,17 @@ public:
 
     static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)255;
+        return static_cast<std::uint8_t>(255);
     }
 
     static SBE_CONSTEXPR std::uint8_t marketSegmentIDMinValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)0;
+        return static_cast<std::uint8_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint8_t marketSegmentIDMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)254;
+        return static_cast<std::uint8_t>(254);
     }
 
     static SBE_CONSTEXPR std::size_t marketSegmentIDEncodingLength() SBE_NOEXCEPT
@@ -1618,7 +1633,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * MassCancelRequestTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *MassCancelRequestTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1660,7 +1675,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD MassCxlReqTyp::Value massCancelRequestType() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t massCancelRequestTypeRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD MassCxlReqTyp::Value massCancelRequestType() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t));
@@ -1674,7 +1696,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1716,7 +1738,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD SideNULL::Value side() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD SideNULL::Value side() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t));
@@ -1730,7 +1759,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1772,7 +1801,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD MassActionOrdTyp::Value ordType() const SBE_NOEXCEPT
+    SBE_NODISCARD char ordTypeRaw() const SBE_NOEXCEPT
+    {
+        char val;
+        std::memcpy(&val, m_buffer + m_offset + 68, sizeof(char));
+        return (val);
+    }
+
+    SBE_NODISCARD MassActionOrdTyp::Value ordType() const
     {
         char val;
         std::memcpy(&val, m_buffer + m_offset + 68, sizeof(char));
@@ -1786,7 +1822,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1828,7 +1864,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD MassCancelTIF::Value timeInForce() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t timeInForceRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD MassCancelTIF::Value timeInForce() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint8_t));
@@ -1842,7 +1885,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1884,7 +1927,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 70, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD BooleanNULL::Value liquidityFlag() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 70, sizeof(std::uint8_t));
@@ -1990,13 +2040,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return true;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+SBE_NODISCARD static std::size_t computeLength()
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
+    std::size_t length = sbeBlockLength();
 
     return length;
 #if defined(__GNUG__) && !defined(__clang__)

src/lib/orderman/actors/ilink3/generated/OrderMassStatusRequest530.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(68);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(530);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     OrderMassStatusRequest530() = default;
 
     OrderMassStatusRequest530(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)68;
+        return static_cast<std::uint16_t>(68);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)530;
+        return static_cast<std::uint16_t>(530);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "AF";
     }
@@ -258,7 +260,7 @@ public:
 
     OrderMassStatusRequest530 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = OrderMassStatusRequest530(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        OrderMassStatusRequest530 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        OrderMassStatusRequest530 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -381,12 +382,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * MassStatusReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *MassStatusReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -452,12 +453,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t massStatusReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t massStatusReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t massStatusReqIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -521,7 +522,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -535,7 +543,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -579,12 +587,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -606,7 +614,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -645,17 +653,17 @@ public:
 
     static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -709,7 +717,7 @@ public:
             throw std::runtime_error("length too large for getSenderID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -722,7 +730,7 @@ public:
     SBE_NODISCARD std::string getSenderIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -767,7 +775,7 @@ public:
     SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -779,14 +787,14 @@ public:
     #if __cplusplus >= 201703L
     OrderMassStatusRequest530 &putSenderID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -796,14 +804,14 @@ public:
     #else
     OrderMassStatusRequest530 &putSenderID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -812,7 +820,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -856,12 +864,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -883,7 +891,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SecurityGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SecurityGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -922,17 +930,17 @@ public:
 
     static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t securityGroupEncodingLength() SBE_NOEXCEPT
@@ -986,7 +994,7 @@ public:
             throw std::runtime_error("length too large for getSecurityGroup [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 49, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 49, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -999,7 +1007,7 @@ public:
     SBE_NODISCARD std::string getSecurityGroupAsString() const
     {
         const char *buffer = m_buffer + m_offset + 49;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 6 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1044,7 +1052,7 @@ public:
     SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 49;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 6 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1056,14 +1064,14 @@ public:
     #if __cplusplus >= 201703L
     OrderMassStatusRequest530 &putSecurityGroup(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 6)
         {
             throw std::runtime_error("string too large for putSecurityGroup [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 49, str.data(), srcLength);
-        for (size_t start = srcLength; start < 6; ++start)
+        for (std::size_t start = srcLength; start < 6; ++start)
         {
             m_buffer[m_offset + 49 + start] = 0;
         }
@@ -1073,14 +1081,14 @@ public:
     #else
     OrderMassStatusRequest530 &putSecurityGroup(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 6)
         {
             throw std::runtime_error("string too large for putSecurityGroup [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 49, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 6; ++start)
+        for (std::size_t start = srcLength; start < 6; ++start)
         {
             m_buffer[m_offset + 49 + start] = 0;
         }
@@ -1089,7 +1097,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1128,17 +1136,17 @@ public:
 
     static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1192,7 +1200,7 @@ public:
             throw std::runtime_error("length too large for getLocation [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 55, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 55, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1205,7 +1213,7 @@ public:
     SBE_NODISCARD std::string getLocationAsString() const
     {
         const char *buffer = m_buffer + m_offset + 55;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1250,7 +1258,7 @@ public:
     SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 55;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1262,14 +1270,14 @@ public:
     #if __cplusplus >= 201703L
     OrderMassStatusRequest530 &putLocation(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 55, str.data(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 55 + start] = 0;
         }
@@ -1279,14 +1287,14 @@ public:
     #else
     OrderMassStatusRequest530 &putLocation(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 55, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 55 + start] = 0;
         }
@@ -1295,7 +1303,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1334,17 +1342,17 @@ public:
 
     static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT
     {
-        return 2147483647;
+        return INT32_C(2147483647);
     }
 
     static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
     {
-        return -2147483647;
+        return INT32_C(-2147483647);
     }
 
     static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
     {
-        return 2147483647;
+        return INT32_C(2147483647);
     }
 
     static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -1366,7 +1374,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * MassStatusReqTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *MassStatusReqTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1408,7 +1416,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD MassStatusReqTyp::Value massStatusReqType() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t massStatusReqTypeRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD MassStatusReqTyp::Value massStatusReqType() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint8_t));
@@ -1422,7 +1437,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * OrdStatusReqTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrdStatusReqTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1464,7 +1479,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD MassStatusOrdTyp::Value ordStatusReqType() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t ordStatusReqTypeRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 65, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD MassStatusOrdTyp::Value ordStatusReqType() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 65, sizeof(std::uint8_t));
@@ -1478,7 +1500,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1520,7 +1542,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD MassStatusTIF::Value timeInForce() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t timeInForceRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD MassStatusTIF::Value timeInForce() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t));
@@ -1534,7 +1563,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * MarketSegmentIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *MarketSegmentIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1573,17 +1602,17 @@ public:
 
     static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)255;
+        return static_cast<std::uint8_t>(255);
     }
 
     static SBE_CONSTEXPR std::uint8_t marketSegmentIDMinValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)0;
+        return static_cast<std::uint8_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint8_t marketSegmentIDMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)254;
+        return static_cast<std::uint8_t>(254);
     }
 
     static SBE_CONSTEXPR std::size_t marketSegmentIDEncodingLength() SBE_NOEXCEPT
@@ -1685,13 +1714,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return true;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+SBE_NODISCARD static std::size_t computeLength()
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
+    std::size_t length = sbeBlockLength();
 
     return length;
 #if defined(__GNUG__) && !defined(__clang__)

src/lib/orderman/actors/ilink3/generated/OrderStatus.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,36 +94,40 @@ class OrderStatus
 public:
     enum Value
     {
-        New = (char)48,
-        PartiallyFilled = (char)49,
-        Filled = (char)50,
-        Cancelled = (char)52,
-        Replaced = (char)53,
-        Rejected = (char)56,
-        Expired = (char)67,
-        Undefined = (char)85,
-        NULL_VALUE = (char)0
+        New = static_cast<char>(48),
+        PartiallyFilled = static_cast<char>(49),
+        Filled = static_cast<char>(50),
+        Cancelled = static_cast<char>(52),
+        Replaced = static_cast<char>(53),
+        PendingCancel = static_cast<char>(54),
+        Rejected = static_cast<char>(56),
+        Expired = static_cast<char>(67),
+        PendingReplace = static_cast<char>(69),
+        Undefined = static_cast<char>(85),
+        NULL_VALUE = static_cast<char>(0)
     };
 
     static OrderStatus::Value get(const char value)
     {
         switch (value)
         {
-            case 48: return New;
-            case 49: return PartiallyFilled;
-            case 50: return Filled;
-            case 52: return Cancelled;
-            case 53: return Replaced;
-            case 56: return Rejected;
-            case 67: return Expired;
-            case 85: return Undefined;
-            case 0: return NULL_VALUE;
+            case static_cast<char>(48): return New;
+            case static_cast<char>(49): return PartiallyFilled;
+            case static_cast<char>(50): return Filled;
+            case static_cast<char>(52): return Cancelled;
+            case static_cast<char>(53): return Replaced;
+            case static_cast<char>(54): return PendingCancel;
+            case static_cast<char>(56): return Rejected;
+            case static_cast<char>(67): return Expired;
+            case static_cast<char>(69): return PendingReplace;
+            case static_cast<char>(85): return Undefined;
+            case static_cast<char>(0): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum OrderStatus [E103]");
     }
 
-    static const char* c_str(const OrderStatus::Value value)
+    static const char *c_str(const OrderStatus::Value value)
     {
         switch (value)
         {
@@ -137,8 +136,10 @@ public:
             case Filled: return "Filled";
             case Cancelled: return "Cancelled";
             case Replaced: return "Replaced";
+            case PendingCancel: return "PendingCancel";
             case Rejected: return "Rejected";
             case Expired: return "Expired";
+            case PendingReplace: return "PendingReplace";
             case Undefined: return "Undefined";
             case NULL_VALUE: return "NULL_VALUE";
         }

src/lib/orderman/actors/ilink3/generated/OrderStatusRequest533.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(62);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(533);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     OrderStatusRequest533() = default;
 
     OrderStatusRequest533(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)62;
+        return static_cast<std::uint16_t>(62);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)533;
+        return static_cast<std::uint16_t>(533);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "H";
     }
@@ -258,7 +260,7 @@ public:
 
     OrderStatusRequest533 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = OrderStatusRequest533(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        OrderStatusRequest533 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        OrderStatusRequest533 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -381,12 +382,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * OrdStatusReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrdStatusReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -452,12 +453,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t ordStatusReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t ordStatusReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t ordStatusReqIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -521,7 +522,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -535,7 +543,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -579,12 +587,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -606,7 +614,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -645,17 +653,17 @@ public:
 
     static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -709,7 +717,7 @@ public:
             throw std::runtime_error("length too large for getSenderID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -722,7 +730,7 @@ public:
     SBE_NODISCARD std::string getSenderIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -767,7 +775,7 @@ public:
     SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -779,14 +787,14 @@ public:
     #if __cplusplus >= 201703L
     OrderStatusRequest533 &putSenderID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -796,14 +804,14 @@ public:
     #else
     OrderStatusRequest533 &putSenderID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -812,7 +820,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -856,12 +864,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT
@@ -883,7 +891,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -927,12 +935,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -954,7 +962,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -993,17 +1001,17 @@ public:
 
     static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1057,7 +1065,7 @@ public:
             throw std::runtime_error("length too large for getLocation [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 57, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 57, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -1070,7 +1078,7 @@ public:
     SBE_NODISCARD std::string getLocationAsString() const
     {
         const char *buffer = m_buffer + m_offset + 57;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -1115,7 +1123,7 @@ public:
     SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 57;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -1127,14 +1135,14 @@ public:
     #if __cplusplus >= 201703L
     OrderStatusRequest533 &putLocation(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 57, str.data(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 57 + start] = 0;
         }
@@ -1144,14 +1152,14 @@ public:
     #else
     OrderStatusRequest533 &putLocation(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 57, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 57 + start] = 0;
         }
@@ -1219,13 +1227,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return true;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+SBE_NODISCARD static std::size_t computeLength()
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
+    std::size_t length = sbeBlockLength();
 
     return length;
 #if defined(__GNUG__) && !defined(__clang__)

src/lib/orderman/actors/ilink3/generated/OrderType.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,28 +94,28 @@ class OrderType
 public:
     enum Value
     {
-        MarketWithProtection = (char)49,
-        Limit = (char)50,
-        StopLimit = (char)52,
-        MarketWithLeftoverAsLimit = (char)75,
-        NULL_VALUE = (char)0
+        MarketWithProtection = static_cast<char>(49),
+        Limit = static_cast<char>(50),
+        StopLimit = static_cast<char>(52),
+        MarketWithLeftoverAsLimit = static_cast<char>(75),
+        NULL_VALUE = static_cast<char>(0)
     };
 
     static OrderType::Value get(const char value)
     {
         switch (value)
         {
-            case 49: return MarketWithProtection;
-            case 50: return Limit;
-            case 52: return StopLimit;
-            case 75: return MarketWithLeftoverAsLimit;
-            case 0: return NULL_VALUE;
+            case static_cast<char>(49): return MarketWithProtection;
+            case static_cast<char>(50): return Limit;
+            case static_cast<char>(52): return StopLimit;
+            case static_cast<char>(75): return MarketWithLeftoverAsLimit;
+            case static_cast<char>(0): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum OrderType [E103]");
     }
 
-    static const char* c_str(const OrderType::Value value)
+    static const char *c_str(const OrderType::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/OrderTypeReq.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,30 +94,30 @@ class OrderTypeReq
 public:
     enum Value
     {
-        MarketwithProtection = (char)49,
-        Limit = (char)50,
-        StopwithProtection = (char)51,
-        StopLimit = (char)52,
-        MarketWithLeftoverAsLimit = (char)75,
-        NULL_VALUE = (char)0
+        MarketwithProtection = static_cast<char>(49),
+        Limit = static_cast<char>(50),
+        StopwithProtection = static_cast<char>(51),
+        StopLimit = static_cast<char>(52),
+        MarketWithLeftoverAsLimit = static_cast<char>(75),
+        NULL_VALUE = static_cast<char>(0)
     };
 
     static OrderTypeReq::Value get(const char value)
     {
         switch (value)
         {
-            case 49: return MarketwithProtection;
-            case 50: return Limit;
-            case 51: return StopwithProtection;
-            case 52: return StopLimit;
-            case 75: return MarketWithLeftoverAsLimit;
-            case 0: return NULL_VALUE;
+            case static_cast<char>(49): return MarketwithProtection;
+            case static_cast<char>(50): return Limit;
+            case static_cast<char>(51): return StopwithProtection;
+            case static_cast<char>(52): return StopLimit;
+            case static_cast<char>(75): return MarketWithLeftoverAsLimit;
+            case static_cast<char>(0): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum OrderTypeReq [E103]");
     }
 
-    static const char* c_str(const OrderTypeReq::Value value)
+    static const char *c_str(const OrderTypeReq::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/PRICE9.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -172,12 +167,12 @@ public:
         return m_offset;
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -194,15 +189,15 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static const char * mantissaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *mantissaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -245,12 +240,12 @@ public:
 
     static SBE_CONSTEXPR std::int64_t mantissaMinValue() SBE_NOEXCEPT
     {
-        return -9223372036854775807L;
+        return INT64_C(-9223372036854775807);
     }
 
     static SBE_CONSTEXPR std::int64_t mantissaMaxValue() SBE_NOEXCEPT
     {
-        return 9223372036854775807L;
+        return INT64_C(9223372036854775807);
     }
 
     static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT
@@ -272,7 +267,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * exponentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *exponentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -315,12 +310,12 @@ public:
 
     static SBE_CONSTEXPR std::int8_t exponentMinValue() SBE_NOEXCEPT
     {
-        return (std::int8_t)-127;
+        return static_cast<std::int8_t>(-127);
     }
 
     static SBE_CONSTEXPR std::int8_t exponentMaxValue() SBE_NOEXCEPT
     {
-        return (std::int8_t)127;
+        return static_cast<std::int8_t>(127);
     }
 
     static SBE_CONSTEXPR std::size_t exponentEncodingLength() SBE_NOEXCEPT
@@ -330,7 +325,7 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::int8_t exponent() SBE_NOEXCEPT
     {
-        return (std::int8_t)-9;
+        return static_cast<std::int8_t>(-9);
     }
 
 template<typename CharT, typename Traits>

src/lib/orderman/actors/ilink3/generated/PRICENULL9.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -172,12 +167,12 @@ public:
         return m_offset;
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -194,15 +189,15 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static const char * mantissaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *mantissaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -240,17 +235,17 @@ public:
 
     static SBE_CONSTEXPR std::int64_t mantissaNullValue() SBE_NOEXCEPT
     {
-        return 9223372036854775807L;
+        return INT64_C(9223372036854775807);
     }
 
     static SBE_CONSTEXPR std::int64_t mantissaMinValue() SBE_NOEXCEPT
     {
-        return -9223372036854775807L;
+        return INT64_C(-9223372036854775807);
     }
 
     static SBE_CONSTEXPR std::int64_t mantissaMaxValue() SBE_NOEXCEPT
     {
-        return 9223372036854775807L;
+        return INT64_C(9223372036854775807);
     }
 
     static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT
@@ -272,7 +267,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * exponentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *exponentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -315,12 +310,12 @@ public:
 
     static SBE_CONSTEXPR std::int8_t exponentMinValue() SBE_NOEXCEPT
     {
-        return (std::int8_t)-127;
+        return static_cast<std::int8_t>(-127);
     }
 
     static SBE_CONSTEXPR std::int8_t exponentMaxValue() SBE_NOEXCEPT
     {
-        return (std::int8_t)127;
+        return static_cast<std::int8_t>(127);
     }
 
     static SBE_CONSTEXPR std::size_t exponentEncodingLength() SBE_NOEXCEPT
@@ -330,7 +325,7 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::int8_t exponent() SBE_NOEXCEPT
     {
-        return (std::int8_t)-9;
+        return static_cast<std::int8_t>(-9);
     }
 
 template<typename CharT, typename Traits>

src/lib/orderman/actors/ilink3/generated/PartyDetailRole.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,30 +94,30 @@ class PartyDetailRole
 public:
     enum Value
     {
-        ExecutingFirm = (std::uint16_t)1,
-        CustomerAccount = (std::uint16_t)24,
-        TakeUpFirm = (std::uint16_t)96,
-        Operator = (std::uint16_t)118,
-        TakeUpAccount = (std::uint16_t)1000,
-        NULL_VALUE = (std::uint16_t)65535
+        ExecutingFirm = static_cast<std::uint16_t>(1),
+        CustomerAccount = static_cast<std::uint16_t>(24),
+        TakeUpFirm = static_cast<std::uint16_t>(96),
+        Operator = static_cast<std::uint16_t>(118),
+        TakeUpAccount = static_cast<std::uint16_t>(1000),
+        NULL_VALUE = static_cast<std::uint16_t>(65535)
     };
 
     static PartyDetailRole::Value get(const std::uint16_t value)
     {
         switch (value)
         {
-            case 1: return ExecutingFirm;
-            case 24: return CustomerAccount;
-            case 96: return TakeUpFirm;
-            case 118: return Operator;
-            case 1000: return TakeUpAccount;
-            case 65535: return NULL_VALUE;
+            case static_cast<std::uint16_t>(1): return ExecutingFirm;
+            case static_cast<std::uint16_t>(24): return CustomerAccount;
+            case static_cast<std::uint16_t>(96): return TakeUpFirm;
+            case static_cast<std::uint16_t>(118): return Operator;
+            case static_cast<std::uint16_t>(1000): return TakeUpAccount;
+            case static_cast<std::uint16_t>(65535): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum PartyDetailRole [E103]");
     }
 
-    static const char* c_str(const PartyDetailRole::Value value)
+    static const char *c_str(const PartyDetailRole::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/PartyDetailsDefinitionRequest518.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(147);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(518);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     PartyDetailsDefinitionRequest518() = default;
 
     PartyDetailsDefinitionRequest518(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)147;
+        return static_cast<std::uint16_t>(147);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)518;
+        return static_cast<std::uint16_t>(518);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "CX";
     }
@@ -258,7 +260,7 @@ public:
 
     PartyDetailsDefinitionRequest518 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = PartyDetailsDefinitionRequest518(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        PartyDetailsDefinitionRequest518 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        PartyDetailsDefinitionRequest518 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -381,12 +382,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -452,12 +453,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ListUpdateActionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ListUpdateActionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -521,7 +522,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ListUpdAct::Value listUpdateAction() const SBE_NOEXCEPT
+    SBE_NODISCARD char listUpdateActionRaw() const SBE_NOEXCEPT
+    {
+        char val;
+        std::memcpy(&val, m_buffer + m_offset + 16, sizeof(char));
+        return (val);
+    }
+
+    SBE_NODISCARD ListUpdAct::Value listUpdateAction() const
     {
         char val;
         std::memcpy(&val, m_buffer + m_offset + 16, sizeof(char));
@@ -535,7 +543,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -579,12 +587,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -606,7 +614,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * MemoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *MemoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -645,17 +653,17 @@ public:
 
     static SBE_CONSTEXPR char memoNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char memoMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char memoMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t memoEncodingLength() SBE_NOEXCEPT
@@ -709,7 +717,7 @@ public:
             throw std::runtime_error("length too large for getMemo [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -722,7 +730,7 @@ public:
     SBE_NODISCARD std::string getMemoAsString() const
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 75 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -767,7 +775,7 @@ public:
     SBE_NODISCARD std::string_view getMemoAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 75 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -779,14 +787,14 @@ public:
     #if __cplusplus >= 201703L
     PartyDetailsDefinitionRequest518 &putMemo(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 75)
         {
             throw std::runtime_error("string too large for putMemo [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength);
-        for (size_t start = srcLength; start < 75; ++start)
+        for (std::size_t start = srcLength; start < 75; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -796,14 +804,14 @@ public:
     #else
     PartyDetailsDefinitionRequest518 &putMemo(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 75)
         {
             throw std::runtime_error("string too large for putMemo [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 75; ++start)
+        for (std::size_t start = srcLength; start < 75; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -812,7 +820,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * AvgPxGroupIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *AvgPxGroupIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -851,17 +859,17 @@ public:
 
     static SBE_CONSTEXPR char avgPxGroupIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char avgPxGroupIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char avgPxGroupIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t avgPxGroupIDEncodingLength() SBE_NOEXCEPT
@@ -915,7 +923,7 @@ public:
             throw std::runtime_error("length too large for getAvgPxGroupID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 96, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 96, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -928,7 +936,7 @@ public:
     SBE_NODISCARD std::string getAvgPxGroupIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 96;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -973,7 +981,7 @@ public:
     SBE_NODISCARD std::string_view getAvgPxGroupIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 96;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -985,14 +993,14 @@ public:
     #if __cplusplus >= 201703L
     PartyDetailsDefinitionRequest518 &putAvgPxGroupID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putAvgPxGroupID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 96, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 96 + start] = 0;
         }
@@ -1002,14 +1010,14 @@ public:
     #else
     PartyDetailsDefinitionRequest518 &putAvgPxGroupID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putAvgPxGroupID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 96, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 96 + start] = 0;
         }
@@ -1018,7 +1026,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * SelfMatchPreventionIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SelfMatchPreventionIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1057,17 +1065,17 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDNullValue() SBE_NOEXCEPT
     {
-        return 0xffffffffffffffffL;
+        return UINT64_C(0xffffffffffffffff);
     }
 
     static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t selfMatchPreventionIDEncodingLength() SBE_NOEXCEPT
@@ -1089,7 +1097,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * CmtaGiveupCDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *CmtaGiveupCDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1131,7 +1139,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD CmtaGiveUpCD::Value cmtaGiveupCD() const SBE_NOEXCEPT
+    SBE_NODISCARD char cmtaGiveupCDRaw() const SBE_NOEXCEPT
+    {
+        char val;
+        std::memcpy(&val, m_buffer + m_offset + 124, sizeof(char));
+        return (val);
+    }
+
+    SBE_NODISCARD CmtaGiveUpCD::Value cmtaGiveupCD() const
     {
         char val;
         std::memcpy(&val, m_buffer + m_offset + 124, sizeof(char));
@@ -1145,7 +1160,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * CustOrderCapacityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *CustOrderCapacityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1187,7 +1202,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD CustOrderCapacity::Value custOrderCapacity() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t custOrderCapacityRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 125, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD CustOrderCapacity::Value custOrderCapacity() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 125, sizeof(std::uint8_t));
@@ -1201,7 +1223,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ClearingAccountTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ClearingAccountTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1243,7 +1265,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ClearingAcctType::Value clearingAccountType() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t clearingAccountTypeRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 126, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ClearingAcctType::Value clearingAccountType() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 126, sizeof(std::uint8_t));
@@ -1257,7 +1286,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SelfMatchPreventionInstructionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SelfMatchPreventionInstructionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1299,7 +1328,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD SMPI::Value selfMatchPreventionInstruction() const SBE_NOEXCEPT
+    SBE_NODISCARD char selfMatchPreventionInstructionRaw() const SBE_NOEXCEPT
+    {
+        char val;
+        std::memcpy(&val, m_buffer + m_offset + 127, sizeof(char));
+        return (val);
+    }
+
+    SBE_NODISCARD SMPI::Value selfMatchPreventionInstruction() const
     {
         char val;
         std::memcpy(&val, m_buffer + m_offset + 127, sizeof(char));
@@ -1313,7 +1349,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * AvgPxIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *AvgPxIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1355,7 +1391,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD AvgPxInd::Value avgPxIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t avgPxIndicatorRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 128, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD AvgPxInd::Value avgPxIndicator() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 128, sizeof(std::uint8_t));
@@ -1369,7 +1412,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ClearingTradePriceTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ClearingTradePriceTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1411,7 +1454,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD SLEDS::Value clearingTradePriceType() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t clearingTradePriceTypeRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 129, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD SLEDS::Value clearingTradePriceType() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 129, sizeof(std::uint8_t));
@@ -1425,7 +1475,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * CustOrderHandlingInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *CustOrderHandlingInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1467,7 +1517,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD CustOrdHandlInst::Value custOrderHandlingInst() const SBE_NOEXCEPT
+    SBE_NODISCARD char custOrderHandlingInstRaw() const SBE_NOEXCEPT
+    {
+        char val;
+        std::memcpy(&val, m_buffer + m_offset + 130, sizeof(char));
+        return (val);
+    }
+
+    SBE_NODISCARD CustOrdHandlInst::Value custOrderHandlingInst() const
     {
         char val;
         std::memcpy(&val, m_buffer + m_offset + 130, sizeof(char));
@@ -1481,7 +1538,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ExecutorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ExecutorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1520,17 +1577,17 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t executorNullValue() SBE_NOEXCEPT
     {
-        return 0xffffffffffffffffL;
+        return UINT64_C(0xffffffffffffffff);
     }
 
     static SBE_CONSTEXPR std::uint64_t executorMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t executorMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t executorEncodingLength() SBE_NOEXCEPT
@@ -1552,7 +1609,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * IDMShortCodeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *IDMShortCodeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1591,17 +1648,17 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t iDMShortCodeNullValue() SBE_NOEXCEPT
     {
-        return 0xffffffffffffffffL;
+        return UINT64_C(0xffffffffffffffff);
     }
 
     static SBE_CONSTEXPR std::uint64_t iDMShortCodeMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t iDMShortCodeMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t iDMShortCodeEncodingLength() SBE_NOEXCEPT
@@ -1623,7 +1680,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * NoPartyUpdatesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *NoPartyUpdatesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1667,12 +1724,12 @@ public:
 
     static SBE_CONSTEXPR std::uint8_t noPartyUpdatesMinValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)0;
+        return static_cast<std::uint8_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint8_t noPartyUpdatesMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint8_t)254;
+        return static_cast<std::uint8_t>(254);
     }
 
     static SBE_CONSTEXPR std::size_t noPartyUpdatesEncodingLength() SBE_NOEXCEPT
@@ -1682,7 +1739,7 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint8_t noPartyUpdates() SBE_NOEXCEPT
     {
-        return (std::uint8_t)1;
+        return static_cast<std::uint8_t>(1);
     }
 
     class NoPartyDetails
@@ -1743,8 +1800,8 @@ public:
             m_buffer = buffer;
             m_bufferLength = bufferLength;
             GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
-            dimensions.blockLength((std::uint16_t)22);
-            dimensions.numInGroup((std::uint8_t)count);
+            dimensions.blockLength(static_cast<std::uint16_t>(22));
+            dimensions.numInGroup(static_cast<std::uint8_t>(count));
             m_index = 0;
             m_count = count;
             m_blockLength = 22;
@@ -1815,7 +1872,7 @@ public:
         {
             m_count = m_index;
             GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion);
-            dimensions.numInGroup((std::uint8_t)m_count);
+            dimensions.numInGroup(static_cast<std::uint8_t>(m_count));
             return m_count;
         }
 
@@ -1841,7 +1898,7 @@ public:
 
     #endif
 
-        SBE_NODISCARD static const char * PartyDetailIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *PartyDetailIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -1880,17 +1937,17 @@ public:
 
         static SBE_CONSTEXPR char partyDetailIDNullValue() SBE_NOEXCEPT
         {
-            return (char)0;
+            return static_cast<char>(0);
         }
 
         static SBE_CONSTEXPR char partyDetailIDMinValue() SBE_NOEXCEPT
         {
-            return (char)32;
+            return static_cast<char>(32);
         }
 
         static SBE_CONSTEXPR char partyDetailIDMaxValue() SBE_NOEXCEPT
         {
-            return (char)126;
+            return static_cast<char>(126);
         }
 
         static SBE_CONSTEXPR std::size_t partyDetailIDEncodingLength() SBE_NOEXCEPT
@@ -1944,7 +2001,7 @@ public:
                 throw std::runtime_error("length too large for getPartyDetailID [E106]");
             }
 
-            std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast<size_t>(length));
+            std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast<std::size_t>(length));
             return length;
         }
 
@@ -1957,7 +2014,7 @@ public:
         SBE_NODISCARD std::string getPartyDetailIDAsString() const
         {
             const char *buffer = m_buffer + m_offset + 0;
-            size_t length = 0;
+            std::size_t length = 0;
 
             for (; length < 20 && *(buffer + length) != '\0'; ++length);
             std::string result(buffer, length);
@@ -2002,7 +2059,7 @@ public:
         SBE_NODISCARD std::string_view getPartyDetailIDAsStringView() const SBE_NOEXCEPT
         {
             const char *buffer = m_buffer + m_offset + 0;
-            size_t length = 0;
+            std::size_t length = 0;
 
             for (; length < 20 && *(buffer + length) != '\0'; ++length);
             std::string_view result(buffer, length);
@@ -2014,14 +2071,14 @@ public:
         #if __cplusplus >= 201703L
         NoPartyDetails &putPartyDetailID(const std::string_view str)
         {
-            const size_t srcLength = str.length();
+            const std::size_t srcLength = str.length();
             if (srcLength > 20)
             {
                 throw std::runtime_error("string too large for putPartyDetailID [E106]");
             }
 
             std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength);
-            for (size_t start = srcLength; start < 20; ++start)
+            for (std::size_t start = srcLength; start < 20; ++start)
             {
                 m_buffer[m_offset + 0 + start] = 0;
             }
@@ -2031,14 +2088,14 @@ public:
         #else
         NoPartyDetails &putPartyDetailID(const std::string& str)
         {
-            const size_t srcLength = str.length();
+            const std::size_t srcLength = str.length();
             if (srcLength > 20)
             {
                 throw std::runtime_error("string too large for putPartyDetailID [E106]");
             }
 
             std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength);
-            for (size_t start = srcLength; start < 20; ++start)
+            for (std::size_t start = srcLength; start < 20; ++start)
             {
                 m_buffer[m_offset + 0 + start] = 0;
             }
@@ -2047,7 +2104,7 @@ public:
         }
         #endif
 
-        SBE_NODISCARD static const char * PartyDetailIDSourceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *PartyDetailIDSourceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2086,17 +2143,17 @@ public:
 
         static SBE_CONSTEXPR char partyDetailIDSourceNullValue() SBE_NOEXCEPT
         {
-            return (char)0;
+            return static_cast<char>(0);
         }
 
         static SBE_CONSTEXPR char partyDetailIDSourceMinValue() SBE_NOEXCEPT
         {
-            return (char)32;
+            return static_cast<char>(32);
         }
 
         static SBE_CONSTEXPR char partyDetailIDSourceMaxValue() SBE_NOEXCEPT
         {
-            return (char)126;
+            return static_cast<char>(126);
         }
 
         static SBE_CONSTEXPR std::size_t partyDetailIDSourceEncodingLength() SBE_NOEXCEPT
@@ -2111,14 +2168,14 @@ public:
 
         SBE_NODISCARD const char *partyDetailIDSource() const
         {
-            static const std::uint8_t partyDetailIDSourceValues[] = { 67 };
+            static const std::uint8_t partyDetailIDSourceValues[] = { 67, 0 };
 
             return (const char *)partyDetailIDSourceValues;
         }
 
         SBE_NODISCARD char partyDetailIDSource(const std::uint64_t index) const
         {
-            static const std::uint8_t partyDetailIDSourceValues[] = { 67 };
+            static const std::uint8_t partyDetailIDSourceValues[] = { 67, 0 };
 
             return (char)partyDetailIDSourceValues[index];
         }
@@ -2128,7 +2185,7 @@ public:
             static std::uint8_t partyDetailIDSourceValues[] = { 67 };
             std::uint64_t bytesToCopy = length < sizeof(partyDetailIDSourceValues) ? length : sizeof(partyDetailIDSourceValues);
 
-            std::memcpy(dst, partyDetailIDSourceValues, static_cast<size_t>(bytesToCopy));
+            std::memcpy(dst, partyDetailIDSourceValues, static_cast<std::size_t>(bytesToCopy));
             return bytesToCopy;
         }
 
@@ -2172,7 +2229,7 @@ public:
             return oss.str();
         }
 
-        SBE_NODISCARD static const char * PartyDetailRoleMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *PartyDetailRoleMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2214,7 +2271,14 @@ public:
             return 2;
         }
 
-        SBE_NODISCARD PartyDetailRole::Value partyDetailRole() const SBE_NOEXCEPT
+        SBE_NODISCARD std::uint16_t partyDetailRoleRaw() const SBE_NOEXCEPT
+        {
+            std::uint16_t val;
+            std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint16_t));
+            return SBE_LITTLE_ENDIAN_ENCODE_16(val);
+        }
+
+        SBE_NODISCARD PartyDetailRole::Value partyDetailRole() const
         {
             std::uint16_t val;
             std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint16_t));
@@ -2255,13 +2319,13 @@ public:
             return true;
         }
 
-        SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+        SBE_NODISCARD static std::size_t computeLength()
         {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-            size_t length = sbeBlockLength();
+            std::size_t length = sbeBlockLength();
 
             return length;
 #if defined(__GNUG__) && !defined(__clang__)
@@ -2366,8 +2430,8 @@ public:
             m_buffer = buffer;
             m_bufferLength = bufferLength;
             GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
-            dimensions.blockLength((std::uint16_t)2);
-            dimensions.numInGroup((std::uint8_t)count);
+            dimensions.blockLength(static_cast<std::uint16_t>(2));
+            dimensions.numInGroup(static_cast<std::uint8_t>(count));
             m_index = 0;
             m_count = count;
             m_blockLength = 2;
@@ -2438,7 +2502,7 @@ public:
         {
             m_count = m_index;
             GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion);
-            dimensions.numInGroup((std::uint8_t)m_count);
+            dimensions.numInGroup(static_cast<std::uint8_t>(m_count));
             return m_count;
         }
 
@@ -2464,7 +2528,7 @@ public:
 
     #endif
 
-        SBE_NODISCARD static const char * TrdRegPublicationTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *TrdRegPublicationTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2508,12 +2572,12 @@ public:
 
         static SBE_CONSTEXPR std::uint8_t trdRegPublicationTypeMinValue() SBE_NOEXCEPT
         {
-            return (std::uint8_t)0;
+            return static_cast<std::uint8_t>(0);
         }
 
         static SBE_CONSTEXPR std::uint8_t trdRegPublicationTypeMaxValue() SBE_NOEXCEPT
         {
-            return (std::uint8_t)254;
+            return static_cast<std::uint8_t>(254);
         }
 
         static SBE_CONSTEXPR std::size_t trdRegPublicationTypeEncodingLength() SBE_NOEXCEPT
@@ -2535,7 +2599,7 @@ public:
             return *this;
         }
 
-        SBE_NODISCARD static const char * TrdRegPublicationReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *TrdRegPublicationReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2579,12 +2643,12 @@ public:
 
         static SBE_CONSTEXPR std::uint8_t trdRegPublicationReasonMinValue() SBE_NOEXCEPT
         {
-            return (std::uint8_t)0;
+            return static_cast<std::uint8_t>(0);
         }
 
         static SBE_CONSTEXPR std::uint8_t trdRegPublicationReasonMaxValue() SBE_NOEXCEPT
         {
-            return (std::uint8_t)254;
+            return static_cast<std::uint8_t>(254);
         }
 
         static SBE_CONSTEXPR std::size_t trdRegPublicationReasonEncodingLength() SBE_NOEXCEPT
@@ -2632,13 +2696,13 @@ public:
             return true;
         }
 
-        SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+        SBE_NODISCARD static std::size_t computeLength()
         {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-            size_t length = sbeBlockLength();
+            std::size_t length = sbeBlockLength();
 
             return length;
 #if defined(__GNUG__) && !defined(__clang__)
@@ -2816,30 +2880,30 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return false;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength(
-    std::size_t NoPartyDetailsLength = 0,
-    std::size_t NoTrdRegPublicationsLength = 0)
+SBE_NODISCARD static std::size_t computeLength(
+    std::size_t noPartyDetailsLength = 0,
+    std::size_t noTrdRegPublicationsLength = 0)
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
-
+    std::size_t length = sbeBlockLength();
 
     length += NoPartyDetails::sbeHeaderSize();
-    if (NoPartyDetailsLength > 254)
+    if (noPartyDetailsLength > 254LL)
     {
-        throw std::runtime_error("NoPartyDetailsLength outside of allowed range [E110]");
+        throw std::runtime_error("noPartyDetailsLength outside of allowed range [E110]");
     }
-    length += NoPartyDetailsLength * NoPartyDetails::sbeBlockLength();
+    length += noPartyDetailsLength *NoPartyDetails::sbeBlockLength();
 
     length += NoTrdRegPublications::sbeHeaderSize();
-    if (NoTrdRegPublicationsLength > 254)
+    if (noTrdRegPublicationsLength > 254LL)
     {
-        throw std::runtime_error("NoTrdRegPublicationsLength outside of allowed range [E110]");
+        throw std::runtime_error("noTrdRegPublicationsLength outside of allowed range [E110]");
     }
-    length += NoTrdRegPublicationsLength * NoTrdRegPublications::sbeBlockLength();
+    length += noTrdRegPublicationsLength *NoTrdRegPublications::sbeBlockLength();
+
     return length;
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic pop

src/lib/orderman/actors/ilink3/generated/PartyDetailsListReport538.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(93);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(538);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     PartyDetailsListReport538() = default;
 
     PartyDetailsListReport538(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)93;
+        return static_cast<std::uint16_t>(93);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)538;
+        return static_cast<std::uint16_t>(538);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "CG";
     }
@@ -258,7 +260,7 @@ public:
 
     PartyDetailsListReport538 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = PartyDetailsListReport538(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        PartyDetailsListReport538 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        PartyDetailsListReport538 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -381,12 +382,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -452,12 +453,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * AvgPxGroupIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *AvgPxGroupIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -518,17 +519,17 @@ public:
 
     static SBE_CONSTEXPR char avgPxGroupIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char avgPxGroupIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char avgPxGroupIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t avgPxGroupIDEncodingLength() SBE_NOEXCEPT
@@ -582,7 +583,7 @@ public:
             throw std::runtime_error("length too large for getAvgPxGroupID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -595,7 +596,7 @@ public:
     SBE_NODISCARD std::string getAvgPxGroupIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 12;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -640,7 +641,7 @@ public:
     SBE_NODISCARD std::string_view getAvgPxGroupIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 12;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -652,14 +653,14 @@ public:
     #if __cplusplus >= 201703L
     PartyDetailsListReport538 &putAvgPxGroupID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putAvgPxGroupID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 12 + start] = 0;
         }
@@ -669,14 +670,14 @@ public:
     #else
     PartyDetailsListReport538 &putAvgPxGroupID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putAvgPxGroupID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 12 + start] = 0;
         }
@@ -685,7 +686,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -729,12 +730,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -756,7 +757,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * PartyDetailsListReportIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PartyDetailsListReportIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -800,12 +801,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReportIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReportIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t partyDetailsListReportIDEncodingLength() SBE_NOEXCEPT
@@ -827,7 +828,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -871,12 +872,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -898,7 +899,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SelfMatchPreventionIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SelfMatchPreventionIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -937,17 +938,17 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDNullValue() SBE_NOEXCEPT
     {
-        return 0xffffffffffffffffL;
+        return UINT64_C(0xffffffffffffffff);
     }
 
     static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t selfMatchPreventionIDEncodingLength() SBE_NOEXCEPT
@@ -969,7 +970,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * TotNumPartiesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *TotNumPartiesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1013,12 +1014,12 @@ public:
 
     static SBE_CONSTEXPR std::uint16_t totNumPartiesMinValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)0;
+        return static_cast<std::uint16_t>(0);
     }
 
     static SBE_CONSTEXPR std::uint16_t totNumPartiesMaxValue() SBE_NOEXCEPT
     {
-        return (std::uint16_t)65534;
+        return static_cast<std::uint16_t>(65534);
     }
 
     static SBE_CONSTEXPR std::size_t totNumPartiesEncodingLength() SBE_NOEXCEPT
@@ -1040,7 +1041,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * RequestResultMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *RequestResultMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1082,7 +1083,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ReqResult::Value requestResult() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t requestResultRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ReqResult::Value requestResult() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t));
@@ -1096,7 +1104,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LastFragmentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LastFragmentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1138,7 +1146,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD BooleanFlag::Value lastFragment() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t lastFragmentRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD BooleanFlag::Value lastFragment() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t));
@@ -1152,7 +1167,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * CustOrderCapacityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *CustOrderCapacityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1194,7 +1209,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD CustOrderCapacity::Value custOrderCapacity() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t custOrderCapacityRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 68, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD CustOrderCapacity::Value custOrderCapacity() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 68, sizeof(std::uint8_t));
@@ -1208,7 +1230,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ClearingAccountTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ClearingAccountTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1250,7 +1272,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ClearingAcctType::Value clearingAccountType() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t clearingAccountTypeRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ClearingAcctType::Value clearingAccountType() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint8_t));
@@ -1264,7 +1293,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SelfMatchPreventionInstructionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SelfMatchPreventionInstructionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1306,7 +1335,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD SMPI::Value selfMatchPreventionInstruction() const SBE_NOEXCEPT
+    SBE_NODISCARD char selfMatchPreventionInstructionRaw() const SBE_NOEXCEPT
+    {
+        char val;
+        std::memcpy(&val, m_buffer + m_offset + 70, sizeof(char));
+        return (val);
+    }
+
+    SBE_NODISCARD SMPI::Value selfMatchPreventionInstruction() const
     {
         char val;
         std::memcpy(&val, m_buffer + m_offset + 70, sizeof(char));
@@ -1320,7 +1356,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * AvgPxIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *AvgPxIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1362,7 +1398,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD AvgPxInd::Value avgPxIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t avgPxIndicatorRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 71, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD AvgPxInd::Value avgPxIndicator() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 71, sizeof(std::uint8_t));
@@ -1376,7 +1419,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ClearingTradePriceTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ClearingTradePriceTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1418,7 +1461,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD SLEDS::Value clearingTradePriceType() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t clearingTradePriceTypeRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 72, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD SLEDS::Value clearingTradePriceType() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 72, sizeof(std::uint8_t));
@@ -1432,7 +1482,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * CmtaGiveupCDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *CmtaGiveupCDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1474,7 +1524,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD CmtaGiveUpCD::Value cmtaGiveupCD() const SBE_NOEXCEPT
+    SBE_NODISCARD char cmtaGiveupCDRaw() const SBE_NOEXCEPT
+    {
+        char val;
+        std::memcpy(&val, m_buffer + m_offset + 73, sizeof(char));
+        return (val);
+    }
+
+    SBE_NODISCARD CmtaGiveUpCD::Value cmtaGiveupCD() const
     {
         char val;
         std::memcpy(&val, m_buffer + m_offset + 73, sizeof(char));
@@ -1488,7 +1545,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * CustOrderHandlingInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *CustOrderHandlingInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1530,7 +1587,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD CustOrdHandlInst::Value custOrderHandlingInst() const SBE_NOEXCEPT
+    SBE_NODISCARD char custOrderHandlingInstRaw() const SBE_NOEXCEPT
+    {
+        char val;
+        std::memcpy(&val, m_buffer + m_offset + 74, sizeof(char));
+        return (val);
+    }
+
+    SBE_NODISCARD CustOrdHandlInst::Value custOrderHandlingInst() const
     {
         char val;
         std::memcpy(&val, m_buffer + m_offset + 74, sizeof(char));
@@ -1544,7 +1608,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ExecutorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ExecutorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1583,17 +1647,17 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t executorNullValue() SBE_NOEXCEPT
     {
-        return 0xffffffffffffffffL;
+        return UINT64_C(0xffffffffffffffff);
     }
 
     static SBE_CONSTEXPR std::uint64_t executorMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t executorMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t executorEncodingLength() SBE_NOEXCEPT
@@ -1615,7 +1679,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * IDMShortCodeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *IDMShortCodeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1654,17 +1718,17 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t iDMShortCodeNullValue() SBE_NOEXCEPT
     {
-        return 0xffffffffffffffffL;
+        return UINT64_C(0xffffffffffffffff);
     }
 
     static SBE_CONSTEXPR std::uint64_t iDMShortCodeMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t iDMShortCodeMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t iDMShortCodeEncodingLength() SBE_NOEXCEPT
@@ -1686,7 +1750,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1728,7 +1792,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 91, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD BooleanFlag::Value possRetransFlag() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 91, sizeof(std::uint8_t));
@@ -1742,7 +1813,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1784,7 +1855,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD SplitMsg::Value splitMsg() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint8_t));
@@ -1856,8 +1934,8 @@ public:
             m_buffer = buffer;
             m_bufferLength = bufferLength;
             GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
-            dimensions.blockLength((std::uint16_t)22);
-            dimensions.numInGroup((std::uint8_t)count);
+            dimensions.blockLength(static_cast<std::uint16_t>(22));
+            dimensions.numInGroup(static_cast<std::uint8_t>(count));
             m_index = 0;
             m_count = count;
             m_blockLength = 22;
@@ -1928,7 +2006,7 @@ public:
         {
             m_count = m_index;
             GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion);
-            dimensions.numInGroup((std::uint8_t)m_count);
+            dimensions.numInGroup(static_cast<std::uint8_t>(m_count));
             return m_count;
         }
 
@@ -1954,7 +2032,7 @@ public:
 
     #endif
 
-        SBE_NODISCARD static const char * PartyDetailIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *PartyDetailIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -1993,17 +2071,17 @@ public:
 
         static SBE_CONSTEXPR char partyDetailIDNullValue() SBE_NOEXCEPT
         {
-            return (char)0;
+            return static_cast<char>(0);
         }
 
         static SBE_CONSTEXPR char partyDetailIDMinValue() SBE_NOEXCEPT
         {
-            return (char)32;
+            return static_cast<char>(32);
         }
 
         static SBE_CONSTEXPR char partyDetailIDMaxValue() SBE_NOEXCEPT
         {
-            return (char)126;
+            return static_cast<char>(126);
         }
 
         static SBE_CONSTEXPR std::size_t partyDetailIDEncodingLength() SBE_NOEXCEPT
@@ -2057,7 +2135,7 @@ public:
                 throw std::runtime_error("length too large for getPartyDetailID [E106]");
             }
 
-            std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast<size_t>(length));
+            std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast<std::size_t>(length));
             return length;
         }
 
@@ -2070,7 +2148,7 @@ public:
         SBE_NODISCARD std::string getPartyDetailIDAsString() const
         {
             const char *buffer = m_buffer + m_offset + 0;
-            size_t length = 0;
+            std::size_t length = 0;
 
             for (; length < 20 && *(buffer + length) != '\0'; ++length);
             std::string result(buffer, length);
@@ -2115,7 +2193,7 @@ public:
         SBE_NODISCARD std::string_view getPartyDetailIDAsStringView() const SBE_NOEXCEPT
         {
             const char *buffer = m_buffer + m_offset + 0;
-            size_t length = 0;
+            std::size_t length = 0;
 
             for (; length < 20 && *(buffer + length) != '\0'; ++length);
             std::string_view result(buffer, length);
@@ -2127,14 +2205,14 @@ public:
         #if __cplusplus >= 201703L
         NoPartyDetails &putPartyDetailID(const std::string_view str)
         {
-            const size_t srcLength = str.length();
+            const std::size_t srcLength = str.length();
             if (srcLength > 20)
             {
                 throw std::runtime_error("string too large for putPartyDetailID [E106]");
             }
 
             std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength);
-            for (size_t start = srcLength; start < 20; ++start)
+            for (std::size_t start = srcLength; start < 20; ++start)
             {
                 m_buffer[m_offset + 0 + start] = 0;
             }
@@ -2144,14 +2222,14 @@ public:
         #else
         NoPartyDetails &putPartyDetailID(const std::string& str)
         {
-            const size_t srcLength = str.length();
+            const std::size_t srcLength = str.length();
             if (srcLength > 20)
             {
                 throw std::runtime_error("string too large for putPartyDetailID [E106]");
             }
 
             std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength);
-            for (size_t start = srcLength; start < 20; ++start)
+            for (std::size_t start = srcLength; start < 20; ++start)
             {
                 m_buffer[m_offset + 0 + start] = 0;
             }
@@ -2160,7 +2238,7 @@ public:
         }
         #endif
 
-        SBE_NODISCARD static const char * PartyDetailIDSourceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *PartyDetailIDSourceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2199,17 +2277,17 @@ public:
 
         static SBE_CONSTEXPR char partyDetailIDSourceNullValue() SBE_NOEXCEPT
         {
-            return (char)0;
+            return static_cast<char>(0);
         }
 
         static SBE_CONSTEXPR char partyDetailIDSourceMinValue() SBE_NOEXCEPT
         {
-            return (char)32;
+            return static_cast<char>(32);
         }
 
         static SBE_CONSTEXPR char partyDetailIDSourceMaxValue() SBE_NOEXCEPT
         {
-            return (char)126;
+            return static_cast<char>(126);
         }
 
         static SBE_CONSTEXPR std::size_t partyDetailIDSourceEncodingLength() SBE_NOEXCEPT
@@ -2224,14 +2302,14 @@ public:
 
         SBE_NODISCARD const char *partyDetailIDSource() const
         {
-            static const std::uint8_t partyDetailIDSourceValues[] = { 67 };
+            static const std::uint8_t partyDetailIDSourceValues[] = { 67, 0 };
 
             return (const char *)partyDetailIDSourceValues;
         }
 
         SBE_NODISCARD char partyDetailIDSource(const std::uint64_t index) const
         {
-            static const std::uint8_t partyDetailIDSourceValues[] = { 67 };
+            static const std::uint8_t partyDetailIDSourceValues[] = { 67, 0 };
 
             return (char)partyDetailIDSourceValues[index];
         }
@@ -2241,7 +2319,7 @@ public:
             static std::uint8_t partyDetailIDSourceValues[] = { 67 };
             std::uint64_t bytesToCopy = length < sizeof(partyDetailIDSourceValues) ? length : sizeof(partyDetailIDSourceValues);
 
-            std::memcpy(dst, partyDetailIDSourceValues, static_cast<size_t>(bytesToCopy));
+            std::memcpy(dst, partyDetailIDSourceValues, static_cast<std::size_t>(bytesToCopy));
             return bytesToCopy;
         }
 
@@ -2285,7 +2363,7 @@ public:
             return oss.str();
         }
 
-        SBE_NODISCARD static const char * PartyDetailRoleMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *PartyDetailRoleMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2327,7 +2405,14 @@ public:
             return 2;
         }
 
-        SBE_NODISCARD PartyDetailRole::Value partyDetailRole() const SBE_NOEXCEPT
+        SBE_NODISCARD std::uint16_t partyDetailRoleRaw() const SBE_NOEXCEPT
+        {
+            std::uint16_t val;
+            std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint16_t));
+            return SBE_LITTLE_ENDIAN_ENCODE_16(val);
+        }
+
+        SBE_NODISCARD PartyDetailRole::Value partyDetailRole() const
         {
             std::uint16_t val;
             std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint16_t));
@@ -2368,13 +2453,13 @@ public:
             return true;
         }
 
-        SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+        SBE_NODISCARD static std::size_t computeLength()
         {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-            size_t length = sbeBlockLength();
+            std::size_t length = sbeBlockLength();
 
             return length;
 #if defined(__GNUG__) && !defined(__clang__)
@@ -2479,8 +2564,8 @@ public:
             m_buffer = buffer;
             m_bufferLength = bufferLength;
             GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
-            dimensions.blockLength((std::uint16_t)2);
-            dimensions.numInGroup((std::uint8_t)count);
+            dimensions.blockLength(static_cast<std::uint16_t>(2));
+            dimensions.numInGroup(static_cast<std::uint8_t>(count));
             m_index = 0;
             m_count = count;
             m_blockLength = 2;
@@ -2551,7 +2636,7 @@ public:
         {
             m_count = m_index;
             GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion);
-            dimensions.numInGroup((std::uint8_t)m_count);
+            dimensions.numInGroup(static_cast<std::uint8_t>(m_count));
             return m_count;
         }
 
@@ -2577,7 +2662,7 @@ public:
 
     #endif
 
-        SBE_NODISCARD static const char * TrdRegPublicationTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *TrdRegPublicationTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2621,12 +2706,12 @@ public:
 
         static SBE_CONSTEXPR std::uint8_t trdRegPublicationTypeMinValue() SBE_NOEXCEPT
         {
-            return (std::uint8_t)0;
+            return static_cast<std::uint8_t>(0);
         }
 
         static SBE_CONSTEXPR std::uint8_t trdRegPublicationTypeMaxValue() SBE_NOEXCEPT
         {
-            return (std::uint8_t)254;
+            return static_cast<std::uint8_t>(254);
         }
 
         static SBE_CONSTEXPR std::size_t trdRegPublicationTypeEncodingLength() SBE_NOEXCEPT
@@ -2648,7 +2733,7 @@ public:
             return *this;
         }
 
-        SBE_NODISCARD static const char * TrdRegPublicationReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *TrdRegPublicationReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2692,12 +2777,12 @@ public:
 
         static SBE_CONSTEXPR std::uint8_t trdRegPublicationReasonMinValue() SBE_NOEXCEPT
         {
-            return (std::uint8_t)0;
+            return static_cast<std::uint8_t>(0);
         }
 
         static SBE_CONSTEXPR std::uint8_t trdRegPublicationReasonMaxValue() SBE_NOEXCEPT
         {
-            return (std::uint8_t)254;
+            return static_cast<std::uint8_t>(254);
         }
 
         static SBE_CONSTEXPR std::size_t trdRegPublicationReasonEncodingLength() SBE_NOEXCEPT
@@ -2745,13 +2830,13 @@ public:
             return true;
         }
 
-        SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+        SBE_NODISCARD static std::size_t computeLength()
         {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-            size_t length = sbeBlockLength();
+            std::size_t length = sbeBlockLength();
 
             return length;
 #if defined(__GNUG__) && !defined(__clang__)
@@ -2948,30 +3033,30 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return false;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength(
-    std::size_t NoPartyDetailsLength = 0,
-    std::size_t NoTrdRegPublicationsLength = 0)
+SBE_NODISCARD static std::size_t computeLength(
+    std::size_t noPartyDetailsLength = 0,
+    std::size_t noTrdRegPublicationsLength = 0)
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
-
+    std::size_t length = sbeBlockLength();
 
     length += NoPartyDetails::sbeHeaderSize();
-    if (NoPartyDetailsLength > 254)
+    if (noPartyDetailsLength > 254LL)
     {
-        throw std::runtime_error("NoPartyDetailsLength outside of allowed range [E110]");
+        throw std::runtime_error("noPartyDetailsLength outside of allowed range [E110]");
     }
-    length += NoPartyDetailsLength * NoPartyDetails::sbeBlockLength();
+    length += noPartyDetailsLength *NoPartyDetails::sbeBlockLength();
 
     length += NoTrdRegPublications::sbeHeaderSize();
-    if (NoTrdRegPublicationsLength > 254)
+    if (noTrdRegPublicationsLength > 254LL)
     {
-        throw std::runtime_error("NoTrdRegPublicationsLength outside of allowed range [E110]");
+        throw std::runtime_error("noTrdRegPublicationsLength outside of allowed range [E110]");
     }
-    length += NoTrdRegPublicationsLength * NoTrdRegPublications::sbeBlockLength();
+    length += noTrdRegPublicationsLength *NoTrdRegPublications::sbeBlockLength();
+
     return length;
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic pop

src/lib/orderman/actors/ilink3/generated/PartyDetailsListRequest537.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(20);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(537);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     PartyDetailsListRequest537() = default;
 
     PartyDetailsListRequest537(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)20;
+        return static_cast<std::uint16_t>(20);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)537;
+        return static_cast<std::uint16_t>(537);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "CF";
     }
@@ -258,7 +260,7 @@ public:
 
     PartyDetailsListRequest537 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = PartyDetailsListRequest537(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        PartyDetailsListRequest537 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        PartyDetailsListRequest537 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -381,12 +382,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -452,12 +453,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -523,12 +524,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -608,8 +609,8 @@ public:
             m_buffer = buffer;
             m_bufferLength = bufferLength;
             GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
-            dimensions.blockLength((std::uint16_t)7);
-            dimensions.numInGroup((std::uint8_t)count);
+            dimensions.blockLength(static_cast<std::uint16_t>(7));
+            dimensions.numInGroup(static_cast<std::uint8_t>(count));
             m_index = 0;
             m_count = count;
             m_blockLength = 7;
@@ -680,7 +681,7 @@ public:
         {
             m_count = m_index;
             GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion);
-            dimensions.numInGroup((std::uint8_t)m_count);
+            dimensions.numInGroup(static_cast<std::uint8_t>(m_count));
             return m_count;
         }
 
@@ -706,7 +707,7 @@ public:
 
     #endif
 
-        SBE_NODISCARD static const char * RequestingPartyIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *RequestingPartyIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -745,17 +746,17 @@ public:
 
         static SBE_CONSTEXPR char requestingPartyIDNullValue() SBE_NOEXCEPT
         {
-            return (char)0;
+            return static_cast<char>(0);
         }
 
         static SBE_CONSTEXPR char requestingPartyIDMinValue() SBE_NOEXCEPT
         {
-            return (char)32;
+            return static_cast<char>(32);
         }
 
         static SBE_CONSTEXPR char requestingPartyIDMaxValue() SBE_NOEXCEPT
         {
-            return (char)126;
+            return static_cast<char>(126);
         }
 
         static SBE_CONSTEXPR std::size_t requestingPartyIDEncodingLength() SBE_NOEXCEPT
@@ -809,7 +810,7 @@ public:
                 throw std::runtime_error("length too large for getRequestingPartyID [E106]");
             }
 
-            std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast<size_t>(length));
+            std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast<std::size_t>(length));
             return length;
         }
 
@@ -822,7 +823,7 @@ public:
         SBE_NODISCARD std::string getRequestingPartyIDAsString() const
         {
             const char *buffer = m_buffer + m_offset + 0;
-            size_t length = 0;
+            std::size_t length = 0;
 
             for (; length < 5 && *(buffer + length) != '\0'; ++length);
             std::string result(buffer, length);
@@ -867,7 +868,7 @@ public:
         SBE_NODISCARD std::string_view getRequestingPartyIDAsStringView() const SBE_NOEXCEPT
         {
             const char *buffer = m_buffer + m_offset + 0;
-            size_t length = 0;
+            std::size_t length = 0;
 
             for (; length < 5 && *(buffer + length) != '\0'; ++length);
             std::string_view result(buffer, length);
@@ -879,14 +880,14 @@ public:
         #if __cplusplus >= 201703L
         NoRequestingPartyIDs &putRequestingPartyID(const std::string_view str)
         {
-            const size_t srcLength = str.length();
+            const std::size_t srcLength = str.length();
             if (srcLength > 5)
             {
                 throw std::runtime_error("string too large for putRequestingPartyID [E106]");
             }
 
             std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength);
-            for (size_t start = srcLength; start < 5; ++start)
+            for (std::size_t start = srcLength; start < 5; ++start)
             {
                 m_buffer[m_offset + 0 + start] = 0;
             }
@@ -896,14 +897,14 @@ public:
         #else
         NoRequestingPartyIDs &putRequestingPartyID(const std::string& str)
         {
-            const size_t srcLength = str.length();
+            const std::size_t srcLength = str.length();
             if (srcLength > 5)
             {
                 throw std::runtime_error("string too large for putRequestingPartyID [E106]");
             }
 
             std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength);
-            for (size_t start = srcLength; start < 5; ++start)
+            for (std::size_t start = srcLength; start < 5; ++start)
             {
                 m_buffer[m_offset + 0 + start] = 0;
             }
@@ -912,7 +913,7 @@ public:
         }
         #endif
 
-        SBE_NODISCARD static const char * RequestingPartyIDSourceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *RequestingPartyIDSourceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -951,17 +952,17 @@ public:
 
         static SBE_CONSTEXPR char requestingPartyIDSourceNullValue() SBE_NOEXCEPT
         {
-            return (char)0;
+            return static_cast<char>(0);
         }
 
         static SBE_CONSTEXPR char requestingPartyIDSourceMinValue() SBE_NOEXCEPT
         {
-            return (char)32;
+            return static_cast<char>(32);
         }
 
         static SBE_CONSTEXPR char requestingPartyIDSourceMaxValue() SBE_NOEXCEPT
         {
-            return (char)126;
+            return static_cast<char>(126);
         }
 
         static SBE_CONSTEXPR std::size_t requestingPartyIDSourceEncodingLength() SBE_NOEXCEPT
@@ -983,7 +984,7 @@ public:
             return *this;
         }
 
-        SBE_NODISCARD static const char * RequestingPartyRoleMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *RequestingPartyRoleMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -1022,17 +1023,17 @@ public:
 
         static SBE_CONSTEXPR char requestingPartyRoleNullValue() SBE_NOEXCEPT
         {
-            return (char)0;
+            return static_cast<char>(0);
         }
 
         static SBE_CONSTEXPR char requestingPartyRoleMinValue() SBE_NOEXCEPT
         {
-            return (char)32;
+            return static_cast<char>(32);
         }
 
         static SBE_CONSTEXPR char requestingPartyRoleMaxValue() SBE_NOEXCEPT
         {
-            return (char)126;
+            return static_cast<char>(126);
         }
 
         static SBE_CONSTEXPR std::size_t requestingPartyRoleEncodingLength() SBE_NOEXCEPT
@@ -1099,13 +1100,13 @@ public:
             return true;
         }
 
-        SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+        SBE_NODISCARD static std::size_t computeLength()
         {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-            size_t length = sbeBlockLength();
+            std::size_t length = sbeBlockLength();
 
             return length;
 #if defined(__GNUG__) && !defined(__clang__)
@@ -1210,8 +1211,8 @@ public:
             m_buffer = buffer;
             m_bufferLength = bufferLength;
             GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
-            dimensions.blockLength((std::uint16_t)11);
-            dimensions.numInGroup((std::uint8_t)count);
+            dimensions.blockLength(static_cast<std::uint16_t>(11));
+            dimensions.numInGroup(static_cast<std::uint8_t>(count));
             m_index = 0;
             m_count = count;
             m_blockLength = 11;
@@ -1282,7 +1283,7 @@ public:
         {
             m_count = m_index;
             GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion);
-            dimensions.numInGroup((std::uint8_t)m_count);
+            dimensions.numInGroup(static_cast<std::uint8_t>(m_count));
             return m_count;
         }
 
@@ -1308,7 +1309,7 @@ public:
 
     #endif
 
-        SBE_NODISCARD static const char * PartyIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *PartyIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -1352,12 +1353,12 @@ public:
 
         static SBE_CONSTEXPR std::uint64_t partyIDMinValue() SBE_NOEXCEPT
         {
-            return 0x0L;
+            return UINT64_C(0x0);
         }
 
         static SBE_CONSTEXPR std::uint64_t partyIDMaxValue() SBE_NOEXCEPT
         {
-            return 0xfffffffffffffffeL;
+            return UINT64_C(0xfffffffffffffffe);
         }
 
         static SBE_CONSTEXPR std::size_t partyIDEncodingLength() SBE_NOEXCEPT
@@ -1379,7 +1380,7 @@ public:
             return *this;
         }
 
-        SBE_NODISCARD static const char * PartyIDSourceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *PartyIDSourceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -1418,17 +1419,17 @@ public:
 
         static SBE_CONSTEXPR char partyIDSourceNullValue() SBE_NOEXCEPT
         {
-            return (char)0;
+            return static_cast<char>(0);
         }
 
         static SBE_CONSTEXPR char partyIDSourceMinValue() SBE_NOEXCEPT
         {
-            return (char)32;
+            return static_cast<char>(32);
         }
 
         static SBE_CONSTEXPR char partyIDSourceMaxValue() SBE_NOEXCEPT
         {
-            return (char)126;
+            return static_cast<char>(126);
         }
 
         static SBE_CONSTEXPR std::size_t partyIDSourceEncodingLength() SBE_NOEXCEPT
@@ -1450,7 +1451,7 @@ public:
             return *this;
         }
 
-        SBE_NODISCARD static const char * PartyRoleMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *PartyRoleMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -1494,12 +1495,12 @@ public:
 
         static SBE_CONSTEXPR std::uint16_t partyRoleMinValue() SBE_NOEXCEPT
         {
-            return (std::uint16_t)0;
+            return static_cast<std::uint16_t>(0);
         }
 
         static SBE_CONSTEXPR std::uint16_t partyRoleMaxValue() SBE_NOEXCEPT
         {
-            return (std::uint16_t)65534;
+            return static_cast<std::uint16_t>(65534);
         }
 
         static SBE_CONSTEXPR std::size_t partyRoleEncodingLength() SBE_NOEXCEPT
@@ -1558,13 +1559,13 @@ public:
             return true;
         }
 
-        SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+        SBE_NODISCARD static std::size_t computeLength()
         {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-            size_t length = sbeBlockLength();
+            std::size_t length = sbeBlockLength();
 
             return length;
 #if defined(__GNUG__) && !defined(__clang__)
@@ -1688,30 +1689,30 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return false;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength(
-    std::size_t NoRequestingPartyIDsLength = 0,
-    std::size_t NoPartyIDsLength = 0)
+SBE_NODISCARD static std::size_t computeLength(
+    std::size_t noRequestingPartyIDsLength = 0,
+    std::size_t noPartyIDsLength = 0)
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
-
+    std::size_t length = sbeBlockLength();
 
     length += NoRequestingPartyIDs::sbeHeaderSize();
-    if (NoRequestingPartyIDsLength > 254)
+    if (noRequestingPartyIDsLength > 254LL)
     {
-        throw std::runtime_error("NoRequestingPartyIDsLength outside of allowed range [E110]");
+        throw std::runtime_error("noRequestingPartyIDsLength outside of allowed range [E110]");
     }
-    length += NoRequestingPartyIDsLength * NoRequestingPartyIDs::sbeBlockLength();
+    length += noRequestingPartyIDsLength *NoRequestingPartyIDs::sbeBlockLength();
 
     length += NoPartyIDs::sbeHeaderSize();
-    if (NoPartyIDsLength > 254)
+    if (noPartyIDsLength > 254LL)
     {
-        throw std::runtime_error("NoPartyIDsLength outside of allowed range [E110]");
+        throw std::runtime_error("noPartyIDsLength outside of allowed range [E110]");
     }
-    length += NoPartyIDsLength * NoPartyIDs::sbeBlockLength();
+    length += noPartyIDsLength *NoPartyIDs::sbeBlockLength();
+
     return length;
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic pop

src/lib/orderman/actors/ilink3/generated/QuoteAckStatus.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class QuoteAckStatus
 public:
     enum Value
     {
-        Accepted = (std::uint8_t)0,
-        Rejected = (std::uint8_t)5,
-        NULL_VALUE = (std::uint8_t)255
+        Accepted = static_cast<std::uint8_t>(0),
+        Rejected = static_cast<std::uint8_t>(5),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static QuoteAckStatus::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 0: return Accepted;
-            case 5: return Rejected;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(0): return Accepted;
+            case static_cast<std::uint8_t>(5): return Rejected;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum QuoteAckStatus [E103]");
     }
 
-    static const char* c_str(const QuoteAckStatus::Value value)
+    static const char *c_str(const QuoteAckStatus::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/QuoteCancel528.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
     }
 
 public:
+    static const std::uint16_t SBE_BLOCK_LENGTH = static_cast<std::uint16_t>(52);
+    static const std::uint16_t SBE_TEMPLATE_ID = static_cast<std::uint16_t>(528);
+    static const std::uint16_t SBE_SCHEMA_ID = static_cast<std::uint16_t>(8);
+    static const std::uint16_t SBE_SCHEMA_VERSION = static_cast<std::uint16_t>(7);
+
     enum MetaAttribute
     {
         EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
         std::uint64_t uint_value;
     };
 
+    using messageHeader = MessageHeader;
+
     QuoteCancel528() = default;
 
     QuoteCancel528(
@@ -218,30 +220,30 @@ public:
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT
     {
-        return (std::uint16_t)52;
+        return static_cast<std::uint16_t>(52);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT
     {
-        return MessageHeader::encodedLength() + sbeBlockLength();
+        return messageHeader::encodedLength() + sbeBlockLength();
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)528;
+        return static_cast<std::uint16_t>(528);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT
     {
-        return (std::uint16_t)8;
+        return static_cast<std::uint16_t>(8);
     }
 
     SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT
     {
-        return (std::uint16_t)5;
+        return static_cast<std::uint16_t>(7);
     }
 
-    SBE_NODISCARD static SBE_CONSTEXPR const char * sbeSemanticType() SBE_NOEXCEPT
+    SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT
     {
         return "Z";
     }
@@ -258,7 +260,7 @@ public:
 
     QuoteCancel528 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength)
     {
-        MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
+        messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion());
 
         hdr
             .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
 
         return *this = QuoteCancel528(
             buffer,
-            offset + MessageHeader::encodedLength(),
+            offset + messageHeader::encodedLength(),
             bufferLength,
             sbeBlockLength(),
             sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
 
     SBE_NODISCARD std::uint64_t decodeLength() const
     {
-        QuoteCancel528 skipper(m_buffer, m_offset,
-            m_bufferLength, sbeBlockLength(), m_actingVersion);
+        QuoteCancel528 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
         skipper.skip();
         return skipper.encodedLength();
     }
 
-    SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT
+    SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
     {
         return m_buffer;
     }
 
-    SBE_NODISCARD char * buffer() SBE_NOEXCEPT
+    SBE_NODISCARD char *buffer() SBE_NOEXCEPT
     {
         return m_buffer;
     }
@@ -337,7 +338,7 @@ public:
         return m_actingVersion;
     }
 
-    SBE_NODISCARD static const char * PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -381,12 +382,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -452,12 +453,12 @@ public:
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
     {
-        return 0x0L;
+        return UINT64_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
     {
-        return 0xfffffffffffffffeL;
+        return UINT64_C(0xfffffffffffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -521,7 +522,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -535,7 +543,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -579,12 +587,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -606,7 +614,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -645,17 +653,17 @@ public:
 
     static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -709,7 +717,7 @@ public:
             throw std::runtime_error("length too large for getSenderID [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -722,7 +730,7 @@ public:
     SBE_NODISCARD std::string getSenderIDAsString() const
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -767,7 +775,7 @@ public:
     SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 21;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 20 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -779,14 +787,14 @@ public:
     #if __cplusplus >= 201703L
     QuoteCancel528 &putSenderID(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -796,14 +804,14 @@ public:
     #else
     QuoteCancel528 &putSenderID(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 20)
         {
             throw std::runtime_error("string too large for putSenderID [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 20; ++start)
+        for (std::size_t start = srcLength; start < 20; ++start)
         {
             m_buffer[m_offset + 21 + start] = 0;
         }
@@ -812,7 +820,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -851,17 +859,17 @@ public:
 
     static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
     {
-        return (char)0;
+        return static_cast<char>(0);
     }
 
     static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
     {
-        return (char)32;
+        return static_cast<char>(32);
     }
 
     static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
     {
-        return (char)126;
+        return static_cast<char>(126);
     }
 
     static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -915,7 +923,7 @@ public:
             throw std::runtime_error("length too large for getLocation [E106]");
         }
 
-        std::memcpy(dst, m_buffer + m_offset + 41, sizeof(char) * static_cast<size_t>(length));
+        std::memcpy(dst, m_buffer + m_offset + 41, sizeof(char) * static_cast<std::size_t>(length));
         return length;
     }
 
@@ -928,7 +936,7 @@ public:
     SBE_NODISCARD std::string getLocationAsString() const
     {
         const char *buffer = m_buffer + m_offset + 41;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string result(buffer, length);
@@ -973,7 +981,7 @@ public:
     SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
     {
         const char *buffer = m_buffer + m_offset + 41;
-        size_t length = 0;
+        std::size_t length = 0;
 
         for (; length < 5 && *(buffer + length) != '\0'; ++length);
         std::string_view result(buffer, length);
@@ -985,14 +993,14 @@ public:
     #if __cplusplus >= 201703L
     QuoteCancel528 &putLocation(const std::string_view str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 41, str.data(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 41 + start] = 0;
         }
@@ -1002,14 +1010,14 @@ public:
     #else
     QuoteCancel528 &putLocation(const std::string& str)
     {
-        const size_t srcLength = str.length();
+        const std::size_t srcLength = str.length();
         if (srcLength > 5)
         {
             throw std::runtime_error("string too large for putLocation [E106]");
         }
 
         std::memcpy(m_buffer + m_offset + 41, str.c_str(), srcLength);
-        for (size_t start = srcLength; start < 5; ++start)
+        for (std::size_t start = srcLength; start < 5; ++start)
         {
             m_buffer[m_offset + 41 + start] = 0;
         }
@@ -1018,7 +1026,7 @@ public:
     }
     #endif
 
-    SBE_NODISCARD static const char * QuoteIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *QuoteIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1062,12 +1070,12 @@ public:
 
     static SBE_CONSTEXPR std::uint32_t quoteIDMinValue() SBE_NOEXCEPT
     {
-        return 0;
+        return UINT32_C(0x0);
     }
 
     static SBE_CONSTEXPR std::uint32_t quoteIDMaxValue() SBE_NOEXCEPT
     {
-        return 4294967294;
+        return UINT32_C(0xfffffffe);
     }
 
     static SBE_CONSTEXPR std::size_t quoteIDEncodingLength() SBE_NOEXCEPT
@@ -1089,7 +1097,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * QuoteCancelTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *QuoteCancelTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1131,7 +1139,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD QuoteCxlTyp::Value quoteCancelType() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t quoteCancelTypeRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 50, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD QuoteCxlTyp::Value quoteCancelType() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 50, sizeof(std::uint8_t));
@@ -1145,7 +1160,7 @@ public:
         return *this;
     }
 
-    SBE_NODISCARD static const char * LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+    SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
     {
         switch (metaAttribute)
         {
@@ -1187,7 +1202,14 @@ public:
         return 1;
     }
 
-    SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT
+    SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT
+    {
+        std::uint8_t val;
+        std::memcpy(&val, m_buffer + m_offset + 51, sizeof(std::uint8_t));
+        return (val);
+    }
+
+    SBE_NODISCARD BooleanNULL::Value liquidityFlag() const
     {
         std::uint8_t val;
         std::memcpy(&val, m_buffer + m_offset + 51, sizeof(std::uint8_t));
@@ -1259,8 +1281,8 @@ public:
             m_buffer = buffer;
             m_bufferLength = bufferLength;
             GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
-            dimensions.blockLength((std::uint16_t)10);
-            dimensions.numInGroup((std::uint8_t)count);
+            dimensions.blockLength(static_cast<std::uint16_t>(10));
+            dimensions.numInGroup(static_cast<std::uint8_t>(count));
             m_index = 0;
             m_count = count;
             m_blockLength = 10;
@@ -1331,7 +1353,7 @@ public:
         {
             m_count = m_index;
             GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion);
-            dimensions.numInGroup((std::uint8_t)m_count);
+            dimensions.numInGroup(static_cast<std::uint8_t>(m_count));
             return m_count;
         }
 
@@ -1357,7 +1379,7 @@ public:
 
     #endif
 
-        SBE_NODISCARD static const char * SecurityGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *SecurityGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -1396,17 +1418,17 @@ public:
 
         static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT
         {
-            return (char)0;
+            return static_cast<char>(0);
         }
 
         static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT
         {
-            return (char)32;
+            return static_cast<char>(32);
         }
 
         static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT
         {
-            return (char)126;
+            return static_cast<char>(126);
         }
 
         static SBE_CONSTEXPR std::size_t securityGroupEncodingLength() SBE_NOEXCEPT
@@ -1460,7 +1482,7 @@ public:
                 throw std::runtime_error("length too large for getSecurityGroup [E106]");
             }
 
-            std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast<size_t>(length));
+            std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast<std::size_t>(length));
             return length;
         }
 
@@ -1473,7 +1495,7 @@ public:
         SBE_NODISCARD std::string getSecurityGroupAsString() const
         {
             const char *buffer = m_buffer + m_offset + 0;
-            size_t length = 0;
+            std::size_t length = 0;
 
             for (; length < 6 && *(buffer + length) != '\0'; ++length);
             std::string result(buffer, length);
@@ -1518,7 +1540,7 @@ public:
         SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT
         {
             const char *buffer = m_buffer + m_offset + 0;
-            size_t length = 0;
+            std::size_t length = 0;
 
             for (; length < 6 && *(buffer + length) != '\0'; ++length);
             std::string_view result(buffer, length);
@@ -1530,14 +1552,14 @@ public:
         #if __cplusplus >= 201703L
         NoQuoteEntries &putSecurityGroup(const std::string_view str)
         {
-            const size_t srcLength = str.length();
+            const std::size_t srcLength = str.length();
             if (srcLength > 6)
             {
                 throw std::runtime_error("string too large for putSecurityGroup [E106]");
             }
 
             std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength);
-            for (size_t start = srcLength; start < 6; ++start)
+            for (std::size_t start = srcLength; start < 6; ++start)
             {
                 m_buffer[m_offset + 0 + start] = 0;
             }
@@ -1547,14 +1569,14 @@ public:
         #else
         NoQuoteEntries &putSecurityGroup(const std::string& str)
         {
-            const size_t srcLength = str.length();
+            const std::size_t srcLength = str.length();
             if (srcLength > 6)
             {
                 throw std::runtime_error("string too large for putSecurityGroup [E106]");
             }
 
             std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength);
-            for (size_t start = srcLength; start < 6; ++start)
+            for (std::size_t start = srcLength; start < 6; ++start)
             {
                 m_buffer[m_offset + 0 + start] = 0;
             }
@@ -1563,7 +1585,7 @@ public:
         }
         #endif
 
-        SBE_NODISCARD static const char * SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -1602,17 +1624,17 @@ public:
 
         static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT
         {
-            return 2147483647;
+            return INT32_C(2147483647);
         }
 
         static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
         {
-            return -2147483647;
+            return INT32_C(-2147483647);
         }
 
         static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
         {
-            return 2147483647;
+            return INT32_C(2147483647);
         }
 
         static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -1661,13 +1683,13 @@ public:
             return true;
         }
 
-        SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+        SBE_NODISCARD static std::size_t computeLength()
         {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-            size_t length = sbeBlockLength();
+            std::size_t length = sbeBlockLength();
 
             return length;
 #if defined(__GNUG__) && !defined(__clang__)
@@ -1772,8 +1794,8 @@ public:
             m_buffer = buffer;
             m_bufferLength = bufferLength;
             GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
-            dimensions.blockLength((std::uint16_t)10);
-            dimensions.numInGroup((std::uint8_t)count);
+            dimensions.blockLength(static_cast<std::uint16_t>(10));
+            dimensions.numInGroup(static_cast<std::uint8_t>(count));
             m_index = 0;
             m_count = count;
             m_blockLength = 10;
@@ -1844,7 +1866,7 @@ public:
         {
             m_count = m_index;
             GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion);
-            dimensions.numInGroup((std::uint8_t)m_count);
+            dimensions.numInGroup(static_cast<std::uint8_t>(m_count));
             return m_count;
         }
 
@@ -1870,7 +1892,7 @@ public:
 
     #endif
 
-        SBE_NODISCARD static const char * BidSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *BidSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -1909,17 +1931,17 @@ public:
 
         static SBE_CONSTEXPR std::uint32_t bidSizeNullValue() SBE_NOEXCEPT
         {
-            return 4294967295;
+            return UINT32_C(0xffffffff);
         }
 
         static SBE_CONSTEXPR std::uint32_t bidSizeMinValue() SBE_NOEXCEPT
         {
-            return 0;
+            return UINT32_C(0x0);
         }
 
         static SBE_CONSTEXPR std::uint32_t bidSizeMaxValue() SBE_NOEXCEPT
         {
-            return 4294967294;
+            return UINT32_C(0xfffffffe);
         }
 
         static SBE_CONSTEXPR std::size_t bidSizeEncodingLength() SBE_NOEXCEPT
@@ -1941,7 +1963,7 @@ public:
             return *this;
         }
 
-        SBE_NODISCARD static const char * OfferSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *OfferSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -1980,17 +2002,17 @@ public:
 
         static SBE_CONSTEXPR std::uint32_t offerSizeNullValue() SBE_NOEXCEPT
         {
-            return 4294967295;
+            return UINT32_C(0xffffffff);
         }
 
         static SBE_CONSTEXPR std::uint32_t offerSizeMinValue() SBE_NOEXCEPT
         {
-            return 0;
+            return UINT32_C(0x0);
         }
 
         static SBE_CONSTEXPR std::uint32_t offerSizeMaxValue() SBE_NOEXCEPT
         {
-            return 4294967294;
+            return UINT32_C(0xfffffffe);
         }
 
         static SBE_CONSTEXPR std::size_t offerSizeEncodingLength() SBE_NOEXCEPT
@@ -2012,7 +2034,7 @@ public:
             return *this;
         }
 
-        SBE_NODISCARD static const char * QuoteSetIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
+        SBE_NODISCARD static const char *QuoteSetIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT
         {
             switch (metaAttribute)
             {
@@ -2056,12 +2078,12 @@ public:
 
         static SBE_CONSTEXPR std::uint16_t quoteSetIDMinValue() SBE_NOEXCEPT
         {
-            return (std::uint16_t)0;
+            return static_cast<std::uint16_t>(0);
         }
 
         static SBE_CONSTEXPR std::uint16_t quoteSetIDMaxValue() SBE_NOEXCEPT
         {
-            return (std::uint16_t)65534;
+            return static_cast<std::uint16_t>(65534);
         }
 
         static SBE_CONSTEXPR std::size_t quoteSetIDEncodingLength() SBE_NOEXCEPT
@@ -2113,13 +2135,13 @@ public:
             return true;
         }
 
-        SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength()
+        SBE_NODISCARD static std::size_t computeLength()
         {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-            size_t length = sbeBlockLength();
+            std::size_t length = sbeBlockLength();
 
             return length;
 #if defined(__GNUG__) && !defined(__clang__)
@@ -2269,30 +2291,30 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
     return false;
 }
 
-SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength(
-    std::size_t NoQuoteEntriesLength = 0,
-    std::size_t NoQuoteSetsLength = 0)
+SBE_NODISCARD static std::size_t computeLength(
+    std::size_t noQuoteEntriesLength = 0,
+    std::size_t noQuoteSetsLength = 0)
 {
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
-    size_t length = sbeBlockLength();
-
+    std::size_t length = sbeBlockLength();
 
     length += NoQuoteEntries::sbeHeaderSize();
-    if (NoQuoteEntriesLength > 254)
+    if (noQuoteEntriesLength > 254LL)
     {
-        throw std::runtime_error("NoQuoteEntriesLength outside of allowed range [E110]");
+        throw std::runtime_error("noQuoteEntriesLength outside of allowed range [E110]");
     }
-    length += NoQuoteEntriesLength * NoQuoteEntries::sbeBlockLength();
+    length += noQuoteEntriesLength *NoQuoteEntries::sbeBlockLength();
 
     length += NoQuoteSets::sbeHeaderSize();
-    if (NoQuoteSetsLength > 254)
+    if (noQuoteSetsLength > 254LL)
     {
-        throw std::runtime_error("NoQuoteSetsLength outside of allowed range [E110]");
+        throw std::runtime_error("noQuoteSetsLength outside of allowed range [E110]");
     }
-    length += NoQuoteSetsLength * NoQuoteSets::sbeBlockLength();
+    length += noQuoteSetsLength *NoQuoteSets::sbeBlockLength();
+
     return length;
 #if defined(__GNUG__) && !defined(__clang__)
 #pragma GCC diagnostic pop

src/lib/orderman/actors/ilink3/generated/QuoteCxlStatus.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,30 +94,30 @@ class QuoteCxlStatus
 public:
     enum Value
     {
-        CancelperInstrument = (std::uint8_t)1,
-        CancelperInstrumentgroup = (std::uint8_t)3,
-        Cancelallquotes = (std::uint8_t)4,
-        Rejected = (std::uint8_t)5,
-        CancelperQuoteSet = (std::uint8_t)100,
-        NULL_VALUE = (std::uint8_t)255
+        CancelperInstrument = static_cast<std::uint8_t>(1),
+        CancelperInstrumentgroup = static_cast<std::uint8_t>(3),
+        Cancelallquotes = static_cast<std::uint8_t>(4),
+        Rejected = static_cast<std::uint8_t>(5),
+        CancelperQuoteSet = static_cast<std::uint8_t>(100),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static QuoteCxlStatus::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 1: return CancelperInstrument;
-            case 3: return CancelperInstrumentgroup;
-            case 4: return Cancelallquotes;
-            case 5: return Rejected;
-            case 100: return CancelperQuoteSet;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(1): return CancelperInstrument;
+            case static_cast<std::uint8_t>(3): return CancelperInstrumentgroup;
+            case static_cast<std::uint8_t>(4): return Cancelallquotes;
+            case static_cast<std::uint8_t>(5): return Rejected;
+            case static_cast<std::uint8_t>(100): return CancelperQuoteSet;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum QuoteCxlStatus [E103]");
     }
 
-    static const char* c_str(const QuoteCxlStatus::Value value)
+    static const char *c_str(const QuoteCxlStatus::Value value)
     {
         switch (value)
         {

src/lib/orderman/actors/ilink3/generated/QuoteCxlTyp.h

@@ -22,12 +22,6 @@
 #  define SBE_NOEXCEPT
 #endif
 
-#if __cplusplus >= 201402L
-#  define SBE_CONSTEXPR_14 constexpr
-#else
-#  define SBE_CONSTEXPR_14
-#endif
-
 #if __cplusplus >= 201703L
 #  include <string_view>
 #  define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #if defined(WIN32) || defined(_WIN32)
 #  define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,28 +94,28 @@ class QuoteCxlTyp
 public:
     enum Value
     {
-        CancelperInstrument = (std::uint8_t)1,
-        CancelperInstrumentgroup = (std::uint8_t)3,
-        Cancelallquotes = (std::uint8_t)4,
-        CancelperQuoteSet = (std::uint8_t)100,
-        NULL_VALUE = (std::uint8_t)255
+        CancelperInstrument = static_cast<std::uint8_t>(1),
+        CancelperInstrumentgroup = static_cast<std::uint8_t>(3),
+        Cancelallquotes = static_cast<std::uint8_t>(4),
+        CancelperQuoteSet = static_cast<std::uint8_t>(100),
+        NULL_VALUE = static_cast<std::uint8_t>(255)
     };
 
     static QuoteCxlTyp::Value get(const std::uint8_t value)
     {
         switch (value)
         {
-            case 1: return CancelperInstrument;
-            case 3: return CancelperInstrumentgroup;
-            case 4: return Cancelallquotes;
-            case 100: return CancelperQuoteSet;
-            case 255: return NULL_VALUE;
+            case static_cast<std::uint8_t>(1): return CancelperInstrument;
+            case static_cast<std::uint8_t>(3): return CancelperInstrumentgroup;
+            case static_cast<std::uint8_t>(4): return Cancelallquotes;
+            case static_cast<std::uint8_t>(100): return CancelperQuoteSet;
+            case static_cast<std::uint8_t>(255): return NULL_VALUE;
         }
 
         throw std::runtime_error("unknown value for enum QuoteCxlTyp [E103]");
     }
 
-    static const char* c_str(const QuoteCxlTyp::Value value)
+    static const char *c_str(const QuoteCxlTyp::Value value)
     {
         switch (value)
         {