Compare commits

...
Author SHA1 Message Date
Pedro Pinto ef833c5705 Made uuid in jetfix configurable. 2021-04-06 13:21:27 -04:00
Pedro Pinto 44216afd51 Added to .gitignore 2021-04-06 13:14:27 -04:00
Pete Fisher cad407827d new keycode 2021-03-25 11:25:20 -04:00
Pete Fisher 9714135b7d cme schema update to v7 2021-03-25 10:33:41 -04:00
Pete Fisher c82e598313 updating submodule to latest 2021-03-18 17:18:52 -04:00
Pedro Pinto e7806d2fec Merge branch 'master' into prod 2020-09-16 16:28:36 -04:00
Taha Afzal c30bab899f Changing TASCounter to use the new formula 2020-07-29 09:43:00 -04:00
Taha Afzal 46544f36f1 Pyramid Algo now sends hedges for fills while a cancel is in flight 2020-07-23 13:13:52 -04:00
John Colvin c7df3ac43c Merge remote-tracking branch 'origin/csv_export' into prod 2020-07-22 10:44:58 -05:00
Jake Norbut 9d1b03d1e2 fixing merge 2020-03-04 11:51:05 -06:00
Jake Norbut 9a677cf980 merging master into csv_export; taking master 2020-03-04 11:50:56 -06:00
Jake Norbut 25445d58d0 refactoring TaS CSV export 2019-12-18 13:48:14 -06:00
Jake Norbut 0b313a8aa8 refactoring Fills CSV export 2019-12-18 13:47:36 -06:00
Jake Norbut 54f954fd4b adding CSV export to order book 2019-12-18 13:47:03 -06:00
Jake Norbut 980f38ba03 using OrderedDictionary to CSVs are output with a predictable column order 2019-12-18 13:46:22 -06:00
Jake Norbut 9eada2724b Having the Command be on the Window rather than the VM; nice thinking John 2019-12-18 10:11:10 -06:00
Jake Norbut b5f53ee918 adding csv_properties to TimeAndSalesVM.Row 2019-12-18 10:10:04 -06:00
Jake Norbut efc175f654 adding export to csv command to Fills window 2019-12-17 10:32:58 -06:00
Jake Norbut 6074afd999 adding csv export command to fills vm 2019-12-17 10:32:15 -06:00
Jake Norbut 219dff4055 adding new export_csv IDialogCommand which just creates a new file 2019-12-17 10:28:57 -06:00
Jake Norbut 9a3b07b622 adding ToCsv IEnumerable ext method in a new util namespace 2019-12-17 10:21:38 -06:00
124 changed files with 16910 additions and 6643 deletions

No files matched your search

+1
View File
@@ -37,3 +37,4 @@ trace_data/
*.rej *.rej
/build /build
.clangd/ .clangd/
/.cache/
@@ -1,6 +1,7 @@
using bts.api; using bts.api;
using bts.co2; using bts.co2;
using bts.utils; using bts.utils;
using bts.utils.csv;
using mbts; using mbts;
using mbts.spark; using mbts.spark;
using mbts.ui.controls; using mbts.ui.controls;
@@ -49,6 +50,18 @@ namespace bts.shell.time_and_sales {
public void raise_invalidated() => public void raise_invalidated() =>
invalidated?.Invoke(); 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) => public bool Equals(TimeAndSalesRowVM other) =>
other != null && other != null &&
row_key == other.row_key; row_key == other.row_key;
@@ -2,6 +2,7 @@
using bts.shell.fills; using bts.shell.fills;
using bts.spark; using bts.spark;
using bts.view; using bts.view;
using bts.utils.csv;
using mbts; using mbts;
using mbts.co2; using mbts.co2;
using mbts.persist; using mbts.persist;
@@ -124,6 +125,8 @@ namespace bts.shell.time_and_sales {
show_in_context_menu = _can_pause_updates show_in_context_menu = _can_pause_updates
}; };
_commands = new SparkCommand[] { _commands = new SparkCommand[] {
// csv export
new SparkCommandCommand("Export to csv", Icons.Export, FileDialogCommand.export_csv(() => _vm.rows.ToCsv(TimeAndSalesRowVM.csv_ordered_properties), "TaS")),
// ladder // ladder
SparkCommands.ShowLadderAutoLookup(SparkCommands.KeyGestures.ShowLadder) SparkCommands.ShowLadderAutoLookup(SparkCommands.KeyGestures.ShowLadder)
.complete(current_sec_key_src, sec_keys => sec_keys.Count > 0), .complete(current_sec_key_src, sec_keys => sec_keys.Count > 0),
@@ -5,6 +5,7 @@ using bts.collections;
using bts.shell.fills; using bts.shell.fills;
using bts.spark; using bts.spark;
using bts.utils; using bts.utils;
using bts.utils.csv;
using mbts.collections; using mbts.collections;
using mbts.persist; using mbts.persist;
using mbts.spark.filters; using mbts.spark.filters;
@@ -333,6 +334,27 @@ namespace mbts.spark {
public override bool Equals(object obj) => Equals(obj as Row); public override bool Equals(object obj) => Equals(obj as Row);
public override int GetHashCode() => _fill.FillKey.GetHashCode() ^ _order.Key.GetHashCode(); 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; public event Action invalidated;
void IRowVM.raise_invalidated() => invalidated?.Invoke(); void IRowVM.raise_invalidated() => invalidated?.Invoke();
} }
@@ -4,6 +4,7 @@ using bts.shell;
using bts.shell.fills; using bts.shell.fills;
using bts.spark; using bts.spark;
using bts.view; using bts.view;
using bts.utils.csv;
using mbts.persist; using mbts.persist;
using mbts.ui; using mbts.ui;
using mbts.ui.settings; using mbts.ui.settings;
@@ -61,6 +62,7 @@ namespace mbts.spark {
_view = new FillsView { DataContext = _vm }; _view = new FillsView { DataContext = _vm };
_commands = new List<SparkCommand> { _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 // 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(() => { SparkCommands.window_settings_command(new DialogCommand(() => {
var vm = new ShellSettingsDialogVM<GridSettings, SimpleGridSettingsVM>( var vm = new ShellSettingsDialogVM<GridSettings, SimpleGridSettingsVM>(
@@ -4,6 +4,7 @@ using bts.api.orderman;
using bts.collections; using bts.collections;
using bts.spark; using bts.spark;
using bts.utils; using bts.utils;
using bts.utils.csv;
using mbts.ui; using mbts.ui;
using mbts.ui.controls; using mbts.ui.controls;
using System; using System;
@@ -11,6 +12,7 @@ using System.Collections.Generic;
using System.ComponentModel; using System.ComponentModel;
using System.Reactive.Linq; using System.Reactive.Linq;
using System.Runtime.CompilerServices; using System.Runtime.CompilerServices;
using System.Linq;
using System.Windows.Input; using System.Windows.Input;
using System.Windows.Media; using System.Windows.Media;
using Columns = mbts.spark.OrderBookGridView.ColumnKeys; using Columns = mbts.spark.OrderBookGridView.ColumnKeys;
@@ -60,6 +62,35 @@ namespace mbts.spark {
public event Action<(OrderSecurityRootPair oldval, OrderSecurityRootPair newval)> updated; public event Action<(OrderSecurityRootPair oldval, OrderSecurityRootPair newval)> updated;
public event PropertyChangedEventHandler PropertyChanged; 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 // Core
public OrderSecurityRootPair order_tuple { get; private set; } public OrderSecurityRootPair order_tuple { get; private set; }
public OrderRecordImmutable order => order_tuple.order.order; public OrderRecordImmutable order => order_tuple.order.order;
@@ -6,6 +6,7 @@ using bts.shell.fills;
using bts.shell.orderbook; using bts.shell.orderbook;
using bts.spark; using bts.spark;
using bts.view; using bts.view;
using bts.utils.csv;
using mbts.persist; using mbts.persist;
using mbts.spark.utilities; using mbts.spark.utilities;
using mbts.ui; using mbts.ui;
@@ -231,6 +232,7 @@ namespace mbts.spark {
toggle_collapse_all_command, toggle_collapse_all_command,
toggle_expand_all_command, toggle_expand_all_command,
show_grid_settings_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 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.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)), hidden_cmd(new SparkCommandCommand(OrderBookView.CommandDescriptions.RevertOrders, null, _vm.revert_selected_orders_cmd, OrderBookView.KeyboardShortcuts.RevertOrders)),
@@ -64,6 +64,25 @@ namespace mbts.ui {
} }
}, can_execute == null ? null : new Func<object, bool>(_ => can_execute())); }, 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() { 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(); var rv = new TDialog();
if (!string.IsNullOrEmpty(initial_dir)) if (!string.IsNullOrEmpty(initial_dir))
+52
View File
@@ -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;
}
}
}
+4 -4
View File
@@ -1,10 +1,10 @@
#nusers: 1 #nusers: 100
#allow concurrent : true #allow concurrent : true
#expires: 2021-Jan-01 00:00:00 637450560000000000 #expires: 2022-Jun-01 00:00:00 637896384000000000
#generation_time: 2020-Apr-03 18:39:31.010863 5248901378137496534 #generation_time: 2021-Mar-25 15:21:51.824504 5249208843545632944
EncryptedKeyCode { EncryptedKeyCode {
value { value {
keycode: "BJBQWsbdTXWa/iLmOf3ekE8vP/NYkf0Q/nUsp/rJ78Ze3W9pNXICCMabmmsr1xOM7aqRIclPgZd955uSSfvFkdNWFTxwPQ5IfnDGopj3QdhUVxhzgVLaXHN+vC0H/MWrDQ5K4WY5J/6VXgUn1LSN/2HNb5iR2sKXeh3Alamg87YtCWEi+scelffE7HK5ERT/3A3Y/e0pqUFhP6xouIjHRhC2FRBb6OoJQVvFwVDADSuKZNo9B6GhC3H0YdHqjFhGDoky5ecgzeKIX8uWJEQNnQXQJ0iTgQ95+YR5IMU+XWdlVfSrc0fuTmj3YWcBQ8Kl2ItEcobyZzJYega3tu6Ftw==" keycode: "HdVz7cDRyofLl3vA8TPulaIHkquYzq24QTXThZccEpZkvk5mDF5dKkQa9fWG5JOWnswNZVfVct0bpHG99X3XHDTdhHyZy0xb+eEI4PS50vaHQGw3fHmFh/ku9EwLxMZZYCEnhelsg2LADjIG8ebqsgmVi6asHZo70nZCaIXzwu8KCjak/sD7K2EP5odhnRpPL4JdsSkgUAwmrr0V17pFxH1RmTS6pXYUvko3DTOIM8yudWabVlSrdmcsnCEzHN5WbZiMdPNEykhEdEtKM58TR9tVnk+JuDIU8uczEQsLK2tT1VVoleGLc5TM/p8jhWokkvr8WdbToIGaalhp72VG6g=="
} }
} }
+1
View File
@@ -88,6 +88,7 @@ message JetFIX {
optional uint32 max_connection_attempts = 346 [default=10]; optional uint32 max_connection_attempts = 346 [default=10];
optional bool auto_fix_seq_num = 347 [default=false]; optional bool auto_fix_seq_num = 347 [default=false];
optional bool use_ilink3 = 348 [default=false] ; optional bool use_ilink3 = 348 [default=false] ;
optional uint32 uuid_offset = 349 [default=0];
} }
repeated Connection connection = 10; repeated Connection connection = 10;
+8 -5
View File
@@ -129,11 +129,14 @@ SessionName session_name (config::JetFIX::Connection const &session_cfg)
if (session_cfg.has_start_day ()) { if (session_cfg.has_start_day ()) {
bts_assert (session_cfg.has_end_day ()); bts_assert (session_cfg.has_end_day ());
return session_name (now, auto sn =
parse_weekday (session_cfg.start_day ()), session_name (now,
parse_time (session_cfg.start_time ()), parse_weekday (session_cfg.start_day ()),
parse_weekday (session_cfg.end_day ()), parse_time (session_cfg.start_time ()),
parse_time (session_cfg.end_time ())); parse_weekday (session_cfg.end_day ()),
parse_time (session_cfg.end_time ()));
sn.as_uint64_t += session_cfg.uuid_offset();
return sn;
} else } else
return session_name (now, return session_name (now,
parse_time (session_cfg.start_time ()), parse_time (session_cfg.start_time ()),
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,26 +94,26 @@ class AvgPxInd
public: public:
enum Value enum Value
{ {
NoAveragePricing = (std::uint8_t)0, NoAveragePricing = static_cast<std::uint8_t>(0),
TradeispartofanAveragePriceGroupIdentifiedbytheAvgPxGrpID = (std::uint8_t)1, TradeispartofanAveragePriceGroupIdentifiedbytheAvgPxGrpID = static_cast<std::uint8_t>(1),
TradeispartofaNotionalValueAveragePriceGroup = (std::uint8_t)3, TradeispartofaNotionalValueAveragePriceGroup = static_cast<std::uint8_t>(3),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static AvgPxInd::Value get(const std::uint8_t value) static AvgPxInd::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 0: return NoAveragePricing; case static_cast<std::uint8_t>(0): return NoAveragePricing;
case 1: return TradeispartofanAveragePriceGroupIdentifiedbytheAvgPxGrpID; case static_cast<std::uint8_t>(1): return TradeispartofanAveragePriceGroupIdentifiedbytheAvgPxGrpID;
case 3: return TradeispartofaNotionalValueAveragePriceGroup; case static_cast<std::uint8_t>(3): return TradeispartofaNotionalValueAveragePriceGroup;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum AvgPxInd [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class BooleanFlag
public: public:
enum Value enum Value
{ {
False = (std::uint8_t)0, False = static_cast<std::uint8_t>(0),
True = (std::uint8_t)1, True = static_cast<std::uint8_t>(1),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static BooleanFlag::Value get(const std::uint8_t value) static BooleanFlag::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 0: return False; case static_cast<std::uint8_t>(0): return False;
case 1: return True; case static_cast<std::uint8_t>(1): return True;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum BooleanFlag [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class BooleanNULL
public: public:
enum Value enum Value
{ {
False = (std::uint8_t)0, False = static_cast<std::uint8_t>(0),
True = (std::uint8_t)1, True = static_cast<std::uint8_t>(1),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static BooleanNULL::Value get(const std::uint8_t value) static BooleanNULL::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 0: return False; case static_cast<std::uint8_t>(0): return False;
case 1: return True; case static_cast<std::uint8_t>(1): return True;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum BooleanNULL [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
BusinessReject521() = default; BusinessReject521() = default;
BusinessReject521( BusinessReject521(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "j";
} }
@@ -258,7 +260,7 @@ public:
BusinessReject521 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = BusinessReject521( return *this = BusinessReject521(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
BusinessReject521 skipper(m_buffer, m_offset, BusinessReject521 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -381,12 +382,12 @@ public:
static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -452,12 +453,12 @@ public:
static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -518,17 +519,17 @@ public:
static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT
@@ -582,7 +583,7 @@ public:
throw std::runtime_error("length too large for getText [E106]"); 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; return length;
} }
@@ -595,7 +596,7 @@ public:
SBE_NODISCARD std::string getTextAsString() const SBE_NODISCARD std::string getTextAsString() const
{ {
const char *buffer = m_buffer + m_offset + 12; const char *buffer = m_buffer + m_offset + 12;
size_t length = 0; std::size_t length = 0;
for (; length < 256 && *(buffer + length) != '\0'; ++length); for (; length < 256 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -640,7 +641,7 @@ public:
SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 12; const char *buffer = m_buffer + m_offset + 12;
size_t length = 0; std::size_t length = 0;
for (; length < 256 && *(buffer + length) != '\0'; ++length); for (; length < 256 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -652,14 +653,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
BusinessReject521 &putText(const std::string_view str) BusinessReject521 &putText(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 256) if (srcLength > 256)
{ {
throw std::runtime_error("string too large for putText [E106]"); throw std::runtime_error("string too large for putText [E106]");
} }
std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); 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; m_buffer[m_offset + 12 + start] = 0;
} }
@@ -669,14 +670,14 @@ public:
#else #else
BusinessReject521 &putText(const std::string& str) BusinessReject521 &putText(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 256) if (srcLength > 256)
{ {
throw std::runtime_error("string too large for putText [E106]"); throw std::runtime_error("string too large for putText [E106]");
} }
std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); 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; m_buffer[m_offset + 12 + start] = 0;
} }
@@ -685,7 +686,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -724,17 +725,17 @@ public:
static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -788,7 +789,7 @@ public:
throw std::runtime_error("length too large for getSenderID [E106]"); 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; return length;
} }
@@ -801,7 +802,7 @@ public:
SBE_NODISCARD std::string getSenderIDAsString() const SBE_NODISCARD std::string getSenderIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 268; const char *buffer = m_buffer + m_offset + 268;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -846,7 +847,7 @@ public:
SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 268; const char *buffer = m_buffer + m_offset + 268;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -858,14 +859,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
BusinessReject521 &putSenderID(const std::string_view str) BusinessReject521 &putSenderID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); 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; m_buffer[m_offset + 268 + start] = 0;
} }
@@ -875,14 +876,14 @@ public:
#else #else
BusinessReject521 &putSenderID(const std::string& str) BusinessReject521 &putSenderID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); 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; m_buffer[m_offset + 268 + start] = 0;
} }
@@ -891,7 +892,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -930,17 +931,17 @@ public:
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT
{ {
return 0xffffffffffffffffL; return UINT64_C(0xffffffffffffffff);
} }
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -962,7 +963,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1006,12 +1007,12 @@ public:
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1033,7 +1034,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1072,17 +1073,17 @@ public:
static SBE_CONSTEXPR std::uint64_t businessRejectRefIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t businessRejectRefIDNullValue() SBE_NOEXCEPT
{ {
return 0xffffffffffffffffL; return UINT64_C(0xffffffffffffffff);
} }
static SBE_CONSTEXPR std::uint64_t businessRejectRefIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t businessRejectRefIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t businessRejectRefIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t businessRejectRefIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t businessRejectRefIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t businessRejectRefIDEncodingLength() SBE_NOEXCEPT
@@ -1104,7 +1105,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1143,17 +1144,17 @@ public:
static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1207,7 +1208,7 @@ public:
throw std::runtime_error("length too large for getLocation [E106]"); 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; return length;
} }
@@ -1220,7 +1221,7 @@ public:
SBE_NODISCARD std::string getLocationAsString() const SBE_NODISCARD std::string getLocationAsString() const
{ {
const char *buffer = m_buffer + m_offset + 312; const char *buffer = m_buffer + m_offset + 312;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1265,7 +1266,7 @@ public:
SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 312; const char *buffer = m_buffer + m_offset + 312;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1277,14 +1278,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
BusinessReject521 &putLocation(const std::string_view str) BusinessReject521 &putLocation(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 312, str.data(), srcLength); 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; m_buffer[m_offset + 312 + start] = 0;
} }
@@ -1294,14 +1295,14 @@ public:
#else #else
BusinessReject521 &putLocation(const std::string& str) BusinessReject521 &putLocation(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 312, str.c_str(), srcLength); 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; m_buffer[m_offset + 312 + start] = 0;
} }
@@ -1310,7 +1311,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1349,17 +1350,17 @@ public:
static SBE_CONSTEXPR std::uint32_t refSeqNumNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t refSeqNumNullValue() SBE_NOEXCEPT
{ {
return 4294967295; return UINT32_C(0xffffffff);
} }
static SBE_CONSTEXPR std::uint32_t refSeqNumMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t refSeqNumMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t refSeqNumMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t refSeqNumMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t refSeqNumEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t refSeqNumEncodingLength() SBE_NOEXCEPT
@@ -1381,7 +1382,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1420,17 +1421,17 @@ public:
static SBE_CONSTEXPR std::uint16_t refTagIDNullValue() SBE_NOEXCEPT 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 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 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 static SBE_CONSTEXPR std::size_t refTagIDEncodingLength() SBE_NOEXCEPT
@@ -1452,7 +1453,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1496,12 +1497,12 @@ public:
static SBE_CONSTEXPR std::uint16_t businessRejectReasonMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t businessRejectReasonEncodingLength() SBE_NOEXCEPT
@@ -1523,7 +1524,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1562,17 +1563,17 @@ public:
static SBE_CONSTEXPR char refMsgTypeNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char refMsgTypeNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char refMsgTypeMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char refMsgTypeMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char refMsgTypeMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char refMsgTypeMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t refMsgTypeEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t refMsgTypeEncodingLength() SBE_NOEXCEPT
@@ -1626,7 +1627,7 @@ public:
throw std::runtime_error("length too large for getRefMsgType [E106]"); 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; return length;
} }
@@ -1651,7 +1652,7 @@ public:
SBE_NODISCARD std::string getRefMsgTypeAsString() const SBE_NODISCARD std::string getRefMsgTypeAsString() const
{ {
const char *buffer = m_buffer + m_offset + 325; const char *buffer = m_buffer + m_offset + 325;
size_t length = 0; std::size_t length = 0;
for (; length < 2 && *(buffer + length) != '\0'; ++length); for (; length < 2 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1696,7 +1697,7 @@ public:
SBE_NODISCARD std::string_view getRefMsgTypeAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getRefMsgTypeAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 325; const char *buffer = m_buffer + m_offset + 325;
size_t length = 0; std::size_t length = 0;
for (; length < 2 && *(buffer + length) != '\0'; ++length); for (; length < 2 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1708,14 +1709,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
BusinessReject521 &putRefMsgType(const std::string_view str) BusinessReject521 &putRefMsgType(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 2) if (srcLength > 2)
{ {
throw std::runtime_error("string too large for putRefMsgType [E106]"); throw std::runtime_error("string too large for putRefMsgType [E106]");
} }
std::memcpy(m_buffer + m_offset + 325, str.data(), srcLength); 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; m_buffer[m_offset + 325 + start] = 0;
} }
@@ -1725,14 +1726,14 @@ public:
#else #else
BusinessReject521 &putRefMsgType(const std::string& str) BusinessReject521 &putRefMsgType(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 2) if (srcLength > 2)
{ {
throw std::runtime_error("string too large for putRefMsgType [E106]"); throw std::runtime_error("string too large for putRefMsgType [E106]");
} }
std::memcpy(m_buffer + m_offset + 325, str.c_str(), srcLength); 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; m_buffer[m_offset + 325 + start] = 0;
} }
@@ -1741,7 +1742,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1783,7 +1784,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 327, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 327, sizeof(std::uint8_t));
@@ -1797,7 +1805,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1839,7 +1847,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 328, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 328, sizeof(std::uint8_t));
@@ -1853,7 +1868,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1895,7 +1910,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 329, sizeof(std::uint8_t)); 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; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class ClearingAcctType
public: public:
enum Value enum Value
{ {
Customer = (std::uint8_t)0, Customer = static_cast<std::uint8_t>(0),
Firm = (std::uint8_t)1, Firm = static_cast<std::uint8_t>(1),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static ClearingAcctType::Value get(const std::uint8_t value) static ClearingAcctType::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 0: return Customer; case static_cast<std::uint8_t>(0): return Customer;
case 1: return Firm; case static_cast<std::uint8_t>(1): return Firm;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum ClearingAcctType [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class CmtaGiveUpCD
public: public:
enum Value enum Value
{ {
GiveUp = (char)71, GiveUp = static_cast<char>(71),
SGXoffset = (char)83, SGXoffset = static_cast<char>(83),
NULL_VALUE = (char)0 NULL_VALUE = static_cast<char>(0)
}; };
static CmtaGiveUpCD::Value get(const char value) static CmtaGiveUpCD::Value get(const char value)
{ {
switch (value) switch (value)
{ {
case 71: return GiveUp; case static_cast<char>(71): return GiveUp;
case 83: return SGXoffset; case static_cast<char>(83): return SGXoffset;
case 0: return NULL_VALUE; case static_cast<char>(0): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum CmtaGiveUpCD [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,32 +94,32 @@ class CustOrdHandlInst
public: public:
enum Value enum Value
{ {
FCMprovidedscreen = (char)67, FCMprovidedscreen = static_cast<char>(67),
Otherprovidedscreen = (char)68, Otherprovidedscreen = static_cast<char>(68),
FCMAPIorFIX = (char)71, FCMAPIorFIX = static_cast<char>(71),
AlgoEngine = (char)72, AlgoEngine = static_cast<char>(72),
DeskElectronic = (char)87, DeskElectronic = static_cast<char>(87),
ClientElectronic = (char)89, ClientElectronic = static_cast<char>(89),
NULL_VALUE = (char)0 NULL_VALUE = static_cast<char>(0)
}; };
static CustOrdHandlInst::Value get(const char value) static CustOrdHandlInst::Value get(const char value)
{ {
switch (value) switch (value)
{ {
case 67: return FCMprovidedscreen; case static_cast<char>(67): return FCMprovidedscreen;
case 68: return Otherprovidedscreen; case static_cast<char>(68): return Otherprovidedscreen;
case 71: return FCMAPIorFIX; case static_cast<char>(71): return FCMAPIorFIX;
case 72: return AlgoEngine; case static_cast<char>(72): return AlgoEngine;
case 87: return DeskElectronic; case static_cast<char>(87): return DeskElectronic;
case 89: return ClientElectronic; case static_cast<char>(89): return ClientElectronic;
case 0: return NULL_VALUE; case static_cast<char>(0): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum CustOrdHandlInst [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,28 +94,28 @@ class CustOrderCapacity
public: public:
enum Value enum Value
{ {
Membertradingfortheirownaccount = (std::uint8_t)1, Membertradingfortheirownaccount = static_cast<std::uint8_t>(1),
Clearingfirmtradingforitsproprietaryaccount = (std::uint8_t)2, Clearingfirmtradingforitsproprietaryaccount = static_cast<std::uint8_t>(2),
Membertradingforanothermember = (std::uint8_t)3, Membertradingforanothermember = static_cast<std::uint8_t>(3),
Allother = (std::uint8_t)4, Allother = static_cast<std::uint8_t>(4),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static CustOrderCapacity::Value get(const std::uint8_t value) static CustOrderCapacity::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 1: return Membertradingfortheirownaccount; case static_cast<std::uint8_t>(1): return Membertradingfortheirownaccount;
case 2: return Clearingfirmtradingforitsproprietaryaccount; case static_cast<std::uint8_t>(2): return Clearingfirmtradingforitsproprietaryaccount;
case 3: return Membertradingforanothermember; case static_cast<std::uint8_t>(3): return Membertradingforanothermember;
case 4: return Allother; case static_cast<std::uint8_t>(4): return Allother;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum CustOrderCapacity [E103]"); 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) switch (value)
{ {
+12 -17
View File
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -172,12 +167,12 @@ public:
return m_offset; return m_offset;
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -194,15 +189,15 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT 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 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) switch (metaAttribute)
{ {
@@ -245,12 +240,12 @@ public:
static SBE_CONSTEXPR std::uint16_t lengthMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t lengthEncodingLength() SBE_NOEXCEPT
@@ -272,7 +267,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -310,17 +305,17 @@ public:
static SBE_CONSTEXPR char varDataNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char varDataNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char varDataMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char varDataMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char varDataMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char varDataMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t varDataEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t varDataEncodingLength() SBE_NOEXCEPT
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,36 +94,36 @@ class DKReason
public: public:
enum Value enum Value
{ {
UnknownSecurity = (char)65, UnknownSecurity = static_cast<char>(65),
WrongSide = (char)66, WrongSide = static_cast<char>(66),
QuantityExceedsOrder = (char)67, QuantityExceedsOrder = static_cast<char>(67),
NoMatchingOrder = (char)68, NoMatchingOrder = static_cast<char>(68),
PriceExceedsLimit = (char)69, PriceExceedsLimit = static_cast<char>(69),
CalculationDifference = (char)70, CalculationDifference = static_cast<char>(70),
NoMatchingExecutionReport = (char)71, NoMatchingExecutionReport = static_cast<char>(71),
Other = (char)90, Other = static_cast<char>(90),
NULL_VALUE = (char)0 NULL_VALUE = static_cast<char>(0)
}; };
static DKReason::Value get(const char value) static DKReason::Value get(const char value)
{ {
switch (value) switch (value)
{ {
case 65: return UnknownSecurity; case static_cast<char>(65): return UnknownSecurity;
case 66: return WrongSide; case static_cast<char>(66): return WrongSide;
case 67: return QuantityExceedsOrder; case static_cast<char>(67): return QuantityExceedsOrder;
case 68: return NoMatchingOrder; case static_cast<char>(68): return NoMatchingOrder;
case 69: return PriceExceedsLimit; case static_cast<char>(69): return PriceExceedsLimit;
case 70: return CalculationDifference; case static_cast<char>(70): return CalculationDifference;
case 71: return NoMatchingExecutionReport; case static_cast<char>(71): return NoMatchingExecutionReport;
case 90: return Other; case static_cast<char>(90): return Other;
case 0: return NULL_VALUE; case static_cast<char>(0): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum DKReason [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -172,12 +167,12 @@ public:
return m_offset; return m_offset;
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -194,15 +189,15 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT 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 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) switch (metaAttribute)
{ {
@@ -240,17 +235,17 @@ public:
static SBE_CONSTEXPR std::int32_t mantissaNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t mantissaNullValue() SBE_NOEXCEPT
{ {
return 2147483647; return INT32_C(2147483647);
} }
static SBE_CONSTEXPR std::int32_t mantissaMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t mantissaMinValue() SBE_NOEXCEPT
{ {
return -2147483647; return INT32_C(-2147483647);
} }
static SBE_CONSTEXPR std::int32_t mantissaMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t mantissaMaxValue() SBE_NOEXCEPT
{ {
return 2147483647; return INT32_C(2147483647);
} }
static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT
@@ -272,7 +267,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -310,17 +305,17 @@ public:
static SBE_CONSTEXPR std::int8_t exponentNullValue() SBE_NOEXCEPT 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 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 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 static SBE_CONSTEXPR std::size_t exponentEncodingLength() SBE_NOEXCEPT
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -172,12 +167,12 @@ public:
return m_offset; return m_offset;
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -194,15 +189,15 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT 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 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) switch (metaAttribute)
{ {
@@ -240,17 +235,17 @@ public:
static SBE_CONSTEXPR std::int64_t mantissaNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int64_t mantissaNullValue() SBE_NOEXCEPT
{ {
return 9223372036854775807L; return INT64_C(9223372036854775807);
} }
static SBE_CONSTEXPR std::int64_t mantissaMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int64_t mantissaMinValue() SBE_NOEXCEPT
{ {
return -9223372036854775807L; return INT64_C(-9223372036854775807);
} }
static SBE_CONSTEXPR std::int64_t mantissaMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int64_t mantissaMaxValue() SBE_NOEXCEPT
{ {
return 9223372036854775807L; return INT64_C(9223372036854775807);
} }
static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT
@@ -272,7 +267,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -310,17 +305,17 @@ public:
static SBE_CONSTEXPR std::int8_t exponentNullValue() SBE_NOEXCEPT 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 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 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 static SBE_CONSTEXPR std::size_t exponentEncodingLength() SBE_NOEXCEPT
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
Establish503() = default; Establish503() = default;
Establish503( Establish503(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "Establish";
} }
@@ -258,7 +260,7 @@ public:
Establish503 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = Establish503( return *this = Establish503(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
Establish503 skipper(m_buffer, m_offset, Establish503 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -376,17 +377,17 @@ public:
static SBE_CONSTEXPR char hMACVersionNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char hMACVersionNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char hMACVersionMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char hMACVersionMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char hMACVersionMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char hMACVersionMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t hMACVersionEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t hMACVersionEncodingLength() SBE_NOEXCEPT
@@ -401,14 +402,14 @@ public:
SBE_NODISCARD const char *hMACVersion() const 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; return (const char *)hMACVersionValues;
} }
SBE_NODISCARD char hMACVersion(const std::uint64_t index) const 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]; 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 }; 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::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; return bytesToCopy;
} }
@@ -462,7 +463,7 @@ public:
return oss.str(); 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) switch (metaAttribute)
{ {
@@ -501,17 +502,17 @@ public:
static SBE_CONSTEXPR char hMACSignatureNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char hMACSignatureNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char hMACSignatureMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char hMACSignatureMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char hMACSignatureMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char hMACSignatureMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t hMACSignatureEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t hMACSignatureEncodingLength() SBE_NOEXCEPT
@@ -565,7 +566,7 @@ public:
throw std::runtime_error("length too large for getHMACSignature [E106]"); 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; return length;
} }
@@ -578,7 +579,7 @@ public:
SBE_NODISCARD std::string getHMACSignatureAsString() const SBE_NODISCARD std::string getHMACSignatureAsString() const
{ {
const char *buffer = m_buffer + m_offset + 0; const char *buffer = m_buffer + m_offset + 0;
size_t length = 0; std::size_t length = 0;
for (; length < 32 && *(buffer + length) != '\0'; ++length); for (; length < 32 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -623,7 +624,7 @@ public:
SBE_NODISCARD std::string_view getHMACSignatureAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getHMACSignatureAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 0; const char *buffer = m_buffer + m_offset + 0;
size_t length = 0; std::size_t length = 0;
for (; length < 32 && *(buffer + length) != '\0'; ++length); for (; length < 32 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -635,14 +636,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
Establish503 &putHMACSignature(const std::string_view str) Establish503 &putHMACSignature(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 32) if (srcLength > 32)
{ {
throw std::runtime_error("string too large for putHMACSignature [E106]"); throw std::runtime_error("string too large for putHMACSignature [E106]");
} }
std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); 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; m_buffer[m_offset + 0 + start] = 0;
} }
@@ -652,14 +653,14 @@ public:
#else #else
Establish503 &putHMACSignature(const std::string& str) Establish503 &putHMACSignature(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 32) if (srcLength > 32)
{ {
throw std::runtime_error("string too large for putHMACSignature [E106]"); throw std::runtime_error("string too large for putHMACSignature [E106]");
} }
std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); 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; m_buffer[m_offset + 0 + start] = 0;
} }
@@ -668,7 +669,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -707,17 +708,17 @@ public:
static SBE_CONSTEXPR char accessKeyIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char accessKeyIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char accessKeyIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char accessKeyIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char accessKeyIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char accessKeyIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t accessKeyIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t accessKeyIDEncodingLength() SBE_NOEXCEPT
@@ -771,7 +772,7 @@ public:
throw std::runtime_error("length too large for getAccessKeyID [E106]"); 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; return length;
} }
@@ -784,7 +785,7 @@ public:
SBE_NODISCARD std::string getAccessKeyIDAsString() const SBE_NODISCARD std::string getAccessKeyIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 32; const char *buffer = m_buffer + m_offset + 32;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -829,7 +830,7 @@ public:
SBE_NODISCARD std::string_view getAccessKeyIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getAccessKeyIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 32; const char *buffer = m_buffer + m_offset + 32;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -841,14 +842,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
Establish503 &putAccessKeyID(const std::string_view str) Establish503 &putAccessKeyID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putAccessKeyID [E106]"); throw std::runtime_error("string too large for putAccessKeyID [E106]");
} }
std::memcpy(m_buffer + m_offset + 32, str.data(), srcLength); 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; m_buffer[m_offset + 32 + start] = 0;
} }
@@ -858,14 +859,14 @@ public:
#else #else
Establish503 &putAccessKeyID(const std::string& str) Establish503 &putAccessKeyID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putAccessKeyID [E106]"); throw std::runtime_error("string too large for putAccessKeyID [E106]");
} }
std::memcpy(m_buffer + m_offset + 32, str.c_str(), srcLength); 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; m_buffer[m_offset + 32 + start] = 0;
} }
@@ -874,7 +875,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -913,17 +914,17 @@ public:
static SBE_CONSTEXPR char tradingSystemNameNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char tradingSystemNameNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char tradingSystemNameMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char tradingSystemNameMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char tradingSystemNameMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char tradingSystemNameMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t tradingSystemNameEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t tradingSystemNameEncodingLength() SBE_NOEXCEPT
@@ -977,7 +978,7 @@ public:
throw std::runtime_error("length too large for getTradingSystemName [E106]"); 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; return length;
} }
@@ -990,7 +991,7 @@ public:
SBE_NODISCARD std::string getTradingSystemNameAsString() const SBE_NODISCARD std::string getTradingSystemNameAsString() const
{ {
const char *buffer = m_buffer + m_offset + 52; const char *buffer = m_buffer + m_offset + 52;
size_t length = 0; std::size_t length = 0;
for (; length < 30 && *(buffer + length) != '\0'; ++length); for (; length < 30 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1035,7 +1036,7 @@ public:
SBE_NODISCARD std::string_view getTradingSystemNameAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getTradingSystemNameAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 52; const char *buffer = m_buffer + m_offset + 52;
size_t length = 0; std::size_t length = 0;
for (; length < 30 && *(buffer + length) != '\0'; ++length); for (; length < 30 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1047,14 +1048,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
Establish503 &putTradingSystemName(const std::string_view str) Establish503 &putTradingSystemName(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 30) if (srcLength > 30)
{ {
throw std::runtime_error("string too large for putTradingSystemName [E106]"); throw std::runtime_error("string too large for putTradingSystemName [E106]");
} }
std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); 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; m_buffer[m_offset + 52 + start] = 0;
} }
@@ -1064,14 +1065,14 @@ public:
#else #else
Establish503 &putTradingSystemName(const std::string& str) Establish503 &putTradingSystemName(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 30) if (srcLength > 30)
{ {
throw std::runtime_error("string too large for putTradingSystemName [E106]"); throw std::runtime_error("string too large for putTradingSystemName [E106]");
} }
std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); 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; m_buffer[m_offset + 52 + start] = 0;
} }
@@ -1080,7 +1081,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1119,17 +1120,17 @@ public:
static SBE_CONSTEXPR char tradingSystemVersionNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char tradingSystemVersionNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char tradingSystemVersionMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char tradingSystemVersionMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char tradingSystemVersionMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char tradingSystemVersionMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t tradingSystemVersionEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t tradingSystemVersionEncodingLength() SBE_NOEXCEPT
@@ -1183,7 +1184,7 @@ public:
throw std::runtime_error("length too large for getTradingSystemVersion [E106]"); 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; return length;
} }
@@ -1196,7 +1197,7 @@ public:
SBE_NODISCARD std::string getTradingSystemVersionAsString() const SBE_NODISCARD std::string getTradingSystemVersionAsString() const
{ {
const char *buffer = m_buffer + m_offset + 82; const char *buffer = m_buffer + m_offset + 82;
size_t length = 0; std::size_t length = 0;
for (; length < 10 && *(buffer + length) != '\0'; ++length); for (; length < 10 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1241,7 +1242,7 @@ public:
SBE_NODISCARD std::string_view getTradingSystemVersionAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getTradingSystemVersionAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 82; const char *buffer = m_buffer + m_offset + 82;
size_t length = 0; std::size_t length = 0;
for (; length < 10 && *(buffer + length) != '\0'; ++length); for (; length < 10 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1253,14 +1254,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
Establish503 &putTradingSystemVersion(const std::string_view str) Establish503 &putTradingSystemVersion(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 10) if (srcLength > 10)
{ {
throw std::runtime_error("string too large for putTradingSystemVersion [E106]"); throw std::runtime_error("string too large for putTradingSystemVersion [E106]");
} }
std::memcpy(m_buffer + m_offset + 82, str.data(), srcLength); 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; m_buffer[m_offset + 82 + start] = 0;
} }
@@ -1270,14 +1271,14 @@ public:
#else #else
Establish503 &putTradingSystemVersion(const std::string& str) Establish503 &putTradingSystemVersion(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 10) if (srcLength > 10)
{ {
throw std::runtime_error("string too large for putTradingSystemVersion [E106]"); throw std::runtime_error("string too large for putTradingSystemVersion [E106]");
} }
std::memcpy(m_buffer + m_offset + 82, str.c_str(), srcLength); 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; m_buffer[m_offset + 82 + start] = 0;
} }
@@ -1286,7 +1287,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1325,17 +1326,17 @@ public:
static SBE_CONSTEXPR char tradingSystemVendorNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char tradingSystemVendorNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char tradingSystemVendorMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char tradingSystemVendorMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char tradingSystemVendorMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char tradingSystemVendorMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t tradingSystemVendorEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t tradingSystemVendorEncodingLength() SBE_NOEXCEPT
@@ -1389,7 +1390,7 @@ public:
throw std::runtime_error("length too large for getTradingSystemVendor [E106]"); 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; return length;
} }
@@ -1402,7 +1403,7 @@ public:
SBE_NODISCARD std::string getTradingSystemVendorAsString() const SBE_NODISCARD std::string getTradingSystemVendorAsString() const
{ {
const char *buffer = m_buffer + m_offset + 92; const char *buffer = m_buffer + m_offset + 92;
size_t length = 0; std::size_t length = 0;
for (; length < 10 && *(buffer + length) != '\0'; ++length); for (; length < 10 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1447,7 +1448,7 @@ public:
SBE_NODISCARD std::string_view getTradingSystemVendorAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getTradingSystemVendorAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 92; const char *buffer = m_buffer + m_offset + 92;
size_t length = 0; std::size_t length = 0;
for (; length < 10 && *(buffer + length) != '\0'; ++length); for (; length < 10 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1459,14 +1460,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
Establish503 &putTradingSystemVendor(const std::string_view str) Establish503 &putTradingSystemVendor(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 10) if (srcLength > 10)
{ {
throw std::runtime_error("string too large for putTradingSystemVendor [E106]"); throw std::runtime_error("string too large for putTradingSystemVendor [E106]");
} }
std::memcpy(m_buffer + m_offset + 92, str.data(), srcLength); 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; m_buffer[m_offset + 92 + start] = 0;
} }
@@ -1476,14 +1477,14 @@ public:
#else #else
Establish503 &putTradingSystemVendor(const std::string& str) Establish503 &putTradingSystemVendor(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 10) if (srcLength > 10)
{ {
throw std::runtime_error("string too large for putTradingSystemVendor [E106]"); throw std::runtime_error("string too large for putTradingSystemVendor [E106]");
} }
std::memcpy(m_buffer + m_offset + 92, str.c_str(), srcLength); 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; m_buffer[m_offset + 92 + start] = 0;
} }
@@ -1492,7 +1493,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1536,12 +1537,12 @@ public:
static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -1563,7 +1564,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1607,12 +1608,12 @@ public:
static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT
@@ -1634,7 +1635,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1678,12 +1679,12 @@ public:
static SBE_CONSTEXPR std::uint32_t nextSeqNoMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t nextSeqNoMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t nextSeqNoMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t nextSeqNoMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t nextSeqNoEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t nextSeqNoEncodingLength() SBE_NOEXCEPT
@@ -1705,7 +1706,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1744,17 +1745,17 @@ public:
static SBE_CONSTEXPR char sessionNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char sessionNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char sessionMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char sessionMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char sessionMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char sessionMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t sessionEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t sessionEncodingLength() SBE_NOEXCEPT
@@ -1808,7 +1809,7 @@ public:
throw std::runtime_error("length too large for getSession [E106]"); 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; return length;
} }
@@ -1836,7 +1837,7 @@ public:
SBE_NODISCARD std::string getSessionAsString() const SBE_NODISCARD std::string getSessionAsString() const
{ {
const char *buffer = m_buffer + m_offset + 122; const char *buffer = m_buffer + m_offset + 122;
size_t length = 0; std::size_t length = 0;
for (; length < 3 && *(buffer + length) != '\0'; ++length); for (; length < 3 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1881,7 +1882,7 @@ public:
SBE_NODISCARD std::string_view getSessionAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getSessionAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 122; const char *buffer = m_buffer + m_offset + 122;
size_t length = 0; std::size_t length = 0;
for (; length < 3 && *(buffer + length) != '\0'; ++length); for (; length < 3 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1893,14 +1894,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
Establish503 &putSession(const std::string_view str) Establish503 &putSession(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 3) if (srcLength > 3)
{ {
throw std::runtime_error("string too large for putSession [E106]"); throw std::runtime_error("string too large for putSession [E106]");
} }
std::memcpy(m_buffer + m_offset + 122, str.data(), srcLength); 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; m_buffer[m_offset + 122 + start] = 0;
} }
@@ -1910,14 +1911,14 @@ public:
#else #else
Establish503 &putSession(const std::string& str) Establish503 &putSession(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 3) if (srcLength > 3)
{ {
throw std::runtime_error("string too large for putSession [E106]"); throw std::runtime_error("string too large for putSession [E106]");
} }
std::memcpy(m_buffer + m_offset + 122, str.c_str(), srcLength); 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; m_buffer[m_offset + 122 + start] = 0;
} }
@@ -1926,7 +1927,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1965,17 +1966,17 @@ public:
static SBE_CONSTEXPR char firmNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char firmNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char firmMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char firmMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char firmMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char firmMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t firmEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t firmEncodingLength() SBE_NOEXCEPT
@@ -2029,7 +2030,7 @@ public:
throw std::runtime_error("length too large for getFirm [E106]"); 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; return length;
} }
@@ -2042,7 +2043,7 @@ public:
SBE_NODISCARD std::string getFirmAsString() const SBE_NODISCARD std::string getFirmAsString() const
{ {
const char *buffer = m_buffer + m_offset + 125; const char *buffer = m_buffer + m_offset + 125;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -2087,7 +2088,7 @@ public:
SBE_NODISCARD std::string_view getFirmAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getFirmAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 125; const char *buffer = m_buffer + m_offset + 125;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -2099,14 +2100,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
Establish503 &putFirm(const std::string_view str) Establish503 &putFirm(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putFirm [E106]"); throw std::runtime_error("string too large for putFirm [E106]");
} }
std::memcpy(m_buffer + m_offset + 125, str.data(), srcLength); 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; m_buffer[m_offset + 125 + start] = 0;
} }
@@ -2116,14 +2117,14 @@ public:
#else #else
Establish503 &putFirm(const std::string& str) Establish503 &putFirm(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putFirm [E106]"); throw std::runtime_error("string too large for putFirm [E106]");
} }
std::memcpy(m_buffer + m_offset + 125, str.c_str(), srcLength); 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; m_buffer[m_offset + 125 + start] = 0;
} }
@@ -2132,7 +2133,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -2176,12 +2177,12 @@ public:
static SBE_CONSTEXPR std::uint16_t keepAliveIntervalMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t keepAliveIntervalEncodingLength() SBE_NOEXCEPT
@@ -2203,7 +2204,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2283,7 +2284,7 @@ public:
std::uint64_t bytesToCopy = length < dataLength ? length : dataLength; std::uint64_t bytesToCopy = length < dataLength ? length : dataLength;
std::uint64_t pos = sbePosition(); std::uint64_t pos = sbePosition();
sbePosition(pos + dataLength); 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; return bytesToCopy;
} }
@@ -2372,7 +2373,8 @@ public:
{ {
throw std::runtime_error("std::string too long for length type [E109]"); 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 #if __cplusplus >= 201703L
Establish503 &putCredentials(const std::string_view str) Establish503 &putCredentials(const std::string_view str)
@@ -2381,7 +2383,8 @@ public:
{ {
throw std::runtime_error("std::string too long for length type [E109]"); 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 #endif
template<typename CharT, typename Traits> template<typename CharT, typename Traits>
@@ -2466,21 +2469,21 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
return false; 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__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
length += credentialsHeaderLength(); 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; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
EstablishmentAck504() = default; EstablishmentAck504() = default;
EstablishmentAck504( EstablishmentAck504(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "EstablishmentAck";
} }
@@ -258,7 +260,7 @@ public:
EstablishmentAck504 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = EstablishmentAck504( return *this = EstablishmentAck504(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
EstablishmentAck504 skipper(m_buffer, m_offset, EstablishmentAck504 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -381,12 +382,12 @@ public:
static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -452,12 +453,12 @@ public:
static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -523,12 +524,12 @@ public:
static SBE_CONSTEXPR std::uint32_t nextSeqNoMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t nextSeqNoMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t nextSeqNoMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t nextSeqNoMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t nextSeqNoEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t nextSeqNoEncodingLength() SBE_NOEXCEPT
@@ -550,7 +551,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -594,12 +595,12 @@ public:
static SBE_CONSTEXPR std::uint32_t previousSeqNoMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t previousSeqNoMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t previousSeqNoMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t previousSeqNoMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t previousSeqNoEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t previousSeqNoEncodingLength() SBE_NOEXCEPT
@@ -621,7 +622,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -665,12 +666,12 @@ public:
static SBE_CONSTEXPR std::uint64_t previousUUIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t previousUUIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t previousUUIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t previousUUIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t previousUUIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t previousUUIDEncodingLength() SBE_NOEXCEPT
@@ -692,7 +693,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -736,12 +737,12 @@ public:
static SBE_CONSTEXPR std::uint16_t keepAliveIntervalMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t keepAliveIntervalEncodingLength() SBE_NOEXCEPT
@@ -763,7 +764,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -802,17 +803,17 @@ public:
static SBE_CONSTEXPR std::uint16_t secretKeySecureIDExpirationNullValue() SBE_NOEXCEPT 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 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 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 static SBE_CONSTEXPR std::size_t secretKeySecureIDExpirationEncodingLength() SBE_NOEXCEPT
@@ -834,7 +835,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -876,7 +877,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 36, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 36, sizeof(std::uint8_t));
@@ -890,7 +898,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -932,7 +940,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 37, sizeof(std::uint8_t)); 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; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
EstablishmentReject505() = default; EstablishmentReject505() = default;
EstablishmentReject505( EstablishmentReject505(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "EstablishmentReject";
} }
@@ -258,7 +260,7 @@ public:
EstablishmentReject505 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = EstablishmentReject505( return *this = EstablishmentReject505(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
EstablishmentReject505 skipper(m_buffer, m_offset, EstablishmentReject505 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -376,17 +377,17 @@ public:
static SBE_CONSTEXPR char reasonNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char reasonNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char reasonMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char reasonMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char reasonMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char reasonMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t reasonEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t reasonEncodingLength() SBE_NOEXCEPT
@@ -440,7 +441,7 @@ public:
throw std::runtime_error("length too large for getReason [E106]"); 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; return length;
} }
@@ -453,7 +454,7 @@ public:
SBE_NODISCARD std::string getReasonAsString() const SBE_NODISCARD std::string getReasonAsString() const
{ {
const char *buffer = m_buffer + m_offset + 0; const char *buffer = m_buffer + m_offset + 0;
size_t length = 0; std::size_t length = 0;
for (; length < 48 && *(buffer + length) != '\0'; ++length); for (; length < 48 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -498,7 +499,7 @@ public:
SBE_NODISCARD std::string_view getReasonAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getReasonAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 0; const char *buffer = m_buffer + m_offset + 0;
size_t length = 0; std::size_t length = 0;
for (; length < 48 && *(buffer + length) != '\0'; ++length); for (; length < 48 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -510,14 +511,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
EstablishmentReject505 &putReason(const std::string_view str) EstablishmentReject505 &putReason(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 48) if (srcLength > 48)
{ {
throw std::runtime_error("string too large for putReason [E106]"); throw std::runtime_error("string too large for putReason [E106]");
} }
std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); 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; m_buffer[m_offset + 0 + start] = 0;
} }
@@ -527,14 +528,14 @@ public:
#else #else
EstablishmentReject505 &putReason(const std::string& str) EstablishmentReject505 &putReason(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 48) if (srcLength > 48)
{ {
throw std::runtime_error("string too large for putReason [E106]"); throw std::runtime_error("string too large for putReason [E106]");
} }
std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); 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; m_buffer[m_offset + 0 + start] = 0;
} }
@@ -543,7 +544,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -587,12 +588,12 @@ public:
static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -614,7 +615,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -658,12 +659,12 @@ public:
static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT
@@ -685,7 +686,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -729,12 +730,12 @@ public:
static SBE_CONSTEXPR std::uint32_t nextSeqNoMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t nextSeqNoMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t nextSeqNoMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t nextSeqNoMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t nextSeqNoEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t nextSeqNoEncodingLength() SBE_NOEXCEPT
@@ -756,7 +757,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -800,12 +801,12 @@ public:
static SBE_CONSTEXPR std::uint16_t errorCodesMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t errorCodesEncodingLength() SBE_NOEXCEPT
@@ -827,7 +828,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -869,7 +870,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 70, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 70, sizeof(std::uint8_t));
@@ -883,7 +891,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -925,7 +933,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 71, sizeof(std::uint8_t)); 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; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class ExecAckStatus
public: public:
enum Value enum Value
{ {
Accepted = (std::uint8_t)1, Accepted = static_cast<std::uint8_t>(1),
Rejected = (std::uint8_t)2, Rejected = static_cast<std::uint8_t>(2),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static ExecAckStatus::Value get(const std::uint8_t value) static ExecAckStatus::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 1: return Accepted; case static_cast<std::uint8_t>(1): return Accepted;
case 2: return Rejected; case static_cast<std::uint8_t>(2): return Rejected;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum ExecAckStatus [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -172,12 +167,12 @@ public:
return m_offset; return m_offset;
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -194,12 +189,12 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT 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 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() ExecInst &clear()
@@ -231,208 +226,208 @@ public:
static bool aON(const std::uint8_t bits) 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) 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 SBE_NODISCARD bool aON() const
{ {
std::uint8_t val; std::uint8_t val;
std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); 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) ExecInst &aON(const bool value)
{ {
std::uint8_t bits; std::uint8_t bits;
std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); 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)); std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t));
return *this; return *this;
} }
static bool oB(const std::uint8_t bits) 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) 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 SBE_NODISCARD bool oB() const
{ {
std::uint8_t val; std::uint8_t val;
std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); 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) ExecInst &oB(const bool value)
{ {
std::uint8_t bits; std::uint8_t bits;
std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); 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)); std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t));
return *this; return *this;
} }
static bool nH(const std::uint8_t bits) 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) 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 SBE_NODISCARD bool nH() const
{ {
std::uint8_t val; std::uint8_t val;
std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); 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) ExecInst &nH(const bool value)
{ {
std::uint8_t bits; std::uint8_t bits;
std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); 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)); std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t));
return *this; return *this;
} }
static bool reserved1(const std::uint8_t bits) 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) 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 SBE_NODISCARD bool reserved1() const
{ {
std::uint8_t val; std::uint8_t val;
std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); 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) ExecInst &reserved1(const bool value)
{ {
std::uint8_t bits; std::uint8_t bits;
std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); 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)); std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t));
return *this; return *this;
} }
static bool reserved2(const std::uint8_t bits) 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) 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 SBE_NODISCARD bool reserved2() const
{ {
std::uint8_t val; std::uint8_t val;
std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); 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) ExecInst &reserved2(const bool value)
{ {
std::uint8_t bits; std::uint8_t bits;
std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); 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)); std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t));
return *this; return *this;
} }
static bool reserved3(const std::uint8_t bits) 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) 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 SBE_NODISCARD bool reserved3() const
{ {
std::uint8_t val; std::uint8_t val;
std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); 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) ExecInst &reserved3(const bool value)
{ {
std::uint8_t bits; std::uint8_t bits;
std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); 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)); std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t));
return *this; return *this;
} }
static bool reserved4(const std::uint8_t bits) 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) 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 SBE_NODISCARD bool reserved4() const
{ {
std::uint8_t val; std::uint8_t val;
std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); 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) ExecInst &reserved4(const bool value)
{ {
std::uint8_t bits; std::uint8_t bits;
std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); 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)); std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t));
return *this; return *this;
} }
static bool reserved5(const std::uint8_t bits) 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) 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 SBE_NODISCARD bool reserved5() const
{ {
std::uint8_t val; std::uint8_t val;
std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); 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) ExecInst &reserved5(const bool value)
{ {
std::uint8_t bits; std::uint8_t bits;
std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); 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)); std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t));
return *this; return *this;
} }
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class ExecMode
public: public:
enum Value enum Value
{ {
Aggressive = (char)65, Aggressive = static_cast<char>(65),
Passive = (char)80, Passive = static_cast<char>(80),
NULL_VALUE = (char)0 NULL_VALUE = static_cast<char>(0)
}; };
static ExecMode::Value get(const char value) static ExecMode::Value get(const char value)
{ {
switch (value) switch (value)
{ {
case 65: return Aggressive; case static_cast<char>(65): return Aggressive;
case 80: return Passive; case static_cast<char>(80): return Passive;
case 0: return NULL_VALUE; case static_cast<char>(0): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum ExecMode [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,38 +94,38 @@ class ExecReason
public: public:
enum Value enum Value
{ {
MarketExchangeOption = (std::uint8_t)8, MarketExchangeOption = static_cast<std::uint8_t>(8),
CancelledNotBest = (std::uint8_t)9, CancelledNotBest = static_cast<std::uint8_t>(9),
CancelOnDisconnect = (std::uint8_t)100, CancelOnDisconnect = static_cast<std::uint8_t>(100),
SelfMatchPreventionOldestOrderCancelled = (std::uint8_t)103, SelfMatchPreventionOldestOrderCancelled = static_cast<std::uint8_t>(103),
CancelOnGlobexCreditControlsViolation = (std::uint8_t)104, CancelOnGlobexCreditControlsViolation = static_cast<std::uint8_t>(104),
CancelFromFirmsoft = (std::uint8_t)105, CancelFromFirmsoft = static_cast<std::uint8_t>(105),
CancelFromRiskManagementAPI = (std::uint8_t)106, CancelFromRiskManagementAPI = static_cast<std::uint8_t>(106),
SelfMatchPreventionNewestOrderCancelled = (std::uint8_t)107, SelfMatchPreventionNewestOrderCancelled = static_cast<std::uint8_t>(107),
Cancelduetovolquotedoptionorderrestedqtylessthanminordersize = (std::uint8_t)108, Cancelduetovolquotedoptionorderrestedqtylessthanminordersize = static_cast<std::uint8_t>(108),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static ExecReason::Value get(const std::uint8_t value) static ExecReason::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 8: return MarketExchangeOption; case static_cast<std::uint8_t>(8): return MarketExchangeOption;
case 9: return CancelledNotBest; case static_cast<std::uint8_t>(9): return CancelledNotBest;
case 100: return CancelOnDisconnect; case static_cast<std::uint8_t>(100): return CancelOnDisconnect;
case 103: return SelfMatchPreventionOldestOrderCancelled; case static_cast<std::uint8_t>(103): return SelfMatchPreventionOldestOrderCancelled;
case 104: return CancelOnGlobexCreditControlsViolation; case static_cast<std::uint8_t>(104): return CancelOnGlobexCreditControlsViolation;
case 105: return CancelFromFirmsoft; case static_cast<std::uint8_t>(105): return CancelFromFirmsoft;
case 106: return CancelFromRiskManagementAPI; case static_cast<std::uint8_t>(106): return CancelFromRiskManagementAPI;
case 107: return SelfMatchPreventionNewestOrderCancelled; case static_cast<std::uint8_t>(107): return SelfMatchPreventionNewestOrderCancelled;
case 108: return Cancelduetovolquotedoptionorderrestedqtylessthanminordersize; case static_cast<std::uint8_t>(108): return Cancelduetovolquotedoptionorderrestedqtylessthanminordersize;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum ExecReason [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class ExecTypTrdCxl
public: public:
enum Value enum Value
{ {
TradeCorrection = (char)71, TradeCorrection = static_cast<char>(71),
TradeCancel = (char)72, TradeCancel = static_cast<char>(72),
NULL_VALUE = (char)0 NULL_VALUE = static_cast<char>(0)
}; };
static ExecTypTrdCxl::Value get(const char value) static ExecTypTrdCxl::Value get(const char value)
{ {
switch (value) switch (value)
{ {
case 71: return TradeCorrection; case static_cast<char>(71): return TradeCorrection;
case 72: return TradeCancel; case static_cast<char>(72): return TradeCancel;
case 0: return NULL_VALUE; case static_cast<char>(0): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum ExecTypTrdCxl [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
ExecutionAck539() = default; ExecutionAck539() = default;
ExecutionAck539( ExecutionAck539(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "BN";
} }
@@ -258,7 +260,7 @@ public:
ExecutionAck539 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = ExecutionAck539( return *this = ExecutionAck539(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
ExecutionAck539 skipper(m_buffer, m_offset, ExecutionAck539 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -381,12 +382,12 @@ public:
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -452,12 +453,12 @@ public:
static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -521,7 +522,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -535,7 +543,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -579,12 +587,12 @@ public:
static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -606,7 +614,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -645,17 +653,17 @@ public:
static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT
@@ -709,7 +717,7 @@ public:
throw std::runtime_error("length too large for getClOrdID [E106]"); 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; return length;
} }
@@ -722,7 +730,7 @@ public:
SBE_NODISCARD std::string getClOrdIDAsString() const SBE_NODISCARD std::string getClOrdIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -767,7 +775,7 @@ public:
SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -779,14 +787,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
ExecutionAck539 &putClOrdID(const std::string_view str) ExecutionAck539 &putClOrdID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putClOrdID [E106]"); throw std::runtime_error("string too large for putClOrdID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -796,14 +804,14 @@ public:
#else #else
ExecutionAck539 &putClOrdID(const std::string& str) ExecutionAck539 &putClOrdID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putClOrdID [E106]"); throw std::runtime_error("string too large for putClOrdID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -812,7 +820,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -856,12 +864,12 @@ public:
static SBE_CONSTEXPR std::uint64_t secExecIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t secExecIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t secExecIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t secExecIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t secExecIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t secExecIDEncodingLength() SBE_NOEXCEPT
@@ -883,7 +891,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -930,7 +938,7 @@ public:
return m_lastPx; 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) switch (metaAttribute)
{ {
@@ -974,12 +982,12 @@ public:
static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
{ {
return -2147483647; return INT32_C(-2147483647);
} }
static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
{ {
return 2147483647; return INT32_C(2147483647);
} }
static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -1001,7 +1009,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1045,12 +1053,12 @@ public:
static SBE_CONSTEXPR std::uint32_t lastQtyMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t lastQtyMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t lastQtyMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t lastQtyMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT
@@ -1072,7 +1080,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1114,7 +1122,14 @@ public:
return 1; 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; char val;
std::memcpy(&val, m_buffer + m_offset + 65, sizeof(char)); std::memcpy(&val, m_buffer + m_offset + 65, sizeof(char));
@@ -1128,7 +1143,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1170,7 +1185,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t));
@@ -1184,7 +1206,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1223,17 +1245,17 @@ public:
static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -1275,7 +1297,7 @@ public:
if (m_actingVersion < 4) if (m_actingVersion < 4)
{ {
return (char)0; return static_cast<char>(0);
} }
char val; char val;
@@ -1307,7 +1329,7 @@ public:
return 0; 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; return length;
} }
@@ -1320,7 +1342,7 @@ public:
SBE_NODISCARD std::string getSenderIDAsString() const SBE_NODISCARD std::string getSenderIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 67; const char *buffer = m_buffer + m_offset + 67;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1365,7 +1387,7 @@ public:
SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 67; const char *buffer = m_buffer + m_offset + 67;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1377,14 +1399,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
ExecutionAck539 &putSenderID(const std::string_view str) ExecutionAck539 &putSenderID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 67, str.data(), srcLength); 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; m_buffer[m_offset + 67 + start] = 0;
} }
@@ -1394,14 +1416,14 @@ public:
#else #else
ExecutionAck539 &putSenderID(const std::string& str) ExecutionAck539 &putSenderID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 67, str.c_str(), srcLength); 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; m_buffer[m_offset + 67 + start] = 0;
} }
@@ -1410,7 +1432,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1454,12 +1476,12 @@ public:
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1471,7 +1493,7 @@ public:
{ {
if (m_actingVersion < 5) if (m_actingVersion < 5)
{ {
return 0xffffffffffffffffL; return UINT64_C(0xffffffffffffffff);
} }
std::uint64_t val; std::uint64_t val;
@@ -1486,7 +1508,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1525,17 +1547,17 @@ public:
static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1577,7 +1599,7 @@ public:
if (m_actingVersion < 5) if (m_actingVersion < 5)
{ {
return (char)0; return static_cast<char>(0);
} }
char val; char val;
@@ -1609,7 +1631,7 @@ public:
return 0; 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; return length;
} }
@@ -1622,7 +1644,7 @@ public:
SBE_NODISCARD std::string getLocationAsString() const SBE_NODISCARD std::string getLocationAsString() const
{ {
const char *buffer = m_buffer + m_offset + 95; const char *buffer = m_buffer + m_offset + 95;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1667,7 +1689,7 @@ public:
SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 95; const char *buffer = m_buffer + m_offset + 95;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1679,14 +1701,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
ExecutionAck539 &putLocation(const std::string_view str) ExecutionAck539 &putLocation(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 95, str.data(), srcLength); 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; m_buffer[m_offset + 95 + start] = 0;
} }
@@ -1696,14 +1718,14 @@ public:
#else #else
ExecutionAck539 &putLocation(const std::string& str) ExecutionAck539 &putLocation(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 95, str.c_str(), srcLength); 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; m_buffer[m_offset + 95 + start] = 0;
} }
@@ -1712,7 +1734,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1754,7 +1776,19 @@ public:
return 1; 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) if (m_actingVersion < 5)
{ {
@@ -1861,13 +1895,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
return true; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class ExpCycle
public: public:
enum Value enum Value
{ {
ExpireOnTradingSessionClose = (std::uint8_t)0, ExpireOnTradingSessionClose = static_cast<std::uint8_t>(0),
Expirationatgivendate = (std::uint8_t)2, Expirationatgivendate = static_cast<std::uint8_t>(2),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static ExpCycle::Value get(const std::uint8_t value) static ExpCycle::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 0: return ExpireOnTradingSessionClose; case static_cast<std::uint8_t>(0): return ExpireOnTradingSessionClose;
case 2: return Expirationatgivendate; case static_cast<std::uint8_t>(2): return Expirationatgivendate;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum ExpCycle [E103]"); 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) switch (value)
{ {
+8 -13
View File
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class FTI
public: public:
enum Value enum Value
{ {
Backup = (std::uint8_t)0, Backup = static_cast<std::uint8_t>(0),
Primary = (std::uint8_t)1, Primary = static_cast<std::uint8_t>(1),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static FTI::Value get(const std::uint8_t value) static FTI::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 0: return Backup; case static_cast<std::uint8_t>(0): return Backup;
case 1: return Primary; case static_cast<std::uint8_t>(1): return Primary;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum FTI [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -172,12 +167,12 @@ public:
return m_offset; return m_offset;
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -194,15 +189,15 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT 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 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) switch (metaAttribute)
{ {
@@ -245,12 +240,12 @@ public:
static SBE_CONSTEXPR std::uint16_t blockLengthMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t blockLengthEncodingLength() SBE_NOEXCEPT
@@ -272,7 +267,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -315,12 +310,12 @@ public:
static SBE_CONSTEXPR std::uint8_t numInGroupMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t numInGroupEncodingLength() SBE_NOEXCEPT
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class KeepAliveLapsed
public: public:
enum Value enum Value
{ {
NotLapsed = (std::uint8_t)0, NotLapsed = static_cast<std::uint8_t>(0),
Lapsed = (std::uint8_t)1, Lapsed = static_cast<std::uint8_t>(1),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static KeepAliveLapsed::Value get(const std::uint8_t value) static KeepAliveLapsed::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 0: return NotLapsed; case static_cast<std::uint8_t>(0): return NotLapsed;
case 1: return Lapsed; case static_cast<std::uint8_t>(1): return Lapsed;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum KeepAliveLapsed [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class ListUpdAct
public: public:
enum Value enum Value
{ {
Add = (char)65, Add = static_cast<char>(65),
Delete = (char)68, Delete = static_cast<char>(68),
NULL_VALUE = (char)0 NULL_VALUE = static_cast<char>(0)
}; };
static ListUpdAct::Value get(const char value) static ListUpdAct::Value get(const char value)
{ {
switch (value) switch (value)
{ {
case 65: return Add; case static_cast<char>(65): return Add;
case 68: return Delete; case static_cast<char>(68): return Delete;
case 0: return NULL_VALUE; case static_cast<char>(0): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum ListUpdAct [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class ManualOrdInd
public: public:
enum Value enum Value
{ {
Automated = (std::uint8_t)0, Automated = static_cast<std::uint8_t>(0),
Manual = (std::uint8_t)1, Manual = static_cast<std::uint8_t>(1),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static ManualOrdInd::Value get(const std::uint8_t value) static ManualOrdInd::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 0: return Automated; case static_cast<std::uint8_t>(0): return Automated;
case 1: return Manual; case static_cast<std::uint8_t>(1): return Manual;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum ManualOrdInd [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class ManualOrdIndReq
public: public:
enum Value enum Value
{ {
Automated = (std::uint8_t)0, Automated = static_cast<std::uint8_t>(0),
Manual = (std::uint8_t)1, Manual = static_cast<std::uint8_t>(1),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static ManualOrdIndReq::Value get(const std::uint8_t value) static ManualOrdIndReq::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 0: return Automated; case static_cast<std::uint8_t>(0): return Automated;
case 1: return Manual; case static_cast<std::uint8_t>(1): return Manual;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum ManualOrdIndReq [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class MassActionOrdTyp
public: public:
enum Value enum Value
{ {
Limit = (char)50, Limit = static_cast<char>(50),
StopLimit = (char)52, StopLimit = static_cast<char>(52),
NULL_VALUE = (char)0 NULL_VALUE = static_cast<char>(0)
}; };
static MassActionOrdTyp::Value get(const char value) static MassActionOrdTyp::Value get(const char value)
{ {
switch (value) switch (value)
{ {
case 50: return Limit; case static_cast<char>(50): return Limit;
case 52: return StopLimit; case static_cast<char>(52): return StopLimit;
case 0: return NULL_VALUE; case static_cast<char>(0): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum MassActionOrdTyp [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class MassActionResponse
public: public:
enum Value enum Value
{ {
Rejected = (std::uint8_t)0, Rejected = static_cast<std::uint8_t>(0),
Accepted = (std::uint8_t)1, Accepted = static_cast<std::uint8_t>(1),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static MassActionResponse::Value get(const std::uint8_t value) static MassActionResponse::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 0: return Rejected; case static_cast<std::uint8_t>(0): return Rejected;
case 1: return Accepted; case static_cast<std::uint8_t>(1): return Accepted;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum MassActionResponse [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,30 +94,30 @@ class MassActionScope
public: public:
enum Value enum Value
{ {
Instrument = (std::uint8_t)1, Instrument = static_cast<std::uint8_t>(1),
All = (std::uint8_t)7, All = static_cast<std::uint8_t>(7),
MarketSegmentID = (std::uint8_t)9, MarketSegmentID = static_cast<std::uint8_t>(9),
InstrumentGroup = (std::uint8_t)10, InstrumentGroup = static_cast<std::uint8_t>(10),
QuoteSetID = (std::uint8_t)100, QuoteSetID = static_cast<std::uint8_t>(100),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static MassActionScope::Value get(const std::uint8_t value) static MassActionScope::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 1: return Instrument; case static_cast<std::uint8_t>(1): return Instrument;
case 7: return All; case static_cast<std::uint8_t>(7): return All;
case 9: return MarketSegmentID; case static_cast<std::uint8_t>(9): return MarketSegmentID;
case 10: return InstrumentGroup; case static_cast<std::uint8_t>(10): return InstrumentGroup;
case 100: return QuoteSetID; case static_cast<std::uint8_t>(100): return QuoteSetID;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum MassActionScope [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,26 +94,26 @@ class MassCancelTIF
public: public:
enum Value enum Value
{ {
Day = (std::uint8_t)0, Day = static_cast<std::uint8_t>(0),
GoodTillCancel = (std::uint8_t)1, GoodTillCancel = static_cast<std::uint8_t>(1),
GoodTillDate = (std::uint8_t)6, GoodTillDate = static_cast<std::uint8_t>(6),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static MassCancelTIF::Value get(const std::uint8_t value) static MassCancelTIF::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 0: return Day; case static_cast<std::uint8_t>(0): return Day;
case 1: return GoodTillCancel; case static_cast<std::uint8_t>(1): return GoodTillCancel;
case 6: return GoodTillDate; case static_cast<std::uint8_t>(6): return GoodTillDate;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum MassCancelTIF [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class MassCxlReqTyp
public: public:
enum Value enum Value
{ {
SenderSubID = (std::uint8_t)100, SenderSubID = static_cast<std::uint8_t>(100),
Account = (std::uint8_t)101, Account = static_cast<std::uint8_t>(101),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static MassCxlReqTyp::Value get(const std::uint8_t value) static MassCxlReqTyp::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 100: return SenderSubID; case static_cast<std::uint8_t>(100): return SenderSubID;
case 101: return Account; case static_cast<std::uint8_t>(101): return Account;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum MassCxlReqTyp [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
MassQuote517() = default; MassQuote517() = default;
MassQuote517( MassQuote517(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "i";
} }
@@ -258,7 +260,7 @@ public:
MassQuote517 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = MassQuote517( return *this = MassQuote517(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
MassQuote517 skipper(m_buffer, m_offset, MassQuote517 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -381,12 +382,12 @@ public:
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -452,12 +453,12 @@ public:
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -521,7 +522,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -535,7 +543,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -579,12 +587,12 @@ public:
static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -606,7 +614,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -645,17 +653,17 @@ public:
static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -709,7 +717,7 @@ public:
throw std::runtime_error("length too large for getSenderID [E106]"); 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; return length;
} }
@@ -722,7 +730,7 @@ public:
SBE_NODISCARD std::string getSenderIDAsString() const SBE_NODISCARD std::string getSenderIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -767,7 +775,7 @@ public:
SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -779,14 +787,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
MassQuote517 &putSenderID(const std::string_view str) MassQuote517 &putSenderID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -796,14 +804,14 @@ public:
#else #else
MassQuote517 &putSenderID(const std::string& str) MassQuote517 &putSenderID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -812,7 +820,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -851,17 +859,17 @@ public:
static SBE_CONSTEXPR std::uint64_t quoteReqIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t quoteReqIDNullValue() SBE_NOEXCEPT
{ {
return 0xffffffffffffffffL; return UINT64_C(0xffffffffffffffff);
} }
static SBE_CONSTEXPR std::uint64_t quoteReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t quoteReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t quoteReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t quoteReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t quoteReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t quoteReqIDEncodingLength() SBE_NOEXCEPT
@@ -883,7 +891,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -922,17 +930,17 @@ public:
static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -986,7 +994,7 @@ public:
throw std::runtime_error("length too large for getLocation [E106]"); 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; return length;
} }
@@ -999,7 +1007,7 @@ public:
SBE_NODISCARD std::string getLocationAsString() const SBE_NODISCARD std::string getLocationAsString() const
{ {
const char *buffer = m_buffer + m_offset + 49; const char *buffer = m_buffer + m_offset + 49;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1044,7 +1052,7 @@ public:
SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 49; const char *buffer = m_buffer + m_offset + 49;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1056,14 +1064,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
MassQuote517 &putLocation(const std::string_view str) MassQuote517 &putLocation(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 49, str.data(), srcLength); 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; m_buffer[m_offset + 49 + start] = 0;
} }
@@ -1073,14 +1081,14 @@ public:
#else #else
MassQuote517 &putLocation(const std::string& str) MassQuote517 &putLocation(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 49, str.c_str(), srcLength); 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; m_buffer[m_offset + 49 + start] = 0;
} }
@@ -1089,7 +1097,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1133,12 +1141,12 @@ public:
static SBE_CONSTEXPR std::uint32_t quoteIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t quoteIDMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t quoteIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t quoteIDMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t quoteIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t quoteIDEncodingLength() SBE_NOEXCEPT
@@ -1160,7 +1168,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1204,12 +1212,12 @@ public:
static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t totNoQuoteEntriesEncodingLength() SBE_NOEXCEPT
@@ -1231,7 +1239,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1273,7 +1281,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 59, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 59, sizeof(std::uint8_t));
@@ -1287,7 +1302,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1329,7 +1344,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 60, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 60, sizeof(std::uint8_t));
@@ -1343,7 +1365,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1385,7 +1407,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 61, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 61, sizeof(std::uint8_t));
@@ -1399,7 +1428,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1438,17 +1467,17 @@ public:
static SBE_CONSTEXPR char reservedNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char reservedNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char reservedMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char reservedMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char reservedMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char reservedMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t reservedEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t reservedEncodingLength() SBE_NOEXCEPT
@@ -1490,7 +1519,7 @@ public:
if (m_actingVersion < 5) if (m_actingVersion < 5)
{ {
return (char)0; return static_cast<char>(0);
} }
char val; char val;
@@ -1522,7 +1551,7 @@ public:
return 0; 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; return length;
} }
@@ -1535,7 +1564,7 @@ public:
SBE_NODISCARD std::string getReservedAsString() const SBE_NODISCARD std::string getReservedAsString() const
{ {
const char *buffer = m_buffer + m_offset + 62; const char *buffer = m_buffer + m_offset + 62;
size_t length = 0; std::size_t length = 0;
for (; length < 30 && *(buffer + length) != '\0'; ++length); for (; length < 30 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1580,7 +1609,7 @@ public:
SBE_NODISCARD std::string_view getReservedAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getReservedAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 62; const char *buffer = m_buffer + m_offset + 62;
size_t length = 0; std::size_t length = 0;
for (; length < 30 && *(buffer + length) != '\0'; ++length); for (; length < 30 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1592,14 +1621,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
MassQuote517 &putReserved(const std::string_view str) MassQuote517 &putReserved(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 30) if (srcLength > 30)
{ {
throw std::runtime_error("string too large for putReserved [E106]"); throw std::runtime_error("string too large for putReserved [E106]");
} }
std::memcpy(m_buffer + m_offset + 62, str.data(), srcLength); 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; m_buffer[m_offset + 62 + start] = 0;
} }
@@ -1609,14 +1638,14 @@ public:
#else #else
MassQuote517 &putReserved(const std::string& str) MassQuote517 &putReserved(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 30) if (srcLength > 30)
{ {
throw std::runtime_error("string too large for putReserved [E106]"); throw std::runtime_error("string too large for putReserved [E106]");
} }
std::memcpy(m_buffer + m_offset + 62, str.c_str(), srcLength); 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; m_buffer[m_offset + 62 + start] = 0;
} }
@@ -1683,8 +1712,8 @@ public:
m_buffer = buffer; m_buffer = buffer;
m_bufferLength = bufferLength; m_bufferLength = bufferLength;
GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
dimensions.blockLength((std::uint16_t)38); dimensions.blockLength(static_cast<std::uint16_t>(38));
dimensions.numInGroup((std::uint8_t)count); dimensions.numInGroup(static_cast<std::uint8_t>(count));
m_index = 0; m_index = 0;
m_count = count; m_count = count;
m_blockLength = 38; m_blockLength = 38;
@@ -1755,7 +1784,7 @@ public:
{ {
m_count = m_index; m_count = m_index;
GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); 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; return m_count;
} }
@@ -1781,7 +1810,7 @@ public:
#endif #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) switch (metaAttribute)
{ {
@@ -1828,7 +1857,7 @@ public:
return m_bidPx; 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) switch (metaAttribute)
{ {
@@ -1875,7 +1904,7 @@ public:
return m_offerPx; 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) switch (metaAttribute)
{ {
@@ -1919,12 +1948,12 @@ public:
static SBE_CONSTEXPR std::uint32_t quoteEntryIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t quoteEntryIDMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t quoteEntryIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t quoteEntryIDMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t quoteEntryIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t quoteEntryIDEncodingLength() SBE_NOEXCEPT
@@ -1946,7 +1975,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1990,12 +2019,12 @@ public:
static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
{ {
return -2147483647; return INT32_C(-2147483647);
} }
static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
{ {
return 2147483647; return INT32_C(2147483647);
} }
static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -2017,7 +2046,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2056,17 +2085,17 @@ public:
static SBE_CONSTEXPR std::uint32_t bidSizeNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t bidSizeNullValue() SBE_NOEXCEPT
{ {
return 4294967295; return UINT32_C(0xffffffff);
} }
static SBE_CONSTEXPR std::uint32_t bidSizeMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t bidSizeMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t bidSizeMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t bidSizeMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t bidSizeEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t bidSizeEncodingLength() SBE_NOEXCEPT
@@ -2088,7 +2117,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2127,17 +2156,17 @@ public:
static SBE_CONSTEXPR std::uint32_t offerSizeNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t offerSizeNullValue() SBE_NOEXCEPT
{ {
return 4294967295; return UINT32_C(0xffffffff);
} }
static SBE_CONSTEXPR std::uint32_t offerSizeMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t offerSizeMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t offerSizeMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t offerSizeMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t offerSizeEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t offerSizeEncodingLength() SBE_NOEXCEPT
@@ -2159,7 +2188,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2198,17 +2227,17 @@ public:
static SBE_CONSTEXPR std::int32_t underlyingSecurityIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t underlyingSecurityIDNullValue() SBE_NOEXCEPT
{ {
return 2147483647; return INT32_C(2147483647);
} }
static SBE_CONSTEXPR std::int32_t underlyingSecurityIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t underlyingSecurityIDMinValue() SBE_NOEXCEPT
{ {
return -2147483647; return INT32_C(-2147483647);
} }
static SBE_CONSTEXPR std::int32_t underlyingSecurityIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t underlyingSecurityIDMaxValue() SBE_NOEXCEPT
{ {
return 2147483647; return INT32_C(2147483647);
} }
static SBE_CONSTEXPR std::size_t underlyingSecurityIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t underlyingSecurityIDEncodingLength() SBE_NOEXCEPT
@@ -2230,7 +2259,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2274,12 +2303,12 @@ public:
static SBE_CONSTEXPR std::uint16_t quoteSetIDMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t quoteSetIDEncodingLength() SBE_NOEXCEPT
@@ -2351,13 +2380,13 @@ public:
return true; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -2504,21 +2533,21 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
return false; 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__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
length += NoQuoteEntries::sbeHeaderSize(); 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; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
MassQuoteAck545() = default; MassQuoteAck545() = default;
MassQuoteAck545( MassQuoteAck545(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "b";
} }
@@ -258,7 +260,7 @@ public:
MassQuoteAck545 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = MassQuoteAck545( return *this = MassQuoteAck545(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
MassQuoteAck545 skipper(m_buffer, m_offset, MassQuoteAck545 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -381,12 +382,12 @@ public:
static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -452,12 +453,12 @@ public:
static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -518,17 +519,17 @@ public:
static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT
@@ -582,7 +583,7 @@ public:
throw std::runtime_error("length too large for getText [E106]"); 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; return length;
} }
@@ -595,7 +596,7 @@ public:
SBE_NODISCARD std::string getTextAsString() const SBE_NODISCARD std::string getTextAsString() const
{ {
const char *buffer = m_buffer + m_offset + 12; const char *buffer = m_buffer + m_offset + 12;
size_t length = 0; std::size_t length = 0;
for (; length < 256 && *(buffer + length) != '\0'; ++length); for (; length < 256 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -640,7 +641,7 @@ public:
SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 12; const char *buffer = m_buffer + m_offset + 12;
size_t length = 0; std::size_t length = 0;
for (; length < 256 && *(buffer + length) != '\0'; ++length); for (; length < 256 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -652,14 +653,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
MassQuoteAck545 &putText(const std::string_view str) MassQuoteAck545 &putText(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 256) if (srcLength > 256)
{ {
throw std::runtime_error("string too large for putText [E106]"); throw std::runtime_error("string too large for putText [E106]");
} }
std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); 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; m_buffer[m_offset + 12 + start] = 0;
} }
@@ -669,14 +670,14 @@ public:
#else #else
MassQuoteAck545 &putText(const std::string& str) MassQuoteAck545 &putText(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 256) if (srcLength > 256)
{ {
throw std::runtime_error("string too large for putText [E106]"); throw std::runtime_error("string too large for putText [E106]");
} }
std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); 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; m_buffer[m_offset + 12 + start] = 0;
} }
@@ -685,7 +686,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -724,17 +725,17 @@ public:
static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -788,7 +789,7 @@ public:
throw std::runtime_error("length too large for getSenderID [E106]"); 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; return length;
} }
@@ -801,7 +802,7 @@ public:
SBE_NODISCARD std::string getSenderIDAsString() const SBE_NODISCARD std::string getSenderIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 268; const char *buffer = m_buffer + m_offset + 268;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -846,7 +847,7 @@ public:
SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 268; const char *buffer = m_buffer + m_offset + 268;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -858,14 +859,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
MassQuoteAck545 &putSenderID(const std::string_view str) MassQuoteAck545 &putSenderID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); 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; m_buffer[m_offset + 268 + start] = 0;
} }
@@ -875,14 +876,14 @@ public:
#else #else
MassQuoteAck545 &putSenderID(const std::string& str) MassQuoteAck545 &putSenderID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); 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; m_buffer[m_offset + 268 + start] = 0;
} }
@@ -891,7 +892,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -935,12 +936,12 @@ public:
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -962,7 +963,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1006,12 +1007,12 @@ public:
static SBE_CONSTEXPR std::uint64_t requestTimeMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t requestTimeMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t requestTimeMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t requestTimeMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t requestTimeEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t requestTimeEncodingLength() SBE_NOEXCEPT
@@ -1033,7 +1034,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1077,12 +1078,12 @@ public:
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1104,7 +1105,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1143,17 +1144,17 @@ public:
static SBE_CONSTEXPR std::uint64_t quoteReqIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t quoteReqIDNullValue() SBE_NOEXCEPT
{ {
return 0xffffffffffffffffL; return UINT64_C(0xffffffffffffffff);
} }
static SBE_CONSTEXPR std::uint64_t quoteReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t quoteReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t quoteReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t quoteReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t quoteReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t quoteReqIDEncodingLength() SBE_NOEXCEPT
@@ -1175,7 +1176,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1214,17 +1215,17 @@ public:
static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1278,7 +1279,7 @@ public:
throw std::runtime_error("length too large for getLocation [E106]"); 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; return length;
} }
@@ -1291,7 +1292,7 @@ public:
SBE_NODISCARD std::string getLocationAsString() const SBE_NODISCARD std::string getLocationAsString() const
{ {
const char *buffer = m_buffer + m_offset + 320; const char *buffer = m_buffer + m_offset + 320;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1336,7 +1337,7 @@ public:
SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 320; const char *buffer = m_buffer + m_offset + 320;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1348,14 +1349,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
MassQuoteAck545 &putLocation(const std::string_view str) MassQuoteAck545 &putLocation(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 320, str.data(), srcLength); 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; m_buffer[m_offset + 320 + start] = 0;
} }
@@ -1365,14 +1366,14 @@ public:
#else #else
MassQuoteAck545 &putLocation(const std::string& str) MassQuoteAck545 &putLocation(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 320, str.c_str(), srcLength); 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; m_buffer[m_offset + 320 + start] = 0;
} }
@@ -1381,7 +1382,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1425,12 +1426,12 @@ public:
static SBE_CONSTEXPR std::uint32_t quoteIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t quoteIDMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t quoteIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t quoteIDMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t quoteIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t quoteIDEncodingLength() SBE_NOEXCEPT
@@ -1452,7 +1453,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1491,17 +1492,17 @@ public:
static SBE_CONSTEXPR std::uint16_t quoteRejectReasonNullValue() SBE_NOEXCEPT 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 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 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 static SBE_CONSTEXPR std::size_t quoteRejectReasonEncodingLength() SBE_NOEXCEPT
@@ -1523,7 +1524,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1562,17 +1563,17 @@ public:
static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT 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 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 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 static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT
@@ -1594,7 +1595,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1636,7 +1637,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 333, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 333, sizeof(std::uint8_t));
@@ -1650,7 +1658,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1692,7 +1700,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 334, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 334, sizeof(std::uint8_t));
@@ -1706,7 +1721,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1750,12 +1765,12 @@ public:
static SBE_CONSTEXPR std::uint8_t noProcessedEntriesMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t noProcessedEntriesEncodingLength() SBE_NOEXCEPT
@@ -1777,7 +1792,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1819,7 +1834,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 336, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 336, sizeof(std::uint8_t));
@@ -1833,7 +1855,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1875,7 +1897,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 337, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 337, sizeof(std::uint8_t));
@@ -1889,7 +1918,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1931,7 +1960,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 338, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 338, sizeof(std::uint8_t));
@@ -1945,7 +1981,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1987,7 +2023,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 339, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 339, sizeof(std::uint8_t));
@@ -2001,7 +2044,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2040,17 +2083,17 @@ public:
static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesNullValue() SBE_NOEXCEPT 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 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 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 static SBE_CONSTEXPR std::size_t totNoQuoteEntriesEncodingLength() SBE_NOEXCEPT
@@ -2072,7 +2115,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2114,7 +2157,19 @@ public:
return 1; 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) if (m_actingVersion < 2)
{ {
@@ -2133,7 +2188,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2172,17 +2227,17 @@ public:
static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT
{ {
return 0xffffffffffffffffL; return UINT64_C(0xffffffffffffffff);
} }
static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT
@@ -2194,7 +2249,7 @@ public:
{ {
if (m_actingVersion < 4) if (m_actingVersion < 4)
{ {
return 0xffffffffffffffffL; return UINT64_C(0xffffffffffffffff);
} }
std::uint64_t val; std::uint64_t val;
@@ -2267,8 +2322,8 @@ public:
m_buffer = buffer; m_buffer = buffer;
m_bufferLength = bufferLength; m_bufferLength = bufferLength;
GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
dimensions.blockLength((std::uint16_t)11); dimensions.blockLength(static_cast<std::uint16_t>(11));
dimensions.numInGroup((std::uint8_t)count); dimensions.numInGroup(static_cast<std::uint8_t>(count));
m_index = 0; m_index = 0;
m_count = count; m_count = count;
m_blockLength = 11; m_blockLength = 11;
@@ -2339,7 +2394,7 @@ public:
{ {
m_count = m_index; m_count = m_index;
GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); 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; return m_count;
} }
@@ -2365,7 +2420,7 @@ public:
#endif #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) switch (metaAttribute)
{ {
@@ -2409,12 +2464,12 @@ public:
static SBE_CONSTEXPR std::uint32_t quoteEntryIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t quoteEntryIDMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t quoteEntryIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t quoteEntryIDMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t quoteEntryIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t quoteEntryIDEncodingLength() SBE_NOEXCEPT
@@ -2436,7 +2491,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2480,12 +2535,12 @@ public:
static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
{ {
return -2147483647; return INT32_C(-2147483647);
} }
static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
{ {
return 2147483647; return INT32_C(2147483647);
} }
static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -2507,7 +2562,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2551,12 +2606,12 @@ public:
static SBE_CONSTEXPR std::uint16_t quoteSetIDMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t quoteSetIDEncodingLength() SBE_NOEXCEPT
@@ -2578,7 +2633,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2622,12 +2677,12 @@ public:
static SBE_CONSTEXPR std::uint8_t quoteEntryRejectReasonMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t quoteEntryRejectReasonEncodingLength() SBE_NOEXCEPT
@@ -2683,13 +2738,13 @@ public:
return true; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -2872,21 +2927,21 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
return false; 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__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
length += NoQuoteEntries::sbeHeaderSize(); 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; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class MassStatusOrdTyp
public: public:
enum Value enum Value
{ {
SenderSubID = (std::uint8_t)100, SenderSubID = static_cast<std::uint8_t>(100),
Account = (std::uint8_t)101, Account = static_cast<std::uint8_t>(101),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static MassStatusOrdTyp::Value get(const std::uint8_t value) static MassStatusOrdTyp::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 100: return SenderSubID; case static_cast<std::uint8_t>(100): return SenderSubID;
case 101: return Account; case static_cast<std::uint8_t>(101): return Account;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum MassStatusOrdTyp [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,26 +94,26 @@ class MassStatusReqTyp
public: public:
enum Value enum Value
{ {
Instrument = (std::uint8_t)1, Instrument = static_cast<std::uint8_t>(1),
InstrumentGroup = (std::uint8_t)3, InstrumentGroup = static_cast<std::uint8_t>(3),
MarketSegment = (std::uint8_t)100, MarketSegment = static_cast<std::uint8_t>(100),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static MassStatusReqTyp::Value get(const std::uint8_t value) static MassStatusReqTyp::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 1: return Instrument; case static_cast<std::uint8_t>(1): return Instrument;
case 3: return InstrumentGroup; case static_cast<std::uint8_t>(3): return InstrumentGroup;
case 100: return MarketSegment; case static_cast<std::uint8_t>(100): return MarketSegment;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum MassStatusReqTyp [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,32 +94,35 @@ class MassStatusTIF
public: public:
enum Value enum Value
{ {
Day = (std::uint8_t)0, Day = static_cast<std::uint8_t>(0),
GTC = (std::uint8_t)1, GTC = static_cast<std::uint8_t>(1),
GTD = (std::uint8_t)6, GTD = static_cast<std::uint8_t>(6),
NULL_VALUE = (std::uint8_t)255 GFS = static_cast<std::uint8_t>(99),
NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static MassStatusTIF::Value get(const std::uint8_t value) static MassStatusTIF::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 0: return Day; case static_cast<std::uint8_t>(0): return Day;
case 1: return GTC; case static_cast<std::uint8_t>(1): return GTC;
case 6: return GTD; case static_cast<std::uint8_t>(6): return GTD;
case 255: return NULL_VALUE; 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]"); 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) switch (value)
{ {
case Day: return "Day"; case Day: return "Day";
case GTC: return "GTC"; case GTC: return "GTC";
case GTD: return "GTD"; case GTD: return "GTD";
case GFS: return "GFS";
case NULL_VALUE: return "NULL_VALUE"; case NULL_VALUE: return "NULL_VALUE";
} }
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -172,12 +167,12 @@ public:
return m_offset; return m_offset;
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -194,15 +189,15 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT 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 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) switch (metaAttribute)
{ {
@@ -240,17 +235,17 @@ public:
static SBE_CONSTEXPR std::uint16_t yearNullValue() SBE_NOEXCEPT 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 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 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 static SBE_CONSTEXPR std::size_t yearEncodingLength() SBE_NOEXCEPT
@@ -272,7 +267,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -310,17 +305,17 @@ public:
static SBE_CONSTEXPR std::uint8_t monthNullValue() SBE_NOEXCEPT 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 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 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 static SBE_CONSTEXPR std::size_t monthEncodingLength() SBE_NOEXCEPT
@@ -342,7 +337,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -380,17 +375,17 @@ public:
static SBE_CONSTEXPR std::uint8_t dayNullValue() SBE_NOEXCEPT 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 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 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 static SBE_CONSTEXPR std::size_t dayEncodingLength() SBE_NOEXCEPT
@@ -412,7 +407,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -450,17 +445,17 @@ public:
static SBE_CONSTEXPR std::uint8_t weekNullValue() SBE_NOEXCEPT 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 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 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 static SBE_CONSTEXPR std::size_t weekEncodingLength() SBE_NOEXCEPT
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -172,12 +167,12 @@ public:
return m_offset; return m_offset;
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -194,15 +189,15 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT 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 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) switch (metaAttribute)
{ {
@@ -245,12 +240,12 @@ public:
static SBE_CONSTEXPR std::uint16_t blockLengthMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t blockLengthEncodingLength() SBE_NOEXCEPT
@@ -272,7 +267,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -315,12 +310,12 @@ public:
static SBE_CONSTEXPR std::uint16_t templateIdMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t templateIdEncodingLength() SBE_NOEXCEPT
@@ -342,7 +337,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -385,12 +380,12 @@ public:
static SBE_CONSTEXPR std::uint16_t schemaIdMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t schemaIdEncodingLength() SBE_NOEXCEPT
@@ -412,7 +407,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -455,12 +450,12 @@ public:
static SBE_CONSTEXPR std::uint16_t versionMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t versionEncodingLength() SBE_NOEXCEPT
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
Negotiate500() = default; Negotiate500() = default;
Negotiate500( Negotiate500(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "Negotiate";
} }
@@ -258,7 +260,7 @@ public:
Negotiate500 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = Negotiate500( return *this = Negotiate500(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
Negotiate500 skipper(m_buffer, m_offset, Negotiate500 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -376,17 +377,17 @@ public:
static SBE_CONSTEXPR char customerFlowNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char customerFlowNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char customerFlowMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char customerFlowMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char customerFlowMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char customerFlowMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t customerFlowEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t customerFlowEncodingLength() SBE_NOEXCEPT
@@ -401,14 +402,14 @@ public:
SBE_NODISCARD const char *customerFlow() const 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; return (const char *)customerFlowValues;
} }
SBE_NODISCARD char customerFlow(const std::uint64_t index) const 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]; return (char)customerFlowValues[index];
} }
@@ -418,7 +419,7 @@ public:
static std::uint8_t customerFlowValues[] = { 73, 68, 69, 77, 80, 79, 84, 69, 78, 84 }; 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::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; return bytesToCopy;
} }
@@ -462,7 +463,7 @@ public:
return oss.str(); 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) switch (metaAttribute)
{ {
@@ -501,17 +502,17 @@ public:
static SBE_CONSTEXPR char hMACVersionNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char hMACVersionNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char hMACVersionMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char hMACVersionMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char hMACVersionMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char hMACVersionMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t hMACVersionEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t hMACVersionEncodingLength() SBE_NOEXCEPT
@@ -526,14 +527,14 @@ public:
SBE_NODISCARD const char *hMACVersion() const 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; return (const char *)hMACVersionValues;
} }
SBE_NODISCARD char hMACVersion(const std::uint64_t index) const 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]; 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 }; 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::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; return bytesToCopy;
} }
@@ -587,7 +588,7 @@ public:
return oss.str(); 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) switch (metaAttribute)
{ {
@@ -626,17 +627,17 @@ public:
static SBE_CONSTEXPR char hMACSignatureNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char hMACSignatureNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char hMACSignatureMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char hMACSignatureMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char hMACSignatureMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char hMACSignatureMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t hMACSignatureEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t hMACSignatureEncodingLength() SBE_NOEXCEPT
@@ -690,7 +691,7 @@ public:
throw std::runtime_error("length too large for getHMACSignature [E106]"); 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; return length;
} }
@@ -703,7 +704,7 @@ public:
SBE_NODISCARD std::string getHMACSignatureAsString() const SBE_NODISCARD std::string getHMACSignatureAsString() const
{ {
const char *buffer = m_buffer + m_offset + 0; const char *buffer = m_buffer + m_offset + 0;
size_t length = 0; std::size_t length = 0;
for (; length < 32 && *(buffer + length) != '\0'; ++length); for (; length < 32 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -748,7 +749,7 @@ public:
SBE_NODISCARD std::string_view getHMACSignatureAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getHMACSignatureAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 0; const char *buffer = m_buffer + m_offset + 0;
size_t length = 0; std::size_t length = 0;
for (; length < 32 && *(buffer + length) != '\0'; ++length); for (; length < 32 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -760,14 +761,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
Negotiate500 &putHMACSignature(const std::string_view str) Negotiate500 &putHMACSignature(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 32) if (srcLength > 32)
{ {
throw std::runtime_error("string too large for putHMACSignature [E106]"); throw std::runtime_error("string too large for putHMACSignature [E106]");
} }
std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); 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; m_buffer[m_offset + 0 + start] = 0;
} }
@@ -777,14 +778,14 @@ public:
#else #else
Negotiate500 &putHMACSignature(const std::string& str) Negotiate500 &putHMACSignature(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 32) if (srcLength > 32)
{ {
throw std::runtime_error("string too large for putHMACSignature [E106]"); throw std::runtime_error("string too large for putHMACSignature [E106]");
} }
std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); 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; m_buffer[m_offset + 0 + start] = 0;
} }
@@ -793,7 +794,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -832,17 +833,17 @@ public:
static SBE_CONSTEXPR char accessKeyIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char accessKeyIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char accessKeyIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char accessKeyIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char accessKeyIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char accessKeyIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t accessKeyIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t accessKeyIDEncodingLength() SBE_NOEXCEPT
@@ -896,7 +897,7 @@ public:
throw std::runtime_error("length too large for getAccessKeyID [E106]"); 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; return length;
} }
@@ -909,7 +910,7 @@ public:
SBE_NODISCARD std::string getAccessKeyIDAsString() const SBE_NODISCARD std::string getAccessKeyIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 32; const char *buffer = m_buffer + m_offset + 32;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -954,7 +955,7 @@ public:
SBE_NODISCARD std::string_view getAccessKeyIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getAccessKeyIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 32; const char *buffer = m_buffer + m_offset + 32;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -966,14 +967,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
Negotiate500 &putAccessKeyID(const std::string_view str) Negotiate500 &putAccessKeyID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putAccessKeyID [E106]"); throw std::runtime_error("string too large for putAccessKeyID [E106]");
} }
std::memcpy(m_buffer + m_offset + 32, str.data(), srcLength); 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; m_buffer[m_offset + 32 + start] = 0;
} }
@@ -983,14 +984,14 @@ public:
#else #else
Negotiate500 &putAccessKeyID(const std::string& str) Negotiate500 &putAccessKeyID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putAccessKeyID [E106]"); throw std::runtime_error("string too large for putAccessKeyID [E106]");
} }
std::memcpy(m_buffer + m_offset + 32, str.c_str(), srcLength); 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; m_buffer[m_offset + 32 + start] = 0;
} }
@@ -999,7 +1000,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1043,12 +1044,12 @@ public:
static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -1070,7 +1071,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1114,12 +1115,12 @@ public:
static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT
@@ -1141,7 +1142,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1180,17 +1181,17 @@ public:
static SBE_CONSTEXPR char sessionNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char sessionNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char sessionMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char sessionMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char sessionMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char sessionMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t sessionEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t sessionEncodingLength() SBE_NOEXCEPT
@@ -1244,7 +1245,7 @@ public:
throw std::runtime_error("length too large for getSession [E106]"); 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; return length;
} }
@@ -1272,7 +1273,7 @@ public:
SBE_NODISCARD std::string getSessionAsString() const SBE_NODISCARD std::string getSessionAsString() const
{ {
const char *buffer = m_buffer + m_offset + 68; const char *buffer = m_buffer + m_offset + 68;
size_t length = 0; std::size_t length = 0;
for (; length < 3 && *(buffer + length) != '\0'; ++length); for (; length < 3 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1317,7 +1318,7 @@ public:
SBE_NODISCARD std::string_view getSessionAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getSessionAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 68; const char *buffer = m_buffer + m_offset + 68;
size_t length = 0; std::size_t length = 0;
for (; length < 3 && *(buffer + length) != '\0'; ++length); for (; length < 3 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1329,14 +1330,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
Negotiate500 &putSession(const std::string_view str) Negotiate500 &putSession(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 3) if (srcLength > 3)
{ {
throw std::runtime_error("string too large for putSession [E106]"); throw std::runtime_error("string too large for putSession [E106]");
} }
std::memcpy(m_buffer + m_offset + 68, str.data(), srcLength); 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; m_buffer[m_offset + 68 + start] = 0;
} }
@@ -1346,14 +1347,14 @@ public:
#else #else
Negotiate500 &putSession(const std::string& str) Negotiate500 &putSession(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 3) if (srcLength > 3)
{ {
throw std::runtime_error("string too large for putSession [E106]"); throw std::runtime_error("string too large for putSession [E106]");
} }
std::memcpy(m_buffer + m_offset + 68, str.c_str(), srcLength); 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; m_buffer[m_offset + 68 + start] = 0;
} }
@@ -1362,7 +1363,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1401,17 +1402,17 @@ public:
static SBE_CONSTEXPR char firmNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char firmNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char firmMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char firmMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char firmMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char firmMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t firmEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t firmEncodingLength() SBE_NOEXCEPT
@@ -1465,7 +1466,7 @@ public:
throw std::runtime_error("length too large for getFirm [E106]"); 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; return length;
} }
@@ -1478,7 +1479,7 @@ public:
SBE_NODISCARD std::string getFirmAsString() const SBE_NODISCARD std::string getFirmAsString() const
{ {
const char *buffer = m_buffer + m_offset + 71; const char *buffer = m_buffer + m_offset + 71;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1523,7 +1524,7 @@ public:
SBE_NODISCARD std::string_view getFirmAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getFirmAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 71; const char *buffer = m_buffer + m_offset + 71;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1535,14 +1536,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
Negotiate500 &putFirm(const std::string_view str) Negotiate500 &putFirm(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putFirm [E106]"); throw std::runtime_error("string too large for putFirm [E106]");
} }
std::memcpy(m_buffer + m_offset + 71, str.data(), srcLength); 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; m_buffer[m_offset + 71 + start] = 0;
} }
@@ -1552,14 +1553,14 @@ public:
#else #else
Negotiate500 &putFirm(const std::string& str) Negotiate500 &putFirm(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putFirm [E106]"); throw std::runtime_error("string too large for putFirm [E106]");
} }
std::memcpy(m_buffer + m_offset + 71, str.c_str(), srcLength); 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; m_buffer[m_offset + 71 + start] = 0;
} }
@@ -1568,7 +1569,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1648,7 +1649,7 @@ public:
std::uint64_t bytesToCopy = length < dataLength ? length : dataLength; std::uint64_t bytesToCopy = length < dataLength ? length : dataLength;
std::uint64_t pos = sbePosition(); std::uint64_t pos = sbePosition();
sbePosition(pos + dataLength); 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; return bytesToCopy;
} }
@@ -1737,7 +1738,8 @@ public:
{ {
throw std::runtime_error("std::string too long for length type [E109]"); 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 #if __cplusplus >= 201703L
Negotiate500 &putCredentials(const std::string_view str) Negotiate500 &putCredentials(const std::string_view str)
@@ -1746,7 +1748,8 @@ public:
{ {
throw std::runtime_error("std::string too long for length type [E109]"); 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 #endif
template<typename CharT, typename Traits> template<typename CharT, typename Traits>
@@ -1808,21 +1811,21 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
return false; 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__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
length += credentialsHeaderLength(); 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; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
NegotiationReject502() = default; NegotiationReject502() = default;
NegotiationReject502( NegotiationReject502(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "NegotiationReject";
} }
@@ -258,7 +260,7 @@ public:
NegotiationReject502 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = NegotiationReject502( return *this = NegotiationReject502(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
NegotiationReject502 skipper(m_buffer, m_offset, NegotiationReject502 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -376,17 +377,17 @@ public:
static SBE_CONSTEXPR char reasonNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char reasonNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char reasonMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char reasonMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char reasonMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char reasonMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t reasonEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t reasonEncodingLength() SBE_NOEXCEPT
@@ -440,7 +441,7 @@ public:
throw std::runtime_error("length too large for getReason [E106]"); 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; return length;
} }
@@ -453,7 +454,7 @@ public:
SBE_NODISCARD std::string getReasonAsString() const SBE_NODISCARD std::string getReasonAsString() const
{ {
const char *buffer = m_buffer + m_offset + 0; const char *buffer = m_buffer + m_offset + 0;
size_t length = 0; std::size_t length = 0;
for (; length < 48 && *(buffer + length) != '\0'; ++length); for (; length < 48 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -498,7 +499,7 @@ public:
SBE_NODISCARD std::string_view getReasonAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getReasonAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 0; const char *buffer = m_buffer + m_offset + 0;
size_t length = 0; std::size_t length = 0;
for (; length < 48 && *(buffer + length) != '\0'; ++length); for (; length < 48 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -510,14 +511,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
NegotiationReject502 &putReason(const std::string_view str) NegotiationReject502 &putReason(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 48) if (srcLength > 48)
{ {
throw std::runtime_error("string too large for putReason [E106]"); throw std::runtime_error("string too large for putReason [E106]");
} }
std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); 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; m_buffer[m_offset + 0 + start] = 0;
} }
@@ -527,14 +528,14 @@ public:
#else #else
NegotiationReject502 &putReason(const std::string& str) NegotiationReject502 &putReason(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 48) if (srcLength > 48)
{ {
throw std::runtime_error("string too large for putReason [E106]"); throw std::runtime_error("string too large for putReason [E106]");
} }
std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); 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; m_buffer[m_offset + 0 + start] = 0;
} }
@@ -543,7 +544,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -587,12 +588,12 @@ public:
static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -614,7 +615,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -658,12 +659,12 @@ public:
static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT
@@ -685,7 +686,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -729,12 +730,12 @@ public:
static SBE_CONSTEXPR std::uint16_t errorCodesMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t errorCodesEncodingLength() SBE_NOEXCEPT
@@ -756,7 +757,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -798,7 +799,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t));
@@ -812,7 +820,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -854,7 +862,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t)); 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; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
NegotiationResponse501() = default; NegotiationResponse501() = default;
NegotiationResponse501( NegotiationResponse501(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "NegotiationResponse";
} }
@@ -258,7 +260,7 @@ public:
NegotiationResponse501 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = NegotiationResponse501( return *this = NegotiationResponse501(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
NegotiationResponse501 skipper(m_buffer, m_offset, NegotiationResponse501 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -376,17 +377,17 @@ public:
static SBE_CONSTEXPR char serverFlowNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char serverFlowNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char serverFlowMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char serverFlowMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char serverFlowMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char serverFlowMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t serverFlowEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t serverFlowEncodingLength() SBE_NOEXCEPT
@@ -401,14 +402,14 @@ public:
SBE_NODISCARD const char *serverFlow() const 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; return (const char *)serverFlowValues;
} }
SBE_NODISCARD char serverFlow(const std::uint64_t index) const 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]; 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 }; 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::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; return bytesToCopy;
} }
@@ -462,7 +463,7 @@ public:
return oss.str(); 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) switch (metaAttribute)
{ {
@@ -506,12 +507,12 @@ public:
static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -533,7 +534,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -577,12 +578,12 @@ public:
static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT
@@ -604,7 +605,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -643,17 +644,17 @@ public:
static SBE_CONSTEXPR std::uint16_t secretKeySecureIDExpirationNullValue() SBE_NOEXCEPT 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 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 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 static SBE_CONSTEXPR std::size_t secretKeySecureIDExpirationEncodingLength() SBE_NOEXCEPT
@@ -675,7 +676,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -717,7 +718,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t));
@@ -731,7 +739,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -773,7 +781,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 19, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 19, sizeof(std::uint8_t));
@@ -787,7 +802,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -831,12 +846,12 @@ public:
static SBE_CONSTEXPR std::uint32_t previousSeqNoMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t previousSeqNoMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t previousSeqNoMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t previousSeqNoMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t previousSeqNoEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t previousSeqNoEncodingLength() SBE_NOEXCEPT
@@ -858,7 +873,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -902,12 +917,12 @@ public:
static SBE_CONSTEXPR std::uint64_t previousUUIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t previousUUIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t previousUUIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t previousUUIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t previousUUIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t previousUUIDEncodingLength() SBE_NOEXCEPT
@@ -929,7 +944,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1009,7 +1024,7 @@ public:
std::uint64_t bytesToCopy = length < dataLength ? length : dataLength; std::uint64_t bytesToCopy = length < dataLength ? length : dataLength;
std::uint64_t pos = sbePosition(); std::uint64_t pos = sbePosition();
sbePosition(pos + dataLength); 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; return bytesToCopy;
} }
@@ -1098,7 +1113,8 @@ public:
{ {
throw std::runtime_error("std::string too long for length type [E109]"); 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 #if __cplusplus >= 201703L
NegotiationResponse501 &putCredentials(const std::string_view str) NegotiationResponse501 &putCredentials(const std::string_view str)
@@ -1107,7 +1123,8 @@ public:
{ {
throw std::runtime_error("std::string too long for length type [E109]"); 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 #endif
template<typename CharT, typename Traits> template<typename CharT, typename Traits>
@@ -1169,21 +1186,21 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
return false; 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__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
length += credentialsHeaderLength(); 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; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
NewOrderCross544() = default; NewOrderCross544() = default;
NewOrderCross544( NewOrderCross544(
@@ -218,32 +220,32 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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 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) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = NewOrderCross544( return *this = NewOrderCross544(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
NewOrderCross544 skipper(m_buffer, m_offset, NewOrderCross544 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -381,12 +382,12 @@ public:
static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -452,12 +453,12 @@ public:
static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -521,7 +522,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -535,7 +543,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -579,12 +587,12 @@ public:
static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -606,7 +614,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -645,17 +653,17 @@ public:
static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -709,7 +717,7 @@ public:
throw std::runtime_error("length too large for getSenderID [E106]"); 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; return length;
} }
@@ -722,7 +730,7 @@ public:
SBE_NODISCARD std::string getSenderIDAsString() const SBE_NODISCARD std::string getSenderIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -767,7 +775,7 @@ public:
SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -779,14 +787,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
NewOrderCross544 &putSenderID(const std::string_view str) NewOrderCross544 &putSenderID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -796,14 +804,14 @@ public:
#else #else
NewOrderCross544 &putSenderID(const std::string& str) NewOrderCross544 &putSenderID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -812,7 +820,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -851,17 +859,17 @@ public:
static SBE_CONSTEXPR char ordTypeNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char ordTypeNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char ordTypeMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char ordTypeMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char ordTypeMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char ordTypeMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT
@@ -876,14 +884,14 @@ public:
SBE_NODISCARD const char *ordType() const 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; return (const char *)ordTypeValues;
} }
SBE_NODISCARD char ordType(const std::uint64_t index) const 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]; return (char)ordTypeValues[index];
} }
@@ -893,7 +901,7 @@ public:
static std::uint8_t ordTypeValues[] = { 50 }; static std::uint8_t ordTypeValues[] = { 50 };
std::uint64_t bytesToCopy = length < sizeof(ordTypeValues) ? length : sizeof(ordTypeValues); 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; return bytesToCopy;
} }
@@ -937,7 +945,7 @@ public:
return oss.str(); 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) switch (metaAttribute)
{ {
@@ -976,17 +984,17 @@ public:
static SBE_CONSTEXPR char crossTypeNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char crossTypeNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char crossTypeMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char crossTypeMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char crossTypeMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char crossTypeMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT
@@ -1001,14 +1009,14 @@ public:
SBE_NODISCARD const char *crossType() const 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; return (const char *)crossTypeValues;
} }
SBE_NODISCARD char crossType(const std::uint64_t index) const 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]; return (char)crossTypeValues[index];
} }
@@ -1018,7 +1026,7 @@ public:
static std::uint8_t crossTypeValues[] = { 51 }; static std::uint8_t crossTypeValues[] = { 51 };
std::uint64_t bytesToCopy = length < sizeof(crossTypeValues) ? length : sizeof(crossTypeValues); 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; return bytesToCopy;
} }
@@ -1062,7 +1070,7 @@ public:
return oss.str(); 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) switch (metaAttribute)
{ {
@@ -1101,17 +1109,17 @@ public:
static SBE_CONSTEXPR char crossPrioritizationNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char crossPrioritizationNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char crossPrioritizationMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char crossPrioritizationMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char crossPrioritizationMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char crossPrioritizationMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t crossPrioritizationEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t crossPrioritizationEncodingLength() SBE_NOEXCEPT
@@ -1126,14 +1134,14 @@ public:
SBE_NODISCARD const char *crossPrioritization() const 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; return (const char *)crossPrioritizationValues;
} }
SBE_NODISCARD char crossPrioritization(const std::uint64_t index) const 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]; return (char)crossPrioritizationValues[index];
} }
@@ -1143,7 +1151,7 @@ public:
static std::uint8_t crossPrioritizationValues[] = { 48 }; static std::uint8_t crossPrioritizationValues[] = { 48 };
std::uint64_t bytesToCopy = length < sizeof(crossPrioritizationValues) ? length : sizeof(crossPrioritizationValues); 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; return bytesToCopy;
} }
@@ -1187,7 +1195,7 @@ public:
return oss.str(); 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) switch (metaAttribute)
{ {
@@ -1234,7 +1242,7 @@ public:
return m_price; 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) switch (metaAttribute)
{ {
@@ -1278,12 +1286,12 @@ public:
static SBE_CONSTEXPR std::uint64_t transBkdTimeMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t transBkdTimeMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t transBkdTimeMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t transBkdTimeMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t transBkdTimeEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t transBkdTimeEncodingLength() SBE_NOEXCEPT
@@ -1305,7 +1313,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1349,12 +1357,12 @@ public:
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1376,7 +1384,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1415,17 +1423,17 @@ public:
static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1479,7 +1487,7 @@ public:
throw std::runtime_error("length too large for getLocation [E106]"); 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; return length;
} }
@@ -1492,7 +1500,7 @@ public:
SBE_NODISCARD std::string getLocationAsString() const SBE_NODISCARD std::string getLocationAsString() const
{ {
const char *buffer = m_buffer + m_offset + 65; const char *buffer = m_buffer + m_offset + 65;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1537,7 +1545,7 @@ public:
SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 65; const char *buffer = m_buffer + m_offset + 65;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1549,14 +1557,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
NewOrderCross544 &putLocation(const std::string_view str) NewOrderCross544 &putLocation(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 65, str.data(), srcLength); 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; m_buffer[m_offset + 65 + start] = 0;
} }
@@ -1566,14 +1574,14 @@ public:
#else #else
NewOrderCross544 &putLocation(const std::string& str) NewOrderCross544 &putLocation(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 65, str.c_str(), srcLength); 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; m_buffer[m_offset + 65 + start] = 0;
} }
@@ -1582,7 +1590,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1626,12 +1634,12 @@ public:
static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
{ {
return -2147483647; return INT32_C(-2147483647);
} }
static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
{ {
return 2147483647; return INT32_C(2147483647);
} }
static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -1711,8 +1719,8 @@ public:
m_buffer = buffer; m_buffer = buffer;
m_bufferLength = bufferLength; m_bufferLength = bufferLength;
GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
dimensions.blockLength((std::uint16_t)34); dimensions.blockLength(static_cast<std::uint16_t>(34));
dimensions.numInGroup((std::uint8_t)count); dimensions.numInGroup(static_cast<std::uint8_t>(count));
m_index = 0; m_index = 0;
m_count = count; m_count = count;
m_blockLength = 34; m_blockLength = 34;
@@ -1783,7 +1791,7 @@ public:
{ {
m_count = m_index; m_count = m_index;
GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); 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; return m_count;
} }
@@ -1809,7 +1817,7 @@ public:
#endif #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) switch (metaAttribute)
{ {
@@ -1848,17 +1856,17 @@ public:
static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT
@@ -1912,7 +1920,7 @@ public:
throw std::runtime_error("length too large for getClOrdID [E106]"); 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; return length;
} }
@@ -1925,7 +1933,7 @@ public:
SBE_NODISCARD std::string getClOrdIDAsString() const SBE_NODISCARD std::string getClOrdIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 0; const char *buffer = m_buffer + m_offset + 0;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1970,7 +1978,7 @@ public:
SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 0; const char *buffer = m_buffer + m_offset + 0;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1982,14 +1990,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
NoSides &putClOrdID(const std::string_view str) NoSides &putClOrdID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putClOrdID [E106]"); throw std::runtime_error("string too large for putClOrdID [E106]");
} }
std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); 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; m_buffer[m_offset + 0 + start] = 0;
} }
@@ -1999,14 +2007,14 @@ public:
#else #else
NoSides &putClOrdID(const std::string& str) NoSides &putClOrdID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putClOrdID [E106]"); throw std::runtime_error("string too large for putClOrdID [E106]");
} }
std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); 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; m_buffer[m_offset + 0 + start] = 0;
} }
@@ -2015,7 +2023,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -2059,12 +2067,12 @@ public:
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -2086,7 +2094,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2130,12 +2138,12 @@ public:
static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT
@@ -2157,7 +2165,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2199,7 +2207,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::uint8_t));
@@ -2213,7 +2228,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2255,7 +2270,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 33, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 33, sizeof(std::uint8_t));
@@ -2308,13 +2330,13 @@ public:
return true; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -2448,21 +2470,21 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
return false; 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__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
length += NoSides::sbeHeaderSize(); 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; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
NewOrderSingle514() = default; NewOrderSingle514() = default;
NewOrderSingle514( NewOrderSingle514(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "D";
} }
@@ -258,7 +260,7 @@ public:
NewOrderSingle514 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = NewOrderSingle514( return *this = NewOrderSingle514(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
NewOrderSingle514 skipper(m_buffer, m_offset, NewOrderSingle514 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -384,7 +385,7 @@ public:
return m_price; 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) switch (metaAttribute)
{ {
@@ -428,12 +429,12 @@ public:
static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT
@@ -455,7 +456,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -499,12 +500,12 @@ public:
static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
{ {
return -2147483647; return INT32_C(-2147483647);
} }
static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
{ {
return 2147483647; return INT32_C(2147483647);
} }
static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -526,7 +527,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -568,7 +569,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -582,7 +590,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -626,12 +634,12 @@ public:
static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -653,7 +661,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -692,17 +700,17 @@ public:
static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -756,7 +764,7 @@ public:
throw std::runtime_error("length too large for getSenderID [E106]"); 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; return length;
} }
@@ -769,7 +777,7 @@ public:
SBE_NODISCARD std::string getSenderIDAsString() const SBE_NODISCARD std::string getSenderIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -814,7 +822,7 @@ public:
SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -826,14 +834,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
NewOrderSingle514 &putSenderID(const std::string_view str) NewOrderSingle514 &putSenderID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -843,14 +851,14 @@ public:
#else #else
NewOrderSingle514 &putSenderID(const std::string& str) NewOrderSingle514 &putSenderID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -859,7 +867,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -898,17 +906,17 @@ public:
static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT
@@ -962,7 +970,7 @@ public:
throw std::runtime_error("length too large for getClOrdID [E106]"); 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; return length;
} }
@@ -975,7 +983,7 @@ public:
SBE_NODISCARD std::string getClOrdIDAsString() const SBE_NODISCARD std::string getClOrdIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 41; const char *buffer = m_buffer + m_offset + 41;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1020,7 +1028,7 @@ public:
SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 41; const char *buffer = m_buffer + m_offset + 41;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1032,14 +1040,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
NewOrderSingle514 &putClOrdID(const std::string_view str) NewOrderSingle514 &putClOrdID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putClOrdID [E106]"); throw std::runtime_error("string too large for putClOrdID [E106]");
} }
std::memcpy(m_buffer + m_offset + 41, str.data(), srcLength); 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; m_buffer[m_offset + 41 + start] = 0;
} }
@@ -1049,14 +1057,14 @@ public:
#else #else
NewOrderSingle514 &putClOrdID(const std::string& str) NewOrderSingle514 &putClOrdID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putClOrdID [E106]"); throw std::runtime_error("string too large for putClOrdID [E106]");
} }
std::memcpy(m_buffer + m_offset + 41, str.c_str(), srcLength); 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; m_buffer[m_offset + 41 + start] = 0;
} }
@@ -1065,7 +1073,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1109,12 +1117,12 @@ public:
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -1136,7 +1144,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1180,12 +1188,12 @@ public:
static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT
@@ -1207,7 +1215,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1251,12 +1259,12 @@ public:
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1278,7 +1286,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1325,7 +1333,7 @@ public:
return m_stopPx; 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) switch (metaAttribute)
{ {
@@ -1364,17 +1372,17 @@ public:
static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1428,7 +1436,7 @@ public:
throw std::runtime_error("length too large for getLocation [E106]"); 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; return length;
} }
@@ -1441,7 +1449,7 @@ public:
SBE_NODISCARD std::string getLocationAsString() const SBE_NODISCARD std::string getLocationAsString() const
{ {
const char *buffer = m_buffer + m_offset + 93; const char *buffer = m_buffer + m_offset + 93;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1486,7 +1494,7 @@ public:
SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 93; const char *buffer = m_buffer + m_offset + 93;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1498,14 +1506,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
NewOrderSingle514 &putLocation(const std::string_view str) NewOrderSingle514 &putLocation(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 93, str.data(), srcLength); 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; m_buffer[m_offset + 93 + start] = 0;
} }
@@ -1515,14 +1523,14 @@ public:
#else #else
NewOrderSingle514 &putLocation(const std::string& str) NewOrderSingle514 &putLocation(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 93, str.c_str(), srcLength); 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; m_buffer[m_offset + 93 + start] = 0;
} }
@@ -1531,7 +1539,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1570,17 +1578,17 @@ public:
static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT
{ {
return 4294967295; return UINT32_C(0xffffffff);
} }
static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT
@@ -1602,7 +1610,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1641,17 +1649,17 @@ public:
static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT
{ {
return 4294967295; return UINT32_C(0xffffffff);
} }
static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT
@@ -1673,7 +1681,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1712,17 +1720,17 @@ public:
static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT 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 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 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 static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT
@@ -1744,7 +1752,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1786,7 +1794,14 @@ public:
return 1; 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; char val;
std::memcpy(&val, m_buffer + m_offset + 108, sizeof(char)); std::memcpy(&val, m_buffer + m_offset + 108, sizeof(char));
@@ -1800,7 +1815,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1842,7 +1857,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 109, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 109, sizeof(std::uint8_t));
@@ -1856,7 +1878,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1898,7 +1920,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 110, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 110, sizeof(std::uint8_t));
@@ -1912,7 +1941,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1964,7 +1993,7 @@ public:
return 1; 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) switch (metaAttribute)
{ {
@@ -2006,7 +2035,14 @@ public:
return 1; 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; char val;
std::memcpy(&val, m_buffer + m_offset + 112, sizeof(char)); std::memcpy(&val, m_buffer + m_offset + 112, sizeof(char));
@@ -2020,7 +2056,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2062,7 +2098,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 113, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 113, sizeof(std::uint8_t));
@@ -2076,7 +2119,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2118,7 +2161,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 114, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 114, sizeof(std::uint8_t));
@@ -2132,7 +2182,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2174,7 +2224,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 115, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 115, sizeof(std::uint8_t));
@@ -2188,6 +2245,53 @@ public:
return *this; 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> template<typename CharT, typename Traits>
friend std::basic_ostream<CharT, Traits>& operator << ( friend std::basic_ostream<CharT, Traits>& operator << (
std::basic_ostream<CharT, Traits>& builder, NewOrderSingle514 _writer) std::basic_ostream<CharT, Traits>& builder, NewOrderSingle514 _writer)
@@ -2294,6 +2398,10 @@ friend std::basic_ostream<CharT, Traits>& operator << (
builder << R"("ShortSaleType": )"; builder << R"("ShortSaleType": )";
builder << '"' << writer.shortSaleType() << '"'; builder << '"' << writer.shortSaleType() << '"';
builder << ", ";
builder << R"("DiscretionPrice": )";
builder << writer.discretionPrice();
builder << '}'; builder << '}';
return builder; return builder;
@@ -2308,13 +2416,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
return true; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
NotApplied513() = default; NotApplied513() = default;
NotApplied513( NotApplied513(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "NotApplied";
} }
@@ -258,7 +260,7 @@ public:
NotApplied513 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = NotApplied513( return *this = NotApplied513(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
NotApplied513 skipper(m_buffer, m_offset, NotApplied513 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -381,12 +382,12 @@ public:
static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -452,12 +453,12 @@ public:
static SBE_CONSTEXPR std::uint32_t fromSeqNoMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t fromSeqNoMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t fromSeqNoMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t fromSeqNoMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t fromSeqNoEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t fromSeqNoEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -523,12 +524,12 @@ public:
static SBE_CONSTEXPR std::uint32_t msgCountMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t msgCountMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t msgCountMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t msgCountMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t msgCountEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t msgCountEncodingLength() SBE_NOEXCEPT
@@ -550,7 +551,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -592,7 +593,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); 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; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class OFMOverrideReq
public: public:
enum Value enum Value
{ {
Disabled = (std::uint8_t)0, Disabled = static_cast<std::uint8_t>(0),
Enabled = (std::uint8_t)1, Enabled = static_cast<std::uint8_t>(1),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static OFMOverrideReq::Value get(const std::uint8_t value) static OFMOverrideReq::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 0: return Disabled; case static_cast<std::uint8_t>(0): return Disabled;
case 1: return Enabled; case static_cast<std::uint8_t>(1): return Enabled;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum OFMOverrideReq [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class OrdStatusTrd
public: public:
enum Value enum Value
{ {
PartiallyFilled = (std::uint8_t)1, PartiallyFilled = static_cast<std::uint8_t>(1),
Filled = (std::uint8_t)2, Filled = static_cast<std::uint8_t>(2),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static OrdStatusTrd::Value get(const std::uint8_t value) static OrdStatusTrd::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 1: return PartiallyFilled; case static_cast<std::uint8_t>(1): return PartiallyFilled;
case 2: return Filled; case static_cast<std::uint8_t>(2): return Filled;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum OrdStatusTrd [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class OrdStatusTrdCxl
public: public:
enum Value enum Value
{ {
TradeCorrection = (char)71, TradeCorrection = static_cast<char>(71),
TradeCancel = (char)72, TradeCancel = static_cast<char>(72),
NULL_VALUE = (char)0 NULL_VALUE = static_cast<char>(0)
}; };
static OrdStatusTrdCxl::Value get(const char value) static OrdStatusTrdCxl::Value get(const char value)
{ {
switch (value) switch (value)
{ {
case 71: return TradeCorrection; case static_cast<char>(71): return TradeCorrection;
case 72: return TradeCancel; case static_cast<char>(72): return TradeCancel;
case 0: return NULL_VALUE; case static_cast<char>(0): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum OrdStatusTrdCxl [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
OrderCancelReject535() = default; OrderCancelReject535() = default;
OrderCancelReject535( OrderCancelReject535(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "9";
} }
@@ -258,7 +260,7 @@ public:
OrderCancelReject535 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = OrderCancelReject535( return *this = OrderCancelReject535(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
OrderCancelReject535 skipper(m_buffer, m_offset, OrderCancelReject535 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -381,12 +382,12 @@ public:
static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -452,12 +453,12 @@ public:
static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -518,17 +519,17 @@ public:
static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT
@@ -582,7 +583,7 @@ public:
throw std::runtime_error("length too large for getText [E106]"); 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; return length;
} }
@@ -595,7 +596,7 @@ public:
SBE_NODISCARD std::string getTextAsString() const SBE_NODISCARD std::string getTextAsString() const
{ {
const char *buffer = m_buffer + m_offset + 12; const char *buffer = m_buffer + m_offset + 12;
size_t length = 0; std::size_t length = 0;
for (; length < 256 && *(buffer + length) != '\0'; ++length); for (; length < 256 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -640,7 +641,7 @@ public:
SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 12; const char *buffer = m_buffer + m_offset + 12;
size_t length = 0; std::size_t length = 0;
for (; length < 256 && *(buffer + length) != '\0'; ++length); for (; length < 256 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -652,14 +653,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderCancelReject535 &putText(const std::string_view str) OrderCancelReject535 &putText(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 256) if (srcLength > 256)
{ {
throw std::runtime_error("string too large for putText [E106]"); throw std::runtime_error("string too large for putText [E106]");
} }
std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); 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; m_buffer[m_offset + 12 + start] = 0;
} }
@@ -669,14 +670,14 @@ public:
#else #else
OrderCancelReject535 &putText(const std::string& str) OrderCancelReject535 &putText(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 256) if (srcLength > 256)
{ {
throw std::runtime_error("string too large for putText [E106]"); throw std::runtime_error("string too large for putText [E106]");
} }
std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); 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; m_buffer[m_offset + 12 + start] = 0;
} }
@@ -685,7 +686,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -724,17 +725,17 @@ public:
static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT
@@ -788,7 +789,7 @@ public:
throw std::runtime_error("length too large for getExecID [E106]"); 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; return length;
} }
@@ -801,7 +802,7 @@ public:
SBE_NODISCARD std::string getExecIDAsString() const SBE_NODISCARD std::string getExecIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 268; const char *buffer = m_buffer + m_offset + 268;
size_t length = 0; std::size_t length = 0;
for (; length < 40 && *(buffer + length) != '\0'; ++length); for (; length < 40 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -846,7 +847,7 @@ public:
SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 268; const char *buffer = m_buffer + m_offset + 268;
size_t length = 0; std::size_t length = 0;
for (; length < 40 && *(buffer + length) != '\0'; ++length); for (; length < 40 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -858,14 +859,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderCancelReject535 &putExecID(const std::string_view str) OrderCancelReject535 &putExecID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 40) if (srcLength > 40)
{ {
throw std::runtime_error("string too large for putExecID [E106]"); throw std::runtime_error("string too large for putExecID [E106]");
} }
std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); 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; m_buffer[m_offset + 268 + start] = 0;
} }
@@ -875,14 +876,14 @@ public:
#else #else
OrderCancelReject535 &putExecID(const std::string& str) OrderCancelReject535 &putExecID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 40) if (srcLength > 40)
{ {
throw std::runtime_error("string too large for putExecID [E106]"); throw std::runtime_error("string too large for putExecID [E106]");
} }
std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); 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; m_buffer[m_offset + 268 + start] = 0;
} }
@@ -891,7 +892,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -930,17 +931,17 @@ public:
static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -994,7 +995,7 @@ public:
throw std::runtime_error("length too large for getSenderID [E106]"); 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; return length;
} }
@@ -1007,7 +1008,7 @@ public:
SBE_NODISCARD std::string getSenderIDAsString() const SBE_NODISCARD std::string getSenderIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 308; const char *buffer = m_buffer + m_offset + 308;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1052,7 +1053,7 @@ public:
SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 308; const char *buffer = m_buffer + m_offset + 308;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1064,14 +1065,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderCancelReject535 &putSenderID(const std::string_view str) OrderCancelReject535 &putSenderID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 308, str.data(), srcLength); 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; m_buffer[m_offset + 308 + start] = 0;
} }
@@ -1081,14 +1082,14 @@ public:
#else #else
OrderCancelReject535 &putSenderID(const std::string& str) OrderCancelReject535 &putSenderID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 308, str.c_str(), srcLength); 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; m_buffer[m_offset + 308 + start] = 0;
} }
@@ -1097,7 +1098,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1136,17 +1137,17 @@ public:
static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT
@@ -1200,7 +1201,7 @@ public:
throw std::runtime_error("length too large for getClOrdID [E106]"); 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; return length;
} }
@@ -1213,7 +1214,7 @@ public:
SBE_NODISCARD std::string getClOrdIDAsString() const SBE_NODISCARD std::string getClOrdIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 328; const char *buffer = m_buffer + m_offset + 328;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1258,7 +1259,7 @@ public:
SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 328; const char *buffer = m_buffer + m_offset + 328;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1270,14 +1271,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderCancelReject535 &putClOrdID(const std::string_view str) OrderCancelReject535 &putClOrdID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putClOrdID [E106]"); throw std::runtime_error("string too large for putClOrdID [E106]");
} }
std::memcpy(m_buffer + m_offset + 328, str.data(), srcLength); 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; m_buffer[m_offset + 328 + start] = 0;
} }
@@ -1287,14 +1288,14 @@ public:
#else #else
OrderCancelReject535 &putClOrdID(const std::string& str) OrderCancelReject535 &putClOrdID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putClOrdID [E106]"); throw std::runtime_error("string too large for putClOrdID [E106]");
} }
std::memcpy(m_buffer + m_offset + 328, str.c_str(), srcLength); 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; m_buffer[m_offset + 328 + start] = 0;
} }
@@ -1303,7 +1304,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1347,12 +1348,12 @@ public:
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -1374,7 +1375,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1413,17 +1414,17 @@ public:
static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT
@@ -1438,14 +1439,14 @@ public:
SBE_NODISCARD const char *ordStatus() const 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; return (const char *)ordStatusValues;
} }
SBE_NODISCARD char ordStatus(const std::uint64_t index) const 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]; return (char)ordStatusValues[index];
} }
@@ -1455,7 +1456,7 @@ public:
static std::uint8_t ordStatusValues[] = { 85 }; static std::uint8_t ordStatusValues[] = { 85 };
std::uint64_t bytesToCopy = length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues); 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; return bytesToCopy;
} }
@@ -1499,7 +1500,7 @@ public:
return oss.str(); 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) switch (metaAttribute)
{ {
@@ -1538,17 +1539,17 @@ public:
static SBE_CONSTEXPR char cxlRejResponseToNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char cxlRejResponseToNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char cxlRejResponseToMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char cxlRejResponseToMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char cxlRejResponseToMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char cxlRejResponseToMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t cxlRejResponseToEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t cxlRejResponseToEncodingLength() SBE_NOEXCEPT
@@ -1563,14 +1564,14 @@ public:
SBE_NODISCARD const char *cxlRejResponseTo() const 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; return (const char *)cxlRejResponseToValues;
} }
SBE_NODISCARD char cxlRejResponseTo(const std::uint64_t index) const 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]; return (char)cxlRejResponseToValues[index];
} }
@@ -1580,7 +1581,7 @@ public:
static std::uint8_t cxlRejResponseToValues[] = { 49 }; static std::uint8_t cxlRejResponseToValues[] = { 49 };
std::uint64_t bytesToCopy = length < sizeof(cxlRejResponseToValues) ? length : sizeof(cxlRejResponseToValues); 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; return bytesToCopy;
} }
@@ -1624,7 +1625,7 @@ public:
return oss.str(); 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) switch (metaAttribute)
{ {
@@ -1668,12 +1669,12 @@ public:
static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT
@@ -1695,7 +1696,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1739,12 +1740,12 @@ public:
static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT
@@ -1766,7 +1767,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1810,12 +1811,12 @@ public:
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1837,7 +1838,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1881,12 +1882,12 @@ public:
static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT
@@ -1908,7 +1909,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1947,17 +1948,17 @@ public:
static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -2011,7 +2012,7 @@ public:
throw std::runtime_error("length too large for getLocation [E106]"); 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; return length;
} }
@@ -2024,7 +2025,7 @@ public:
SBE_NODISCARD std::string getLocationAsString() const SBE_NODISCARD std::string getLocationAsString() const
{ {
const char *buffer = m_buffer + m_offset + 388; const char *buffer = m_buffer + m_offset + 388;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -2069,7 +2070,7 @@ public:
SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 388; const char *buffer = m_buffer + m_offset + 388;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -2081,14 +2082,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderCancelReject535 &putLocation(const std::string_view str) OrderCancelReject535 &putLocation(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 388, str.data(), srcLength); 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; m_buffer[m_offset + 388 + start] = 0;
} }
@@ -2098,14 +2099,14 @@ public:
#else #else
OrderCancelReject535 &putLocation(const std::string& str) OrderCancelReject535 &putLocation(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 388, str.c_str(), srcLength); 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; m_buffer[m_offset + 388 + start] = 0;
} }
@@ -2114,7 +2115,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -2158,12 +2159,12 @@ public:
static SBE_CONSTEXPR std::uint16_t cxlRejReasonMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t cxlRejReasonEncodingLength() SBE_NOEXCEPT
@@ -2185,7 +2186,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2224,17 +2225,17 @@ public:
static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT 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 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 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 static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT
@@ -2256,7 +2257,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2298,7 +2299,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 397, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 397, sizeof(std::uint8_t));
@@ -2312,7 +2320,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2354,7 +2362,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 398, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 398, sizeof(std::uint8_t));
@@ -2368,7 +2383,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2410,7 +2425,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 399, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 399, sizeof(std::uint8_t));
@@ -2424,7 +2446,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2466,7 +2488,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 400, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 400, sizeof(std::uint8_t));
@@ -2480,7 +2509,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2519,17 +2548,17 @@ public:
static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT
{ {
return 0xffffffffffffffffL; return UINT64_C(0xffffffffffffffff);
} }
static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT
@@ -2541,7 +2570,7 @@ public:
{ {
if (m_actingVersion < 4) if (m_actingVersion < 4)
{ {
return 0xffffffffffffffffL; return UINT64_C(0xffffffffffffffff);
} }
std::uint64_t val; std::uint64_t val;
@@ -2662,13 +2691,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
return true; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
OrderCancelReplaceReject536() = default; OrderCancelReplaceReject536() = default;
OrderCancelReplaceReject536( OrderCancelReplaceReject536(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "9";
} }
@@ -258,7 +260,7 @@ public:
OrderCancelReplaceReject536 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = OrderCancelReplaceReject536( return *this = OrderCancelReplaceReject536(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
OrderCancelReplaceReject536 skipper(m_buffer, m_offset, OrderCancelReplaceReject536 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -381,12 +382,12 @@ public:
static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -452,12 +453,12 @@ public:
static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -518,17 +519,17 @@ public:
static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT
@@ -582,7 +583,7 @@ public:
throw std::runtime_error("length too large for getText [E106]"); 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; return length;
} }
@@ -595,7 +596,7 @@ public:
SBE_NODISCARD std::string getTextAsString() const SBE_NODISCARD std::string getTextAsString() const
{ {
const char *buffer = m_buffer + m_offset + 12; const char *buffer = m_buffer + m_offset + 12;
size_t length = 0; std::size_t length = 0;
for (; length < 256 && *(buffer + length) != '\0'; ++length); for (; length < 256 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -640,7 +641,7 @@ public:
SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 12; const char *buffer = m_buffer + m_offset + 12;
size_t length = 0; std::size_t length = 0;
for (; length < 256 && *(buffer + length) != '\0'; ++length); for (; length < 256 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -652,14 +653,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderCancelReplaceReject536 &putText(const std::string_view str) OrderCancelReplaceReject536 &putText(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 256) if (srcLength > 256)
{ {
throw std::runtime_error("string too large for putText [E106]"); throw std::runtime_error("string too large for putText [E106]");
} }
std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); 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; m_buffer[m_offset + 12 + start] = 0;
} }
@@ -669,14 +670,14 @@ public:
#else #else
OrderCancelReplaceReject536 &putText(const std::string& str) OrderCancelReplaceReject536 &putText(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 256) if (srcLength > 256)
{ {
throw std::runtime_error("string too large for putText [E106]"); throw std::runtime_error("string too large for putText [E106]");
} }
std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); 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; m_buffer[m_offset + 12 + start] = 0;
} }
@@ -685,7 +686,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -724,17 +725,17 @@ public:
static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT
@@ -788,7 +789,7 @@ public:
throw std::runtime_error("length too large for getExecID [E106]"); 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; return length;
} }
@@ -801,7 +802,7 @@ public:
SBE_NODISCARD std::string getExecIDAsString() const SBE_NODISCARD std::string getExecIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 268; const char *buffer = m_buffer + m_offset + 268;
size_t length = 0; std::size_t length = 0;
for (; length < 40 && *(buffer + length) != '\0'; ++length); for (; length < 40 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -846,7 +847,7 @@ public:
SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 268; const char *buffer = m_buffer + m_offset + 268;
size_t length = 0; std::size_t length = 0;
for (; length < 40 && *(buffer + length) != '\0'; ++length); for (; length < 40 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -858,14 +859,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderCancelReplaceReject536 &putExecID(const std::string_view str) OrderCancelReplaceReject536 &putExecID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 40) if (srcLength > 40)
{ {
throw std::runtime_error("string too large for putExecID [E106]"); throw std::runtime_error("string too large for putExecID [E106]");
} }
std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); 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; m_buffer[m_offset + 268 + start] = 0;
} }
@@ -875,14 +876,14 @@ public:
#else #else
OrderCancelReplaceReject536 &putExecID(const std::string& str) OrderCancelReplaceReject536 &putExecID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 40) if (srcLength > 40)
{ {
throw std::runtime_error("string too large for putExecID [E106]"); throw std::runtime_error("string too large for putExecID [E106]");
} }
std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); 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; m_buffer[m_offset + 268 + start] = 0;
} }
@@ -891,7 +892,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -930,17 +931,17 @@ public:
static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -994,7 +995,7 @@ public:
throw std::runtime_error("length too large for getSenderID [E106]"); 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; return length;
} }
@@ -1007,7 +1008,7 @@ public:
SBE_NODISCARD std::string getSenderIDAsString() const SBE_NODISCARD std::string getSenderIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 308; const char *buffer = m_buffer + m_offset + 308;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1052,7 +1053,7 @@ public:
SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 308; const char *buffer = m_buffer + m_offset + 308;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1064,14 +1065,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderCancelReplaceReject536 &putSenderID(const std::string_view str) OrderCancelReplaceReject536 &putSenderID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 308, str.data(), srcLength); 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; m_buffer[m_offset + 308 + start] = 0;
} }
@@ -1081,14 +1082,14 @@ public:
#else #else
OrderCancelReplaceReject536 &putSenderID(const std::string& str) OrderCancelReplaceReject536 &putSenderID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 308, str.c_str(), srcLength); 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; m_buffer[m_offset + 308 + start] = 0;
} }
@@ -1097,7 +1098,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1136,17 +1137,17 @@ public:
static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT
@@ -1200,7 +1201,7 @@ public:
throw std::runtime_error("length too large for getClOrdID [E106]"); 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; return length;
} }
@@ -1213,7 +1214,7 @@ public:
SBE_NODISCARD std::string getClOrdIDAsString() const SBE_NODISCARD std::string getClOrdIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 328; const char *buffer = m_buffer + m_offset + 328;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1258,7 +1259,7 @@ public:
SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 328; const char *buffer = m_buffer + m_offset + 328;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1270,14 +1271,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderCancelReplaceReject536 &putClOrdID(const std::string_view str) OrderCancelReplaceReject536 &putClOrdID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putClOrdID [E106]"); throw std::runtime_error("string too large for putClOrdID [E106]");
} }
std::memcpy(m_buffer + m_offset + 328, str.data(), srcLength); 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; m_buffer[m_offset + 328 + start] = 0;
} }
@@ -1287,14 +1288,14 @@ public:
#else #else
OrderCancelReplaceReject536 &putClOrdID(const std::string& str) OrderCancelReplaceReject536 &putClOrdID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putClOrdID [E106]"); throw std::runtime_error("string too large for putClOrdID [E106]");
} }
std::memcpy(m_buffer + m_offset + 328, str.c_str(), srcLength); 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; m_buffer[m_offset + 328 + start] = 0;
} }
@@ -1303,7 +1304,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1347,12 +1348,12 @@ public:
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -1374,7 +1375,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1418,12 +1419,12 @@ public:
static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT
@@ -1445,7 +1446,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1489,12 +1490,12 @@ public:
static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT
@@ -1516,7 +1517,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1560,12 +1561,12 @@ public:
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1587,7 +1588,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1631,12 +1632,12 @@ public:
static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT
@@ -1658,7 +1659,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1697,17 +1698,17 @@ public:
static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1761,7 +1762,7 @@ public:
throw std::runtime_error("length too large for getLocation [E106]"); 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; return length;
} }
@@ -1774,7 +1775,7 @@ public:
SBE_NODISCARD std::string getLocationAsString() const SBE_NODISCARD std::string getLocationAsString() const
{ {
const char *buffer = m_buffer + m_offset + 388; const char *buffer = m_buffer + m_offset + 388;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1819,7 +1820,7 @@ public:
SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 388; const char *buffer = m_buffer + m_offset + 388;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1831,14 +1832,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderCancelReplaceReject536 &putLocation(const std::string_view str) OrderCancelReplaceReject536 &putLocation(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 388, str.data(), srcLength); 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; m_buffer[m_offset + 388 + start] = 0;
} }
@@ -1848,14 +1849,14 @@ public:
#else #else
OrderCancelReplaceReject536 &putLocation(const std::string& str) OrderCancelReplaceReject536 &putLocation(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 388, str.c_str(), srcLength); 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; m_buffer[m_offset + 388 + start] = 0;
} }
@@ -1864,7 +1865,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1908,12 +1909,12 @@ public:
static SBE_CONSTEXPR std::uint16_t cxlRejReasonMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t cxlRejReasonEncodingLength() SBE_NOEXCEPT
@@ -1935,7 +1936,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1974,17 +1975,17 @@ public:
static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT 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 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 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 static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT
@@ -2006,7 +2007,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2045,17 +2046,17 @@ public:
static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT
@@ -2070,14 +2071,14 @@ public:
SBE_NODISCARD const char *ordStatus() const 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; return (const char *)ordStatusValues;
} }
SBE_NODISCARD char ordStatus(const std::uint64_t index) const 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]; return (char)ordStatusValues[index];
} }
@@ -2087,7 +2088,7 @@ public:
static std::uint8_t ordStatusValues[] = { 85 }; static std::uint8_t ordStatusValues[] = { 85 };
std::uint64_t bytesToCopy = length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues); 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; return bytesToCopy;
} }
@@ -2131,7 +2132,7 @@ public:
return oss.str(); 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) switch (metaAttribute)
{ {
@@ -2170,17 +2171,17 @@ public:
static SBE_CONSTEXPR char cxlRejResponseToNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char cxlRejResponseToNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char cxlRejResponseToMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char cxlRejResponseToMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char cxlRejResponseToMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char cxlRejResponseToMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t cxlRejResponseToEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t cxlRejResponseToEncodingLength() SBE_NOEXCEPT
@@ -2195,14 +2196,14 @@ public:
SBE_NODISCARD const char *cxlRejResponseTo() const 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; return (const char *)cxlRejResponseToValues;
} }
SBE_NODISCARD char cxlRejResponseTo(const std::uint64_t index) const 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]; return (char)cxlRejResponseToValues[index];
} }
@@ -2212,7 +2213,7 @@ public:
static std::uint8_t cxlRejResponseToValues[] = { 50 }; static std::uint8_t cxlRejResponseToValues[] = { 50 };
std::uint64_t bytesToCopy = length < sizeof(cxlRejResponseToValues) ? length : sizeof(cxlRejResponseToValues); 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; return bytesToCopy;
} }
@@ -2256,7 +2257,7 @@ public:
return oss.str(); 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) switch (metaAttribute)
{ {
@@ -2298,7 +2299,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 397, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 397, sizeof(std::uint8_t));
@@ -2312,7 +2320,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2354,7 +2362,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 398, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 398, sizeof(std::uint8_t));
@@ -2368,7 +2383,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2410,7 +2425,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 399, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 399, sizeof(std::uint8_t));
@@ -2424,7 +2446,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2466,7 +2488,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 400, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 400, sizeof(std::uint8_t));
@@ -2480,7 +2509,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2519,17 +2548,17 @@ public:
static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT
{ {
return 0xffffffffffffffffL; return UINT64_C(0xffffffffffffffff);
} }
static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT
@@ -2541,7 +2570,7 @@ public:
{ {
if (m_actingVersion < 4) if (m_actingVersion < 4)
{ {
return 0xffffffffffffffffL; return UINT64_C(0xffffffffffffffff);
} }
std::uint64_t val; std::uint64_t val;
@@ -2662,13 +2691,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
return true; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
OrderCancelReplaceRequest515() = default; OrderCancelReplaceRequest515() = default;
OrderCancelReplaceRequest515( OrderCancelReplaceRequest515(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "G";
} }
@@ -258,7 +260,7 @@ public:
OrderCancelReplaceRequest515 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = OrderCancelReplaceRequest515( return *this = OrderCancelReplaceRequest515(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
OrderCancelReplaceRequest515 skipper(m_buffer, m_offset, OrderCancelReplaceRequest515 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -384,7 +385,7 @@ public:
return m_price; 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) switch (metaAttribute)
{ {
@@ -428,12 +429,12 @@ public:
static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT
@@ -455,7 +456,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -499,12 +500,12 @@ public:
static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
{ {
return -2147483647; return INT32_C(-2147483647);
} }
static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
{ {
return 2147483647; return INT32_C(2147483647);
} }
static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -526,7 +527,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -568,7 +569,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -582,7 +590,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -626,12 +634,12 @@ public:
static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -653,7 +661,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -692,17 +700,17 @@ public:
static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -756,7 +764,7 @@ public:
throw std::runtime_error("length too large for getSenderID [E106]"); 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; return length;
} }
@@ -769,7 +777,7 @@ public:
SBE_NODISCARD std::string getSenderIDAsString() const SBE_NODISCARD std::string getSenderIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -814,7 +822,7 @@ public:
SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -826,14 +834,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderCancelReplaceRequest515 &putSenderID(const std::string_view str) OrderCancelReplaceRequest515 &putSenderID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -843,14 +851,14 @@ public:
#else #else
OrderCancelReplaceRequest515 &putSenderID(const std::string& str) OrderCancelReplaceRequest515 &putSenderID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -859,7 +867,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -898,17 +906,17 @@ public:
static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT
@@ -962,7 +970,7 @@ public:
throw std::runtime_error("length too large for getClOrdID [E106]"); 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; return length;
} }
@@ -975,7 +983,7 @@ public:
SBE_NODISCARD std::string getClOrdIDAsString() const SBE_NODISCARD std::string getClOrdIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 41; const char *buffer = m_buffer + m_offset + 41;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1020,7 +1028,7 @@ public:
SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 41; const char *buffer = m_buffer + m_offset + 41;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1032,14 +1040,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderCancelReplaceRequest515 &putClOrdID(const std::string_view str) OrderCancelReplaceRequest515 &putClOrdID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putClOrdID [E106]"); throw std::runtime_error("string too large for putClOrdID [E106]");
} }
std::memcpy(m_buffer + m_offset + 41, str.data(), srcLength); 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; m_buffer[m_offset + 41 + start] = 0;
} }
@@ -1049,14 +1057,14 @@ public:
#else #else
OrderCancelReplaceRequest515 &putClOrdID(const std::string& str) OrderCancelReplaceRequest515 &putClOrdID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putClOrdID [E106]"); throw std::runtime_error("string too large for putClOrdID [E106]");
} }
std::memcpy(m_buffer + m_offset + 41, str.c_str(), srcLength); 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; m_buffer[m_offset + 41 + start] = 0;
} }
@@ -1065,7 +1073,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1109,12 +1117,12 @@ public:
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -1136,12 +1144,12 @@ public:
return *this; 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) switch (metaAttribute)
{ {
case MetaAttribute::SEMANTIC_TYPE: return "int"; case MetaAttribute::SEMANTIC_TYPE: return "int";
case MetaAttribute::PRESENCE: return "required"; case MetaAttribute::PRESENCE: return "optional";
default: return ""; default: return "";
} }
} }
@@ -1175,17 +1183,17 @@ public:
static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT 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 static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT
@@ -1207,7 +1215,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1254,7 +1262,7 @@ public:
return m_stopPx; 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) switch (metaAttribute)
{ {
@@ -1298,12 +1306,12 @@ public:
static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT
@@ -1325,7 +1333,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1369,12 +1377,12 @@ public:
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1396,7 +1404,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1435,17 +1443,17 @@ public:
static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1499,7 +1507,7 @@ public:
throw std::runtime_error("length too large for getLocation [E106]"); 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; return length;
} }
@@ -1512,7 +1520,7 @@ public:
SBE_NODISCARD std::string getLocationAsString() const SBE_NODISCARD std::string getLocationAsString() const
{ {
const char *buffer = m_buffer + m_offset + 101; const char *buffer = m_buffer + m_offset + 101;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1557,7 +1565,7 @@ public:
SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 101; const char *buffer = m_buffer + m_offset + 101;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1569,14 +1577,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderCancelReplaceRequest515 &putLocation(const std::string_view str) OrderCancelReplaceRequest515 &putLocation(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 101, str.data(), srcLength); 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; m_buffer[m_offset + 101 + start] = 0;
} }
@@ -1586,14 +1594,14 @@ public:
#else #else
OrderCancelReplaceRequest515 &putLocation(const std::string& str) OrderCancelReplaceRequest515 &putLocation(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 101, str.c_str(), srcLength); 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; m_buffer[m_offset + 101 + start] = 0;
} }
@@ -1602,7 +1610,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1641,17 +1649,17 @@ public:
static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT
{ {
return 4294967295; return UINT32_C(0xffffffff);
} }
static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT
@@ -1673,7 +1681,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1712,17 +1720,17 @@ public:
static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT
{ {
return 4294967295; return UINT32_C(0xffffffff);
} }
static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT
@@ -1744,7 +1752,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1783,17 +1791,17 @@ public:
static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT 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 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 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 static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT
@@ -1815,7 +1823,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1857,7 +1865,14 @@ public:
return 1; 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; char val;
std::memcpy(&val, m_buffer + m_offset + 116, sizeof(char)); std::memcpy(&val, m_buffer + m_offset + 116, sizeof(char));
@@ -1871,7 +1886,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1913,7 +1928,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 117, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 117, sizeof(std::uint8_t));
@@ -1927,7 +1949,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1969,7 +1991,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 118, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 118, sizeof(std::uint8_t));
@@ -1983,7 +2012,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2025,7 +2054,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 119, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 119, sizeof(std::uint8_t));
@@ -2039,7 +2075,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2091,7 +2127,7 @@ public:
return 1; 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) switch (metaAttribute)
{ {
@@ -2133,7 +2169,14 @@ public:
return 1; 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; char val;
std::memcpy(&val, m_buffer + m_offset + 121, sizeof(char)); std::memcpy(&val, m_buffer + m_offset + 121, sizeof(char));
@@ -2147,7 +2190,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2189,7 +2232,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 122, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 122, sizeof(std::uint8_t));
@@ -2203,7 +2253,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2245,7 +2295,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 123, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 123, sizeof(std::uint8_t));
@@ -2259,7 +2316,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2301,7 +2358,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint8_t));
@@ -2315,6 +2379,53 @@ public:
return *this; 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> template<typename CharT, typename Traits>
friend std::basic_ostream<CharT, Traits>& operator << ( friend std::basic_ostream<CharT, Traits>& operator << (
std::basic_ostream<CharT, Traits>& builder, OrderCancelReplaceRequest515 _writer) std::basic_ostream<CharT, Traits>& builder, OrderCancelReplaceRequest515 _writer)
@@ -2429,6 +2540,10 @@ friend std::basic_ostream<CharT, Traits>& operator << (
builder << R"("ShortSaleType": )"; builder << R"("ShortSaleType": )";
builder << '"' << writer.shortSaleType() << '"'; builder << '"' << writer.shortSaleType() << '"';
builder << ", ";
builder << R"("DiscretionPrice": )";
builder << writer.discretionPrice();
builder << '}'; builder << '}';
return builder; return builder;
@@ -2443,13 +2558,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
return true; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
OrderCancelRequest516() = default; OrderCancelRequest516() = default;
OrderCancelRequest516( OrderCancelRequest516(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "F";
} }
@@ -258,7 +260,7 @@ public:
OrderCancelRequest516 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = OrderCancelRequest516( return *this = OrderCancelRequest516(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
OrderCancelRequest516 skipper(m_buffer, m_offset, OrderCancelRequest516 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,12 +338,12 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
case MetaAttribute::SEMANTIC_TYPE: return "int"; case MetaAttribute::SEMANTIC_TYPE: return "int";
case MetaAttribute::PRESENCE: return "required"; case MetaAttribute::PRESENCE: return "optional";
default: return ""; default: return "";
} }
} }
@@ -376,17 +377,17 @@ public:
static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT 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 static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -452,12 +453,12 @@ public:
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -521,7 +522,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -535,7 +543,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -579,12 +587,12 @@ public:
static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -606,7 +614,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -645,17 +653,17 @@ public:
static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -709,7 +717,7 @@ public:
throw std::runtime_error("length too large for getSenderID [E106]"); 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; return length;
} }
@@ -722,7 +730,7 @@ public:
SBE_NODISCARD std::string getSenderIDAsString() const SBE_NODISCARD std::string getSenderIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -767,7 +775,7 @@ public:
SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -779,14 +787,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderCancelRequest516 &putSenderID(const std::string_view str) OrderCancelRequest516 &putSenderID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -796,14 +804,14 @@ public:
#else #else
OrderCancelRequest516 &putSenderID(const std::string& str) OrderCancelRequest516 &putSenderID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -812,7 +820,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -851,17 +859,17 @@ public:
static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT
@@ -915,7 +923,7 @@ public:
throw std::runtime_error("length too large for getClOrdID [E106]"); 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; return length;
} }
@@ -928,7 +936,7 @@ public:
SBE_NODISCARD std::string getClOrdIDAsString() const SBE_NODISCARD std::string getClOrdIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 41; const char *buffer = m_buffer + m_offset + 41;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -973,7 +981,7 @@ public:
SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 41; const char *buffer = m_buffer + m_offset + 41;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -985,14 +993,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderCancelRequest516 &putClOrdID(const std::string_view str) OrderCancelRequest516 &putClOrdID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putClOrdID [E106]"); throw std::runtime_error("string too large for putClOrdID [E106]");
} }
std::memcpy(m_buffer + m_offset + 41, str.data(), srcLength); 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; m_buffer[m_offset + 41 + start] = 0;
} }
@@ -1002,14 +1010,14 @@ public:
#else #else
OrderCancelRequest516 &putClOrdID(const std::string& str) OrderCancelRequest516 &putClOrdID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putClOrdID [E106]"); throw std::runtime_error("string too large for putClOrdID [E106]");
} }
std::memcpy(m_buffer + m_offset + 41, str.c_str(), srcLength); 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; m_buffer[m_offset + 41 + start] = 0;
} }
@@ -1018,7 +1026,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1062,12 +1070,12 @@ public:
static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT
@@ -1089,7 +1097,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1133,12 +1141,12 @@ public:
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1160,7 +1168,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1199,17 +1207,17 @@ public:
static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1263,7 +1271,7 @@ public:
throw std::runtime_error("length too large for getLocation [E106]"); 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; return length;
} }
@@ -1276,7 +1284,7 @@ public:
SBE_NODISCARD std::string getLocationAsString() const SBE_NODISCARD std::string getLocationAsString() const
{ {
const char *buffer = m_buffer + m_offset + 77; const char *buffer = m_buffer + m_offset + 77;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1321,7 +1329,7 @@ public:
SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 77; const char *buffer = m_buffer + m_offset + 77;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1333,14 +1341,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderCancelRequest516 &putLocation(const std::string_view str) OrderCancelRequest516 &putLocation(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 77, str.data(), srcLength); 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; m_buffer[m_offset + 77 + start] = 0;
} }
@@ -1350,14 +1358,14 @@ public:
#else #else
OrderCancelRequest516 &putLocation(const std::string& str) OrderCancelRequest516 &putLocation(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 77, str.c_str(), srcLength); 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; m_buffer[m_offset + 77 + start] = 0;
} }
@@ -1366,7 +1374,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1410,12 +1418,12 @@ public:
static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
{ {
return -2147483647; return INT32_C(-2147483647);
} }
static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
{ {
return 2147483647; return INT32_C(2147483647);
} }
static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -1437,7 +1445,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1479,7 +1487,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 86, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 86, sizeof(std::uint8_t));
@@ -1493,7 +1508,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1535,7 +1550,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 87, sizeof(std::uint8_t)); 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; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class OrderEventType
public: public:
enum Value enum Value
{ {
PartiallyFilled = (std::uint8_t)4, PartiallyFilled = static_cast<std::uint8_t>(4),
Filled = (std::uint8_t)5, Filled = static_cast<std::uint8_t>(5),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static OrderEventType::Value get(const std::uint8_t value) static OrderEventType::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 4: return PartiallyFilled; case static_cast<std::uint8_t>(4): return PartiallyFilled;
case 5: return Filled; case static_cast<std::uint8_t>(5): return Filled;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum OrderEventType [E103]"); 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) switch (value)
{ {
File diff suppressed because it is too large. Load diff
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
OrderMassActionRequest529() = default; OrderMassActionRequest529() = default;
OrderMassActionRequest529( OrderMassActionRequest529(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "CA";
} }
@@ -258,7 +260,7 @@ public:
OrderMassActionRequest529 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = OrderMassActionRequest529( return *this = OrderMassActionRequest529(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
OrderMassActionRequest529 skipper(m_buffer, m_offset, OrderMassActionRequest529 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -381,12 +382,12 @@ public:
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -452,12 +453,12 @@ public:
static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -521,7 +522,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -535,7 +543,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -579,12 +587,12 @@ public:
static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -606,7 +614,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -645,17 +653,17 @@ public:
static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -709,7 +717,7 @@ public:
throw std::runtime_error("length too large for getSenderID [E106]"); 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; return length;
} }
@@ -722,7 +730,7 @@ public:
SBE_NODISCARD std::string getSenderIDAsString() const SBE_NODISCARD std::string getSenderIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -767,7 +775,7 @@ public:
SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -779,14 +787,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderMassActionRequest529 &putSenderID(const std::string_view str) OrderMassActionRequest529 &putSenderID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -796,14 +804,14 @@ public:
#else #else
OrderMassActionRequest529 &putSenderID(const std::string& str) OrderMassActionRequest529 &putSenderID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -812,7 +820,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -851,17 +859,17 @@ public:
static SBE_CONSTEXPR char massActionTypeNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char massActionTypeNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char massActionTypeMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char massActionTypeMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char massActionTypeMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char massActionTypeMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t massActionTypeEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t massActionTypeEncodingLength() SBE_NOEXCEPT
@@ -876,14 +884,14 @@ public:
SBE_NODISCARD const char *massActionType() const 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; return (const char *)massActionTypeValues;
} }
SBE_NODISCARD char massActionType(const std::uint64_t index) const 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]; return (char)massActionTypeValues[index];
} }
@@ -893,7 +901,7 @@ public:
static std::uint8_t massActionTypeValues[] = { 51 }; static std::uint8_t massActionTypeValues[] = { 51 };
std::uint64_t bytesToCopy = length < sizeof(massActionTypeValues) ? length : sizeof(massActionTypeValues); 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; return bytesToCopy;
} }
@@ -937,7 +945,7 @@ public:
return oss.str(); 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) switch (metaAttribute)
{ {
@@ -981,12 +989,12 @@ public:
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -1008,7 +1016,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1047,17 +1055,17 @@ public:
static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t securityGroupEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t securityGroupEncodingLength() SBE_NOEXCEPT
@@ -1111,7 +1119,7 @@ public:
throw std::runtime_error("length too large for getSecurityGroup [E106]"); 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; return length;
} }
@@ -1124,7 +1132,7 @@ public:
SBE_NODISCARD std::string getSecurityGroupAsString() const SBE_NODISCARD std::string getSecurityGroupAsString() const
{ {
const char *buffer = m_buffer + m_offset + 49; const char *buffer = m_buffer + m_offset + 49;
size_t length = 0; std::size_t length = 0;
for (; length < 6 && *(buffer + length) != '\0'; ++length); for (; length < 6 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1169,7 +1177,7 @@ public:
SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 49; const char *buffer = m_buffer + m_offset + 49;
size_t length = 0; std::size_t length = 0;
for (; length < 6 && *(buffer + length) != '\0'; ++length); for (; length < 6 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1181,14 +1189,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderMassActionRequest529 &putSecurityGroup(const std::string_view str) OrderMassActionRequest529 &putSecurityGroup(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 6) if (srcLength > 6)
{ {
throw std::runtime_error("string too large for putSecurityGroup [E106]"); throw std::runtime_error("string too large for putSecurityGroup [E106]");
} }
std::memcpy(m_buffer + m_offset + 49, str.data(), srcLength); 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; m_buffer[m_offset + 49 + start] = 0;
} }
@@ -1198,14 +1206,14 @@ public:
#else #else
OrderMassActionRequest529 &putSecurityGroup(const std::string& str) OrderMassActionRequest529 &putSecurityGroup(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 6) if (srcLength > 6)
{ {
throw std::runtime_error("string too large for putSecurityGroup [E106]"); throw std::runtime_error("string too large for putSecurityGroup [E106]");
} }
std::memcpy(m_buffer + m_offset + 49, str.c_str(), srcLength); 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; m_buffer[m_offset + 49 + start] = 0;
} }
@@ -1214,7 +1222,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1253,17 +1261,17 @@ public:
static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1317,7 +1325,7 @@ public:
throw std::runtime_error("length too large for getLocation [E106]"); 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; return length;
} }
@@ -1330,7 +1338,7 @@ public:
SBE_NODISCARD std::string getLocationAsString() const SBE_NODISCARD std::string getLocationAsString() const
{ {
const char *buffer = m_buffer + m_offset + 55; const char *buffer = m_buffer + m_offset + 55;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1375,7 +1383,7 @@ public:
SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 55; const char *buffer = m_buffer + m_offset + 55;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1387,14 +1395,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderMassActionRequest529 &putLocation(const std::string_view str) OrderMassActionRequest529 &putLocation(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 55, str.data(), srcLength); 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; m_buffer[m_offset + 55 + start] = 0;
} }
@@ -1404,14 +1412,14 @@ public:
#else #else
OrderMassActionRequest529 &putLocation(const std::string& str) OrderMassActionRequest529 &putLocation(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 55, str.c_str(), srcLength); 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; m_buffer[m_offset + 55 + start] = 0;
} }
@@ -1420,7 +1428,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1459,17 +1467,17 @@ public:
static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT
{ {
return 2147483647; return INT32_C(2147483647);
} }
static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
{ {
return -2147483647; return INT32_C(-2147483647);
} }
static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
{ {
return 2147483647; return INT32_C(2147483647);
} }
static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -1491,7 +1499,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1533,7 +1541,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint8_t));
@@ -1547,7 +1562,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1586,17 +1601,17 @@ public:
static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT 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 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 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 static SBE_CONSTEXPR std::size_t marketSegmentIDEncodingLength() SBE_NOEXCEPT
@@ -1618,7 +1633,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1660,7 +1675,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t));
@@ -1674,7 +1696,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1716,7 +1738,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t));
@@ -1730,7 +1759,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1772,7 +1801,14 @@ public:
return 1; 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; char val;
std::memcpy(&val, m_buffer + m_offset + 68, sizeof(char)); std::memcpy(&val, m_buffer + m_offset + 68, sizeof(char));
@@ -1786,7 +1822,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1828,7 +1864,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint8_t));
@@ -1842,7 +1885,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1884,7 +1927,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 70, sizeof(std::uint8_t)); 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; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
OrderMassStatusRequest530() = default; OrderMassStatusRequest530() = default;
OrderMassStatusRequest530( OrderMassStatusRequest530(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "AF";
} }
@@ -258,7 +260,7 @@ public:
OrderMassStatusRequest530 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = OrderMassStatusRequest530( return *this = OrderMassStatusRequest530(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
OrderMassStatusRequest530 skipper(m_buffer, m_offset, OrderMassStatusRequest530 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -381,12 +382,12 @@ public:
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -452,12 +453,12 @@ public:
static SBE_CONSTEXPR std::uint64_t massStatusReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t massStatusReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t massStatusReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t massStatusReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t massStatusReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t massStatusReqIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -521,7 +522,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -535,7 +543,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -579,12 +587,12 @@ public:
static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -606,7 +614,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -645,17 +653,17 @@ public:
static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -709,7 +717,7 @@ public:
throw std::runtime_error("length too large for getSenderID [E106]"); 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; return length;
} }
@@ -722,7 +730,7 @@ public:
SBE_NODISCARD std::string getSenderIDAsString() const SBE_NODISCARD std::string getSenderIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -767,7 +775,7 @@ public:
SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -779,14 +787,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderMassStatusRequest530 &putSenderID(const std::string_view str) OrderMassStatusRequest530 &putSenderID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -796,14 +804,14 @@ public:
#else #else
OrderMassStatusRequest530 &putSenderID(const std::string& str) OrderMassStatusRequest530 &putSenderID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -812,7 +820,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -856,12 +864,12 @@ public:
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -883,7 +891,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -922,17 +930,17 @@ public:
static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t securityGroupEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t securityGroupEncodingLength() SBE_NOEXCEPT
@@ -986,7 +994,7 @@ public:
throw std::runtime_error("length too large for getSecurityGroup [E106]"); 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; return length;
} }
@@ -999,7 +1007,7 @@ public:
SBE_NODISCARD std::string getSecurityGroupAsString() const SBE_NODISCARD std::string getSecurityGroupAsString() const
{ {
const char *buffer = m_buffer + m_offset + 49; const char *buffer = m_buffer + m_offset + 49;
size_t length = 0; std::size_t length = 0;
for (; length < 6 && *(buffer + length) != '\0'; ++length); for (; length < 6 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1044,7 +1052,7 @@ public:
SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 49; const char *buffer = m_buffer + m_offset + 49;
size_t length = 0; std::size_t length = 0;
for (; length < 6 && *(buffer + length) != '\0'; ++length); for (; length < 6 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1056,14 +1064,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderMassStatusRequest530 &putSecurityGroup(const std::string_view str) OrderMassStatusRequest530 &putSecurityGroup(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 6) if (srcLength > 6)
{ {
throw std::runtime_error("string too large for putSecurityGroup [E106]"); throw std::runtime_error("string too large for putSecurityGroup [E106]");
} }
std::memcpy(m_buffer + m_offset + 49, str.data(), srcLength); 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; m_buffer[m_offset + 49 + start] = 0;
} }
@@ -1073,14 +1081,14 @@ public:
#else #else
OrderMassStatusRequest530 &putSecurityGroup(const std::string& str) OrderMassStatusRequest530 &putSecurityGroup(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 6) if (srcLength > 6)
{ {
throw std::runtime_error("string too large for putSecurityGroup [E106]"); throw std::runtime_error("string too large for putSecurityGroup [E106]");
} }
std::memcpy(m_buffer + m_offset + 49, str.c_str(), srcLength); 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; m_buffer[m_offset + 49 + start] = 0;
} }
@@ -1089,7 +1097,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1128,17 +1136,17 @@ public:
static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1192,7 +1200,7 @@ public:
throw std::runtime_error("length too large for getLocation [E106]"); 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; return length;
} }
@@ -1205,7 +1213,7 @@ public:
SBE_NODISCARD std::string getLocationAsString() const SBE_NODISCARD std::string getLocationAsString() const
{ {
const char *buffer = m_buffer + m_offset + 55; const char *buffer = m_buffer + m_offset + 55;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1250,7 +1258,7 @@ public:
SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 55; const char *buffer = m_buffer + m_offset + 55;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1262,14 +1270,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderMassStatusRequest530 &putLocation(const std::string_view str) OrderMassStatusRequest530 &putLocation(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 55, str.data(), srcLength); 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; m_buffer[m_offset + 55 + start] = 0;
} }
@@ -1279,14 +1287,14 @@ public:
#else #else
OrderMassStatusRequest530 &putLocation(const std::string& str) OrderMassStatusRequest530 &putLocation(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 55, str.c_str(), srcLength); 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; m_buffer[m_offset + 55 + start] = 0;
} }
@@ -1295,7 +1303,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1334,17 +1342,17 @@ public:
static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT
{ {
return 2147483647; return INT32_C(2147483647);
} }
static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
{ {
return -2147483647; return INT32_C(-2147483647);
} }
static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
{ {
return 2147483647; return INT32_C(2147483647);
} }
static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -1366,7 +1374,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1408,7 +1416,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint8_t));
@@ -1422,7 +1437,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1464,7 +1479,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 65, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 65, sizeof(std::uint8_t));
@@ -1478,7 +1500,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1520,7 +1542,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t));
@@ -1534,7 +1563,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1573,17 +1602,17 @@ public:
static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT 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 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 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 static SBE_CONSTEXPR std::size_t marketSegmentIDEncodingLength() SBE_NOEXCEPT
@@ -1685,13 +1714,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
return true; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,36 +94,40 @@ class OrderStatus
public: public:
enum Value enum Value
{ {
New = (char)48, New = static_cast<char>(48),
PartiallyFilled = (char)49, PartiallyFilled = static_cast<char>(49),
Filled = (char)50, Filled = static_cast<char>(50),
Cancelled = (char)52, Cancelled = static_cast<char>(52),
Replaced = (char)53, Replaced = static_cast<char>(53),
Rejected = (char)56, PendingCancel = static_cast<char>(54),
Expired = (char)67, Rejected = static_cast<char>(56),
Undefined = (char)85, Expired = static_cast<char>(67),
NULL_VALUE = (char)0 PendingReplace = static_cast<char>(69),
Undefined = static_cast<char>(85),
NULL_VALUE = static_cast<char>(0)
}; };
static OrderStatus::Value get(const char value) static OrderStatus::Value get(const char value)
{ {
switch (value) switch (value)
{ {
case 48: return New; case static_cast<char>(48): return New;
case 49: return PartiallyFilled; case static_cast<char>(49): return PartiallyFilled;
case 50: return Filled; case static_cast<char>(50): return Filled;
case 52: return Cancelled; case static_cast<char>(52): return Cancelled;
case 53: return Replaced; case static_cast<char>(53): return Replaced;
case 56: return Rejected; case static_cast<char>(54): return PendingCancel;
case 67: return Expired; case static_cast<char>(56): return Rejected;
case 85: return Undefined; case static_cast<char>(67): return Expired;
case 0: return NULL_VALUE; 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]"); 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) switch (value)
{ {
@@ -137,8 +136,10 @@ public:
case Filled: return "Filled"; case Filled: return "Filled";
case Cancelled: return "Cancelled"; case Cancelled: return "Cancelled";
case Replaced: return "Replaced"; case Replaced: return "Replaced";
case PendingCancel: return "PendingCancel";
case Rejected: return "Rejected"; case Rejected: return "Rejected";
case Expired: return "Expired"; case Expired: return "Expired";
case PendingReplace: return "PendingReplace";
case Undefined: return "Undefined"; case Undefined: return "Undefined";
case NULL_VALUE: return "NULL_VALUE"; case NULL_VALUE: return "NULL_VALUE";
} }
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
OrderStatusRequest533() = default; OrderStatusRequest533() = default;
OrderStatusRequest533( OrderStatusRequest533(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "H";
} }
@@ -258,7 +260,7 @@ public:
OrderStatusRequest533 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = OrderStatusRequest533( return *this = OrderStatusRequest533(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
OrderStatusRequest533 skipper(m_buffer, m_offset, OrderStatusRequest533 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -381,12 +382,12 @@ public:
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -452,12 +453,12 @@ public:
static SBE_CONSTEXPR std::uint64_t ordStatusReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t ordStatusReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t ordStatusReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t ordStatusReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t ordStatusReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t ordStatusReqIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -521,7 +522,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -535,7 +543,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -579,12 +587,12 @@ public:
static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -606,7 +614,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -645,17 +653,17 @@ public:
static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -709,7 +717,7 @@ public:
throw std::runtime_error("length too large for getSenderID [E106]"); 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; return length;
} }
@@ -722,7 +730,7 @@ public:
SBE_NODISCARD std::string getSenderIDAsString() const SBE_NODISCARD std::string getSenderIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -767,7 +775,7 @@ public:
SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -779,14 +787,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderStatusRequest533 &putSenderID(const std::string_view str) OrderStatusRequest533 &putSenderID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -796,14 +804,14 @@ public:
#else #else
OrderStatusRequest533 &putSenderID(const std::string& str) OrderStatusRequest533 &putSenderID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -812,7 +820,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -856,12 +864,12 @@ public:
static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT
@@ -883,7 +891,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -927,12 +935,12 @@ public:
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -954,7 +962,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -993,17 +1001,17 @@ public:
static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -1057,7 +1065,7 @@ public:
throw std::runtime_error("length too large for getLocation [E106]"); 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; return length;
} }
@@ -1070,7 +1078,7 @@ public:
SBE_NODISCARD std::string getLocationAsString() const SBE_NODISCARD std::string getLocationAsString() const
{ {
const char *buffer = m_buffer + m_offset + 57; const char *buffer = m_buffer + m_offset + 57;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1115,7 +1123,7 @@ public:
SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 57; const char *buffer = m_buffer + m_offset + 57;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1127,14 +1135,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
OrderStatusRequest533 &putLocation(const std::string_view str) OrderStatusRequest533 &putLocation(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 57, str.data(), srcLength); 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; m_buffer[m_offset + 57 + start] = 0;
} }
@@ -1144,14 +1152,14 @@ public:
#else #else
OrderStatusRequest533 &putLocation(const std::string& str) OrderStatusRequest533 &putLocation(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 57, str.c_str(), srcLength); 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; m_buffer[m_offset + 57 + start] = 0;
} }
@@ -1219,13 +1227,13 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
return true; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,28 +94,28 @@ class OrderType
public: public:
enum Value enum Value
{ {
MarketWithProtection = (char)49, MarketWithProtection = static_cast<char>(49),
Limit = (char)50, Limit = static_cast<char>(50),
StopLimit = (char)52, StopLimit = static_cast<char>(52),
MarketWithLeftoverAsLimit = (char)75, MarketWithLeftoverAsLimit = static_cast<char>(75),
NULL_VALUE = (char)0 NULL_VALUE = static_cast<char>(0)
}; };
static OrderType::Value get(const char value) static OrderType::Value get(const char value)
{ {
switch (value) switch (value)
{ {
case 49: return MarketWithProtection; case static_cast<char>(49): return MarketWithProtection;
case 50: return Limit; case static_cast<char>(50): return Limit;
case 52: return StopLimit; case static_cast<char>(52): return StopLimit;
case 75: return MarketWithLeftoverAsLimit; case static_cast<char>(75): return MarketWithLeftoverAsLimit;
case 0: return NULL_VALUE; case static_cast<char>(0): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum OrderType [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,30 +94,30 @@ class OrderTypeReq
public: public:
enum Value enum Value
{ {
MarketwithProtection = (char)49, MarketwithProtection = static_cast<char>(49),
Limit = (char)50, Limit = static_cast<char>(50),
StopwithProtection = (char)51, StopwithProtection = static_cast<char>(51),
StopLimit = (char)52, StopLimit = static_cast<char>(52),
MarketWithLeftoverAsLimit = (char)75, MarketWithLeftoverAsLimit = static_cast<char>(75),
NULL_VALUE = (char)0 NULL_VALUE = static_cast<char>(0)
}; };
static OrderTypeReq::Value get(const char value) static OrderTypeReq::Value get(const char value)
{ {
switch (value) switch (value)
{ {
case 49: return MarketwithProtection; case static_cast<char>(49): return MarketwithProtection;
case 50: return Limit; case static_cast<char>(50): return Limit;
case 51: return StopwithProtection; case static_cast<char>(51): return StopwithProtection;
case 52: return StopLimit; case static_cast<char>(52): return StopLimit;
case 75: return MarketWithLeftoverAsLimit; case static_cast<char>(75): return MarketWithLeftoverAsLimit;
case 0: return NULL_VALUE; case static_cast<char>(0): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum OrderTypeReq [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -172,12 +167,12 @@ public:
return m_offset; return m_offset;
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -194,15 +189,15 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT 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 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) switch (metaAttribute)
{ {
@@ -245,12 +240,12 @@ public:
static SBE_CONSTEXPR std::int64_t mantissaMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int64_t mantissaMinValue() SBE_NOEXCEPT
{ {
return -9223372036854775807L; return INT64_C(-9223372036854775807);
} }
static SBE_CONSTEXPR std::int64_t mantissaMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int64_t mantissaMaxValue() SBE_NOEXCEPT
{ {
return 9223372036854775807L; return INT64_C(9223372036854775807);
} }
static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT
@@ -272,7 +267,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -315,12 +310,12 @@ public:
static SBE_CONSTEXPR std::int8_t exponentMinValue() SBE_NOEXCEPT 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 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 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 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> template<typename CharT, typename Traits>
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -172,12 +167,12 @@ public:
return m_offset; return m_offset;
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -194,15 +189,15 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT 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 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) switch (metaAttribute)
{ {
@@ -240,17 +235,17 @@ public:
static SBE_CONSTEXPR std::int64_t mantissaNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int64_t mantissaNullValue() SBE_NOEXCEPT
{ {
return 9223372036854775807L; return INT64_C(9223372036854775807);
} }
static SBE_CONSTEXPR std::int64_t mantissaMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int64_t mantissaMinValue() SBE_NOEXCEPT
{ {
return -9223372036854775807L; return INT64_C(-9223372036854775807);
} }
static SBE_CONSTEXPR std::int64_t mantissaMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int64_t mantissaMaxValue() SBE_NOEXCEPT
{ {
return 9223372036854775807L; return INT64_C(9223372036854775807);
} }
static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT
@@ -272,7 +267,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -315,12 +310,12 @@ public:
static SBE_CONSTEXPR std::int8_t exponentMinValue() SBE_NOEXCEPT 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 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 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 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> template<typename CharT, typename Traits>
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,30 +94,30 @@ class PartyDetailRole
public: public:
enum Value enum Value
{ {
ExecutingFirm = (std::uint16_t)1, ExecutingFirm = static_cast<std::uint16_t>(1),
CustomerAccount = (std::uint16_t)24, CustomerAccount = static_cast<std::uint16_t>(24),
TakeUpFirm = (std::uint16_t)96, TakeUpFirm = static_cast<std::uint16_t>(96),
Operator = (std::uint16_t)118, Operator = static_cast<std::uint16_t>(118),
TakeUpAccount = (std::uint16_t)1000, TakeUpAccount = static_cast<std::uint16_t>(1000),
NULL_VALUE = (std::uint16_t)65535 NULL_VALUE = static_cast<std::uint16_t>(65535)
}; };
static PartyDetailRole::Value get(const std::uint16_t value) static PartyDetailRole::Value get(const std::uint16_t value)
{ {
switch (value) switch (value)
{ {
case 1: return ExecutingFirm; case static_cast<std::uint16_t>(1): return ExecutingFirm;
case 24: return CustomerAccount; case static_cast<std::uint16_t>(24): return CustomerAccount;
case 96: return TakeUpFirm; case static_cast<std::uint16_t>(96): return TakeUpFirm;
case 118: return Operator; case static_cast<std::uint16_t>(118): return Operator;
case 1000: return TakeUpAccount; case static_cast<std::uint16_t>(1000): return TakeUpAccount;
case 65535: return NULL_VALUE; case static_cast<std::uint16_t>(65535): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum PartyDetailRole [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
PartyDetailsDefinitionRequest518() = default; PartyDetailsDefinitionRequest518() = default;
PartyDetailsDefinitionRequest518( PartyDetailsDefinitionRequest518(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "CX";
} }
@@ -258,7 +260,7 @@ public:
PartyDetailsDefinitionRequest518 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = PartyDetailsDefinitionRequest518( return *this = PartyDetailsDefinitionRequest518(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
PartyDetailsDefinitionRequest518 skipper(m_buffer, m_offset, PartyDetailsDefinitionRequest518 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -381,12 +382,12 @@ public:
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -452,12 +453,12 @@ public:
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -521,7 +522,14 @@ public:
return 1; 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; char val;
std::memcpy(&val, m_buffer + m_offset + 16, sizeof(char)); std::memcpy(&val, m_buffer + m_offset + 16, sizeof(char));
@@ -535,7 +543,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -579,12 +587,12 @@ public:
static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -606,7 +614,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -645,17 +653,17 @@ public:
static SBE_CONSTEXPR char memoNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char memoNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char memoMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char memoMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char memoMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char memoMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t memoEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t memoEncodingLength() SBE_NOEXCEPT
@@ -709,7 +717,7 @@ public:
throw std::runtime_error("length too large for getMemo [E106]"); 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; return length;
} }
@@ -722,7 +730,7 @@ public:
SBE_NODISCARD std::string getMemoAsString() const SBE_NODISCARD std::string getMemoAsString() const
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 75 && *(buffer + length) != '\0'; ++length); for (; length < 75 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -767,7 +775,7 @@ public:
SBE_NODISCARD std::string_view getMemoAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getMemoAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 75 && *(buffer + length) != '\0'; ++length); for (; length < 75 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -779,14 +787,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
PartyDetailsDefinitionRequest518 &putMemo(const std::string_view str) PartyDetailsDefinitionRequest518 &putMemo(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 75) if (srcLength > 75)
{ {
throw std::runtime_error("string too large for putMemo [E106]"); throw std::runtime_error("string too large for putMemo [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -796,14 +804,14 @@ public:
#else #else
PartyDetailsDefinitionRequest518 &putMemo(const std::string& str) PartyDetailsDefinitionRequest518 &putMemo(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 75) if (srcLength > 75)
{ {
throw std::runtime_error("string too large for putMemo [E106]"); throw std::runtime_error("string too large for putMemo [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -812,7 +820,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -851,17 +859,17 @@ public:
static SBE_CONSTEXPR char avgPxGroupIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char avgPxGroupIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char avgPxGroupIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char avgPxGroupIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char avgPxGroupIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char avgPxGroupIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t avgPxGroupIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t avgPxGroupIDEncodingLength() SBE_NOEXCEPT
@@ -915,7 +923,7 @@ public:
throw std::runtime_error("length too large for getAvgPxGroupID [E106]"); 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; return length;
} }
@@ -928,7 +936,7 @@ public:
SBE_NODISCARD std::string getAvgPxGroupIDAsString() const SBE_NODISCARD std::string getAvgPxGroupIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 96; const char *buffer = m_buffer + m_offset + 96;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -973,7 +981,7 @@ public:
SBE_NODISCARD std::string_view getAvgPxGroupIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getAvgPxGroupIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 96; const char *buffer = m_buffer + m_offset + 96;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -985,14 +993,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
PartyDetailsDefinitionRequest518 &putAvgPxGroupID(const std::string_view str) PartyDetailsDefinitionRequest518 &putAvgPxGroupID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putAvgPxGroupID [E106]"); throw std::runtime_error("string too large for putAvgPxGroupID [E106]");
} }
std::memcpy(m_buffer + m_offset + 96, str.data(), srcLength); 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; m_buffer[m_offset + 96 + start] = 0;
} }
@@ -1002,14 +1010,14 @@ public:
#else #else
PartyDetailsDefinitionRequest518 &putAvgPxGroupID(const std::string& str) PartyDetailsDefinitionRequest518 &putAvgPxGroupID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putAvgPxGroupID [E106]"); throw std::runtime_error("string too large for putAvgPxGroupID [E106]");
} }
std::memcpy(m_buffer + m_offset + 96, str.c_str(), srcLength); 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; m_buffer[m_offset + 96 + start] = 0;
} }
@@ -1018,7 +1026,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1057,17 +1065,17 @@ public:
static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDNullValue() SBE_NOEXCEPT
{ {
return 0xffffffffffffffffL; return UINT64_C(0xffffffffffffffff);
} }
static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t selfMatchPreventionIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t selfMatchPreventionIDEncodingLength() SBE_NOEXCEPT
@@ -1089,7 +1097,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1131,7 +1139,14 @@ public:
return 1; 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; char val;
std::memcpy(&val, m_buffer + m_offset + 124, sizeof(char)); std::memcpy(&val, m_buffer + m_offset + 124, sizeof(char));
@@ -1145,7 +1160,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1187,7 +1202,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 125, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 125, sizeof(std::uint8_t));
@@ -1201,7 +1223,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1243,7 +1265,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 126, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 126, sizeof(std::uint8_t));
@@ -1257,7 +1286,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1299,7 +1328,14 @@ public:
return 1; 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; char val;
std::memcpy(&val, m_buffer + m_offset + 127, sizeof(char)); std::memcpy(&val, m_buffer + m_offset + 127, sizeof(char));
@@ -1313,7 +1349,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1355,7 +1391,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 128, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 128, sizeof(std::uint8_t));
@@ -1369,7 +1412,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1411,7 +1454,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 129, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 129, sizeof(std::uint8_t));
@@ -1425,7 +1475,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1467,7 +1517,14 @@ public:
return 1; 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; char val;
std::memcpy(&val, m_buffer + m_offset + 130, sizeof(char)); std::memcpy(&val, m_buffer + m_offset + 130, sizeof(char));
@@ -1481,7 +1538,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1520,17 +1577,17 @@ public:
static SBE_CONSTEXPR std::uint64_t executorNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t executorNullValue() SBE_NOEXCEPT
{ {
return 0xffffffffffffffffL; return UINT64_C(0xffffffffffffffff);
} }
static SBE_CONSTEXPR std::uint64_t executorMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t executorMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t executorMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t executorMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t executorEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t executorEncodingLength() SBE_NOEXCEPT
@@ -1552,7 +1609,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1591,17 +1648,17 @@ public:
static SBE_CONSTEXPR std::uint64_t iDMShortCodeNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t iDMShortCodeNullValue() SBE_NOEXCEPT
{ {
return 0xffffffffffffffffL; return UINT64_C(0xffffffffffffffff);
} }
static SBE_CONSTEXPR std::uint64_t iDMShortCodeMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t iDMShortCodeMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t iDMShortCodeMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t iDMShortCodeMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t iDMShortCodeEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t iDMShortCodeEncodingLength() SBE_NOEXCEPT
@@ -1623,7 +1680,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1667,12 +1724,12 @@ public:
static SBE_CONSTEXPR std::uint8_t noPartyUpdatesMinValue() SBE_NOEXCEPT 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 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 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 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 class NoPartyDetails
@@ -1743,8 +1800,8 @@ public:
m_buffer = buffer; m_buffer = buffer;
m_bufferLength = bufferLength; m_bufferLength = bufferLength;
GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
dimensions.blockLength((std::uint16_t)22); dimensions.blockLength(static_cast<std::uint16_t>(22));
dimensions.numInGroup((std::uint8_t)count); dimensions.numInGroup(static_cast<std::uint8_t>(count));
m_index = 0; m_index = 0;
m_count = count; m_count = count;
m_blockLength = 22; m_blockLength = 22;
@@ -1815,7 +1872,7 @@ public:
{ {
m_count = m_index; m_count = m_index;
GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); 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; return m_count;
} }
@@ -1841,7 +1898,7 @@ public:
#endif #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) switch (metaAttribute)
{ {
@@ -1880,17 +1937,17 @@ public:
static SBE_CONSTEXPR char partyDetailIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char partyDetailIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char partyDetailIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char partyDetailIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char partyDetailIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char partyDetailIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t partyDetailIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailIDEncodingLength() SBE_NOEXCEPT
@@ -1944,7 +2001,7 @@ public:
throw std::runtime_error("length too large for getPartyDetailID [E106]"); 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; return length;
} }
@@ -1957,7 +2014,7 @@ public:
SBE_NODISCARD std::string getPartyDetailIDAsString() const SBE_NODISCARD std::string getPartyDetailIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 0; const char *buffer = m_buffer + m_offset + 0;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -2002,7 +2059,7 @@ public:
SBE_NODISCARD std::string_view getPartyDetailIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getPartyDetailIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 0; const char *buffer = m_buffer + m_offset + 0;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -2014,14 +2071,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
NoPartyDetails &putPartyDetailID(const std::string_view str) NoPartyDetails &putPartyDetailID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putPartyDetailID [E106]"); throw std::runtime_error("string too large for putPartyDetailID [E106]");
} }
std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); 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; m_buffer[m_offset + 0 + start] = 0;
} }
@@ -2031,14 +2088,14 @@ public:
#else #else
NoPartyDetails &putPartyDetailID(const std::string& str) NoPartyDetails &putPartyDetailID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putPartyDetailID [E106]"); throw std::runtime_error("string too large for putPartyDetailID [E106]");
} }
std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); 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; m_buffer[m_offset + 0 + start] = 0;
} }
@@ -2047,7 +2104,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -2086,17 +2143,17 @@ public:
static SBE_CONSTEXPR char partyDetailIDSourceNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char partyDetailIDSourceNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char partyDetailIDSourceMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char partyDetailIDSourceMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char partyDetailIDSourceMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char partyDetailIDSourceMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t partyDetailIDSourceEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailIDSourceEncodingLength() SBE_NOEXCEPT
@@ -2111,14 +2168,14 @@ public:
SBE_NODISCARD const char *partyDetailIDSource() const 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; return (const char *)partyDetailIDSourceValues;
} }
SBE_NODISCARD char partyDetailIDSource(const std::uint64_t index) const 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]; return (char)partyDetailIDSourceValues[index];
} }
@@ -2128,7 +2185,7 @@ public:
static std::uint8_t partyDetailIDSourceValues[] = { 67 }; static std::uint8_t partyDetailIDSourceValues[] = { 67 };
std::uint64_t bytesToCopy = length < sizeof(partyDetailIDSourceValues) ? length : sizeof(partyDetailIDSourceValues); 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; return bytesToCopy;
} }
@@ -2172,7 +2229,7 @@ public:
return oss.str(); 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) switch (metaAttribute)
{ {
@@ -2214,7 +2271,14 @@ public:
return 2; 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::uint16_t val;
std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint16_t)); std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint16_t));
@@ -2255,13 +2319,13 @@ public:
return true; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -2366,8 +2430,8 @@ public:
m_buffer = buffer; m_buffer = buffer;
m_bufferLength = bufferLength; m_bufferLength = bufferLength;
GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
dimensions.blockLength((std::uint16_t)2); dimensions.blockLength(static_cast<std::uint16_t>(2));
dimensions.numInGroup((std::uint8_t)count); dimensions.numInGroup(static_cast<std::uint8_t>(count));
m_index = 0; m_index = 0;
m_count = count; m_count = count;
m_blockLength = 2; m_blockLength = 2;
@@ -2438,7 +2502,7 @@ public:
{ {
m_count = m_index; m_count = m_index;
GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); 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; return m_count;
} }
@@ -2464,7 +2528,7 @@ public:
#endif #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) switch (metaAttribute)
{ {
@@ -2508,12 +2572,12 @@ public:
static SBE_CONSTEXPR std::uint8_t trdRegPublicationTypeMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t trdRegPublicationTypeEncodingLength() SBE_NOEXCEPT
@@ -2535,7 +2599,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2579,12 +2643,12 @@ public:
static SBE_CONSTEXPR std::uint8_t trdRegPublicationReasonMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t trdRegPublicationReasonEncodingLength() SBE_NOEXCEPT
@@ -2632,13 +2696,13 @@ public:
return true; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -2816,30 +2880,30 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
return false; return false;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength( SBE_NODISCARD static std::size_t computeLength(
std::size_t NoPartyDetailsLength = 0, std::size_t noPartyDetailsLength = 0,
std::size_t NoTrdRegPublicationsLength = 0) std::size_t noTrdRegPublicationsLength = 0)
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
length += NoPartyDetails::sbeHeaderSize(); 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(); 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; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
File diff suppressed because it is too large. Load diff
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
PartyDetailsListReport538() = default; PartyDetailsListReport538() = default;
PartyDetailsListReport538( PartyDetailsListReport538(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "CG";
} }
@@ -258,7 +260,7 @@ public:
PartyDetailsListReport538 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = PartyDetailsListReport538( return *this = PartyDetailsListReport538(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
PartyDetailsListReport538 skipper(m_buffer, m_offset, PartyDetailsListReport538 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -381,12 +382,12 @@ public:
static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -452,12 +453,12 @@ public:
static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -518,17 +519,17 @@ public:
static SBE_CONSTEXPR char avgPxGroupIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char avgPxGroupIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char avgPxGroupIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char avgPxGroupIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char avgPxGroupIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char avgPxGroupIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t avgPxGroupIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t avgPxGroupIDEncodingLength() SBE_NOEXCEPT
@@ -582,7 +583,7 @@ public:
throw std::runtime_error("length too large for getAvgPxGroupID [E106]"); 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; return length;
} }
@@ -595,7 +596,7 @@ public:
SBE_NODISCARD std::string getAvgPxGroupIDAsString() const SBE_NODISCARD std::string getAvgPxGroupIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 12; const char *buffer = m_buffer + m_offset + 12;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -640,7 +641,7 @@ public:
SBE_NODISCARD std::string_view getAvgPxGroupIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getAvgPxGroupIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 12; const char *buffer = m_buffer + m_offset + 12;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -652,14 +653,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
PartyDetailsListReport538 &putAvgPxGroupID(const std::string_view str) PartyDetailsListReport538 &putAvgPxGroupID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putAvgPxGroupID [E106]"); throw std::runtime_error("string too large for putAvgPxGroupID [E106]");
} }
std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); 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; m_buffer[m_offset + 12 + start] = 0;
} }
@@ -669,14 +670,14 @@ public:
#else #else
PartyDetailsListReport538 &putAvgPxGroupID(const std::string& str) PartyDetailsListReport538 &putAvgPxGroupID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putAvgPxGroupID [E106]"); throw std::runtime_error("string too large for putAvgPxGroupID [E106]");
} }
std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); 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; m_buffer[m_offset + 12 + start] = 0;
} }
@@ -685,7 +686,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -729,12 +730,12 @@ public:
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -756,7 +757,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -800,12 +801,12 @@ public:
static SBE_CONSTEXPR std::uint64_t partyDetailsListReportIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReportIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t partyDetailsListReportIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReportIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t partyDetailsListReportIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailsListReportIDEncodingLength() SBE_NOEXCEPT
@@ -827,7 +828,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -871,12 +872,12 @@ public:
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -898,7 +899,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -937,17 +938,17 @@ public:
static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDNullValue() SBE_NOEXCEPT
{ {
return 0xffffffffffffffffL; return UINT64_C(0xffffffffffffffff);
} }
static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t selfMatchPreventionIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t selfMatchPreventionIDEncodingLength() SBE_NOEXCEPT
@@ -969,7 +970,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1013,12 +1014,12 @@ public:
static SBE_CONSTEXPR std::uint16_t totNumPartiesMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t totNumPartiesEncodingLength() SBE_NOEXCEPT
@@ -1040,7 +1041,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1082,7 +1083,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t));
@@ -1096,7 +1104,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1138,7 +1146,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t));
@@ -1152,7 +1167,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1194,7 +1209,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 68, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 68, sizeof(std::uint8_t));
@@ -1208,7 +1230,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1250,7 +1272,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint8_t));
@@ -1264,7 +1293,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1306,7 +1335,14 @@ public:
return 1; 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; char val;
std::memcpy(&val, m_buffer + m_offset + 70, sizeof(char)); std::memcpy(&val, m_buffer + m_offset + 70, sizeof(char));
@@ -1320,7 +1356,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1362,7 +1398,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 71, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 71, sizeof(std::uint8_t));
@@ -1376,7 +1419,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1418,7 +1461,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 72, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 72, sizeof(std::uint8_t));
@@ -1432,7 +1482,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1474,7 +1524,14 @@ public:
return 1; 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; char val;
std::memcpy(&val, m_buffer + m_offset + 73, sizeof(char)); std::memcpy(&val, m_buffer + m_offset + 73, sizeof(char));
@@ -1488,7 +1545,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1530,7 +1587,14 @@ public:
return 1; 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; char val;
std::memcpy(&val, m_buffer + m_offset + 74, sizeof(char)); std::memcpy(&val, m_buffer + m_offset + 74, sizeof(char));
@@ -1544,7 +1608,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1583,17 +1647,17 @@ public:
static SBE_CONSTEXPR std::uint64_t executorNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t executorNullValue() SBE_NOEXCEPT
{ {
return 0xffffffffffffffffL; return UINT64_C(0xffffffffffffffff);
} }
static SBE_CONSTEXPR std::uint64_t executorMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t executorMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t executorMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t executorMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t executorEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t executorEncodingLength() SBE_NOEXCEPT
@@ -1615,7 +1679,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1654,17 +1718,17 @@ public:
static SBE_CONSTEXPR std::uint64_t iDMShortCodeNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t iDMShortCodeNullValue() SBE_NOEXCEPT
{ {
return 0xffffffffffffffffL; return UINT64_C(0xffffffffffffffff);
} }
static SBE_CONSTEXPR std::uint64_t iDMShortCodeMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t iDMShortCodeMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t iDMShortCodeMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t iDMShortCodeMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t iDMShortCodeEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t iDMShortCodeEncodingLength() SBE_NOEXCEPT
@@ -1686,7 +1750,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1728,7 +1792,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 91, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 91, sizeof(std::uint8_t));
@@ -1742,7 +1813,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1784,7 +1855,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint8_t));
@@ -1856,8 +1934,8 @@ public:
m_buffer = buffer; m_buffer = buffer;
m_bufferLength = bufferLength; m_bufferLength = bufferLength;
GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
dimensions.blockLength((std::uint16_t)22); dimensions.blockLength(static_cast<std::uint16_t>(22));
dimensions.numInGroup((std::uint8_t)count); dimensions.numInGroup(static_cast<std::uint8_t>(count));
m_index = 0; m_index = 0;
m_count = count; m_count = count;
m_blockLength = 22; m_blockLength = 22;
@@ -1928,7 +2006,7 @@ public:
{ {
m_count = m_index; m_count = m_index;
GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); 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; return m_count;
} }
@@ -1954,7 +2032,7 @@ public:
#endif #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) switch (metaAttribute)
{ {
@@ -1993,17 +2071,17 @@ public:
static SBE_CONSTEXPR char partyDetailIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char partyDetailIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char partyDetailIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char partyDetailIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char partyDetailIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char partyDetailIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t partyDetailIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailIDEncodingLength() SBE_NOEXCEPT
@@ -2057,7 +2135,7 @@ public:
throw std::runtime_error("length too large for getPartyDetailID [E106]"); 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; return length;
} }
@@ -2070,7 +2148,7 @@ public:
SBE_NODISCARD std::string getPartyDetailIDAsString() const SBE_NODISCARD std::string getPartyDetailIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 0; const char *buffer = m_buffer + m_offset + 0;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -2115,7 +2193,7 @@ public:
SBE_NODISCARD std::string_view getPartyDetailIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getPartyDetailIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 0; const char *buffer = m_buffer + m_offset + 0;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -2127,14 +2205,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
NoPartyDetails &putPartyDetailID(const std::string_view str) NoPartyDetails &putPartyDetailID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putPartyDetailID [E106]"); throw std::runtime_error("string too large for putPartyDetailID [E106]");
} }
std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); 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; m_buffer[m_offset + 0 + start] = 0;
} }
@@ -2144,14 +2222,14 @@ public:
#else #else
NoPartyDetails &putPartyDetailID(const std::string& str) NoPartyDetails &putPartyDetailID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putPartyDetailID [E106]"); throw std::runtime_error("string too large for putPartyDetailID [E106]");
} }
std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); 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; m_buffer[m_offset + 0 + start] = 0;
} }
@@ -2160,7 +2238,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -2199,17 +2277,17 @@ public:
static SBE_CONSTEXPR char partyDetailIDSourceNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char partyDetailIDSourceNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char partyDetailIDSourceMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char partyDetailIDSourceMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char partyDetailIDSourceMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char partyDetailIDSourceMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t partyDetailIDSourceEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailIDSourceEncodingLength() SBE_NOEXCEPT
@@ -2224,14 +2302,14 @@ public:
SBE_NODISCARD const char *partyDetailIDSource() const 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; return (const char *)partyDetailIDSourceValues;
} }
SBE_NODISCARD char partyDetailIDSource(const std::uint64_t index) const 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]; return (char)partyDetailIDSourceValues[index];
} }
@@ -2241,7 +2319,7 @@ public:
static std::uint8_t partyDetailIDSourceValues[] = { 67 }; static std::uint8_t partyDetailIDSourceValues[] = { 67 };
std::uint64_t bytesToCopy = length < sizeof(partyDetailIDSourceValues) ? length : sizeof(partyDetailIDSourceValues); 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; return bytesToCopy;
} }
@@ -2285,7 +2363,7 @@ public:
return oss.str(); 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) switch (metaAttribute)
{ {
@@ -2327,7 +2405,14 @@ public:
return 2; 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::uint16_t val;
std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint16_t)); std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint16_t));
@@ -2368,13 +2453,13 @@ public:
return true; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -2479,8 +2564,8 @@ public:
m_buffer = buffer; m_buffer = buffer;
m_bufferLength = bufferLength; m_bufferLength = bufferLength;
GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
dimensions.blockLength((std::uint16_t)2); dimensions.blockLength(static_cast<std::uint16_t>(2));
dimensions.numInGroup((std::uint8_t)count); dimensions.numInGroup(static_cast<std::uint8_t>(count));
m_index = 0; m_index = 0;
m_count = count; m_count = count;
m_blockLength = 2; m_blockLength = 2;
@@ -2551,7 +2636,7 @@ public:
{ {
m_count = m_index; m_count = m_index;
GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); 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; return m_count;
} }
@@ -2577,7 +2662,7 @@ public:
#endif #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) switch (metaAttribute)
{ {
@@ -2621,12 +2706,12 @@ public:
static SBE_CONSTEXPR std::uint8_t trdRegPublicationTypeMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t trdRegPublicationTypeEncodingLength() SBE_NOEXCEPT
@@ -2648,7 +2733,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2692,12 +2777,12 @@ public:
static SBE_CONSTEXPR std::uint8_t trdRegPublicationReasonMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t trdRegPublicationReasonEncodingLength() SBE_NOEXCEPT
@@ -2745,13 +2830,13 @@ public:
return true; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -2948,30 +3033,30 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
return false; return false;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength( SBE_NODISCARD static std::size_t computeLength(
std::size_t NoPartyDetailsLength = 0, std::size_t noPartyDetailsLength = 0,
std::size_t NoTrdRegPublicationsLength = 0) std::size_t noTrdRegPublicationsLength = 0)
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
length += NoPartyDetails::sbeHeaderSize(); 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(); 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; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
PartyDetailsListRequest537() = default; PartyDetailsListRequest537() = default;
PartyDetailsListRequest537( PartyDetailsListRequest537(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "CF";
} }
@@ -258,7 +260,7 @@ public:
PartyDetailsListRequest537 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = PartyDetailsListRequest537( return *this = PartyDetailsListRequest537(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
PartyDetailsListRequest537 skipper(m_buffer, m_offset, PartyDetailsListRequest537 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -381,12 +382,12 @@ public:
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -452,12 +453,12 @@ public:
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -523,12 +524,12 @@ public:
static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -608,8 +609,8 @@ public:
m_buffer = buffer; m_buffer = buffer;
m_bufferLength = bufferLength; m_bufferLength = bufferLength;
GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
dimensions.blockLength((std::uint16_t)7); dimensions.blockLength(static_cast<std::uint16_t>(7));
dimensions.numInGroup((std::uint8_t)count); dimensions.numInGroup(static_cast<std::uint8_t>(count));
m_index = 0; m_index = 0;
m_count = count; m_count = count;
m_blockLength = 7; m_blockLength = 7;
@@ -680,7 +681,7 @@ public:
{ {
m_count = m_index; m_count = m_index;
GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); 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; return m_count;
} }
@@ -706,7 +707,7 @@ public:
#endif #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) switch (metaAttribute)
{ {
@@ -745,17 +746,17 @@ public:
static SBE_CONSTEXPR char requestingPartyIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char requestingPartyIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char requestingPartyIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char requestingPartyIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char requestingPartyIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char requestingPartyIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t requestingPartyIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t requestingPartyIDEncodingLength() SBE_NOEXCEPT
@@ -809,7 +810,7 @@ public:
throw std::runtime_error("length too large for getRequestingPartyID [E106]"); 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; return length;
} }
@@ -822,7 +823,7 @@ public:
SBE_NODISCARD std::string getRequestingPartyIDAsString() const SBE_NODISCARD std::string getRequestingPartyIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 0; const char *buffer = m_buffer + m_offset + 0;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -867,7 +868,7 @@ public:
SBE_NODISCARD std::string_view getRequestingPartyIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getRequestingPartyIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 0; const char *buffer = m_buffer + m_offset + 0;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -879,14 +880,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
NoRequestingPartyIDs &putRequestingPartyID(const std::string_view str) NoRequestingPartyIDs &putRequestingPartyID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putRequestingPartyID [E106]"); throw std::runtime_error("string too large for putRequestingPartyID [E106]");
} }
std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); 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; m_buffer[m_offset + 0 + start] = 0;
} }
@@ -896,14 +897,14 @@ public:
#else #else
NoRequestingPartyIDs &putRequestingPartyID(const std::string& str) NoRequestingPartyIDs &putRequestingPartyID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putRequestingPartyID [E106]"); throw std::runtime_error("string too large for putRequestingPartyID [E106]");
} }
std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); 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; m_buffer[m_offset + 0 + start] = 0;
} }
@@ -912,7 +913,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -951,17 +952,17 @@ public:
static SBE_CONSTEXPR char requestingPartyIDSourceNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char requestingPartyIDSourceNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char requestingPartyIDSourceMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char requestingPartyIDSourceMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char requestingPartyIDSourceMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char requestingPartyIDSourceMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t requestingPartyIDSourceEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t requestingPartyIDSourceEncodingLength() SBE_NOEXCEPT
@@ -983,7 +984,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1022,17 +1023,17 @@ public:
static SBE_CONSTEXPR char requestingPartyRoleNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char requestingPartyRoleNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char requestingPartyRoleMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char requestingPartyRoleMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char requestingPartyRoleMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char requestingPartyRoleMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t requestingPartyRoleEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t requestingPartyRoleEncodingLength() SBE_NOEXCEPT
@@ -1099,13 +1100,13 @@ public:
return true; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -1210,8 +1211,8 @@ public:
m_buffer = buffer; m_buffer = buffer;
m_bufferLength = bufferLength; m_bufferLength = bufferLength;
GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
dimensions.blockLength((std::uint16_t)11); dimensions.blockLength(static_cast<std::uint16_t>(11));
dimensions.numInGroup((std::uint8_t)count); dimensions.numInGroup(static_cast<std::uint8_t>(count));
m_index = 0; m_index = 0;
m_count = count; m_count = count;
m_blockLength = 11; m_blockLength = 11;
@@ -1282,7 +1283,7 @@ public:
{ {
m_count = m_index; m_count = m_index;
GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); 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; return m_count;
} }
@@ -1308,7 +1309,7 @@ public:
#endif #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) switch (metaAttribute)
{ {
@@ -1352,12 +1353,12 @@ public:
static SBE_CONSTEXPR std::uint64_t partyIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t partyIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t partyIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyIDEncodingLength() SBE_NOEXCEPT
@@ -1379,7 +1380,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1418,17 +1419,17 @@ public:
static SBE_CONSTEXPR char partyIDSourceNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char partyIDSourceNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char partyIDSourceMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char partyIDSourceMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char partyIDSourceMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char partyIDSourceMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t partyIDSourceEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyIDSourceEncodingLength() SBE_NOEXCEPT
@@ -1450,7 +1451,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1494,12 +1495,12 @@ public:
static SBE_CONSTEXPR std::uint16_t partyRoleMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t partyRoleEncodingLength() SBE_NOEXCEPT
@@ -1558,13 +1559,13 @@ public:
return true; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -1688,30 +1689,30 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
return false; return false;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength( SBE_NODISCARD static std::size_t computeLength(
std::size_t NoRequestingPartyIDsLength = 0, std::size_t noRequestingPartyIDsLength = 0,
std::size_t NoPartyIDsLength = 0) std::size_t noPartyIDsLength = 0)
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
length += NoRequestingPartyIDs::sbeHeaderSize(); 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(); 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; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,24 +94,24 @@ class QuoteAckStatus
public: public:
enum Value enum Value
{ {
Accepted = (std::uint8_t)0, Accepted = static_cast<std::uint8_t>(0),
Rejected = (std::uint8_t)5, Rejected = static_cast<std::uint8_t>(5),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static QuoteAckStatus::Value get(const std::uint8_t value) static QuoteAckStatus::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 0: return Accepted; case static_cast<std::uint8_t>(0): return Accepted;
case 5: return Rejected; case static_cast<std::uint8_t>(5): return Rejected;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum QuoteAckStatus [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -169,6 +164,11 @@ private:
} }
public: 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 enum MetaAttribute
{ {
EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE
@@ -186,6 +186,8 @@ public:
std::uint64_t uint_value; std::uint64_t uint_value;
}; };
using messageHeader = MessageHeader;
QuoteCancel528() = default; QuoteCancel528() = default;
QuoteCancel528( QuoteCancel528(
@@ -218,30 +220,30 @@ public:
SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT 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 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 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 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"; return "Z";
} }
@@ -258,7 +260,7 @@ public:
QuoteCancel528 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) 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 hdr
.blockLength(sbeBlockLength()) .blockLength(sbeBlockLength())
@@ -268,7 +270,7 @@ public:
return *this = QuoteCancel528( return *this = QuoteCancel528(
buffer, buffer,
offset + MessageHeader::encodedLength(), offset + messageHeader::encodedLength(),
bufferLength, bufferLength,
sbeBlockLength(), sbeBlockLength(),
sbeSchemaVersion()); sbeSchemaVersion());
@@ -311,18 +313,17 @@ public:
SBE_NODISCARD std::uint64_t decodeLength() const SBE_NODISCARD std::uint64_t decodeLength() const
{ {
QuoteCancel528 skipper(m_buffer, m_offset, QuoteCancel528 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion);
m_bufferLength, sbeBlockLength(), m_actingVersion);
skipper.skip(); skipper.skip();
return skipper.encodedLength(); return skipper.encodedLength();
} }
SBE_NODISCARD const char * buffer() const SBE_NOEXCEPT SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
SBE_NODISCARD char * buffer() SBE_NOEXCEPT SBE_NODISCARD char *buffer() SBE_NOEXCEPT
{ {
return m_buffer; return m_buffer;
} }
@@ -337,7 +338,7 @@ public:
return m_actingVersion; 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) switch (metaAttribute)
{ {
@@ -381,12 +382,12 @@ public:
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT
@@ -408,7 +409,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -452,12 +453,12 @@ public:
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT
{ {
return 0x0L; return UINT64_C(0x0);
} }
static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT
{ {
return 0xfffffffffffffffeL; return UINT64_C(0xfffffffffffffffe);
} }
static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT
@@ -479,7 +480,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -521,7 +522,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t));
@@ -535,7 +543,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -579,12 +587,12 @@ public:
static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT
@@ -606,7 +614,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -645,17 +653,17 @@ public:
static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT
@@ -709,7 +717,7 @@ public:
throw std::runtime_error("length too large for getSenderID [E106]"); 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; return length;
} }
@@ -722,7 +730,7 @@ public:
SBE_NODISCARD std::string getSenderIDAsString() const SBE_NODISCARD std::string getSenderIDAsString() const
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -767,7 +775,7 @@ public:
SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 21; const char *buffer = m_buffer + m_offset + 21;
size_t length = 0; std::size_t length = 0;
for (; length < 20 && *(buffer + length) != '\0'; ++length); for (; length < 20 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -779,14 +787,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
QuoteCancel528 &putSenderID(const std::string_view str) QuoteCancel528 &putSenderID(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -796,14 +804,14 @@ public:
#else #else
QuoteCancel528 &putSenderID(const std::string& str) QuoteCancel528 &putSenderID(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 20) if (srcLength > 20)
{ {
throw std::runtime_error("string too large for putSenderID [E106]"); throw std::runtime_error("string too large for putSenderID [E106]");
} }
std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); 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; m_buffer[m_offset + 21 + start] = 0;
} }
@@ -812,7 +820,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -851,17 +859,17 @@ public:
static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT
@@ -915,7 +923,7 @@ public:
throw std::runtime_error("length too large for getLocation [E106]"); 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; return length;
} }
@@ -928,7 +936,7 @@ public:
SBE_NODISCARD std::string getLocationAsString() const SBE_NODISCARD std::string getLocationAsString() const
{ {
const char *buffer = m_buffer + m_offset + 41; const char *buffer = m_buffer + m_offset + 41;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -973,7 +981,7 @@ public:
SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 41; const char *buffer = m_buffer + m_offset + 41;
size_t length = 0; std::size_t length = 0;
for (; length < 5 && *(buffer + length) != '\0'; ++length); for (; length < 5 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -985,14 +993,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
QuoteCancel528 &putLocation(const std::string_view str) QuoteCancel528 &putLocation(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 41, str.data(), srcLength); 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; m_buffer[m_offset + 41 + start] = 0;
} }
@@ -1002,14 +1010,14 @@ public:
#else #else
QuoteCancel528 &putLocation(const std::string& str) QuoteCancel528 &putLocation(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 5) if (srcLength > 5)
{ {
throw std::runtime_error("string too large for putLocation [E106]"); throw std::runtime_error("string too large for putLocation [E106]");
} }
std::memcpy(m_buffer + m_offset + 41, str.c_str(), srcLength); 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; m_buffer[m_offset + 41 + start] = 0;
} }
@@ -1018,7 +1026,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1062,12 +1070,12 @@ public:
static SBE_CONSTEXPR std::uint32_t quoteIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t quoteIDMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t quoteIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t quoteIDMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t quoteIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t quoteIDEncodingLength() SBE_NOEXCEPT
@@ -1089,7 +1097,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1131,7 +1139,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 50, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 50, sizeof(std::uint8_t));
@@ -1145,7 +1160,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1187,7 +1202,14 @@ public:
return 1; 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::uint8_t val;
std::memcpy(&val, m_buffer + m_offset + 51, sizeof(std::uint8_t)); std::memcpy(&val, m_buffer + m_offset + 51, sizeof(std::uint8_t));
@@ -1259,8 +1281,8 @@ public:
m_buffer = buffer; m_buffer = buffer;
m_bufferLength = bufferLength; m_bufferLength = bufferLength;
GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
dimensions.blockLength((std::uint16_t)10); dimensions.blockLength(static_cast<std::uint16_t>(10));
dimensions.numInGroup((std::uint8_t)count); dimensions.numInGroup(static_cast<std::uint8_t>(count));
m_index = 0; m_index = 0;
m_count = count; m_count = count;
m_blockLength = 10; m_blockLength = 10;
@@ -1331,7 +1353,7 @@ public:
{ {
m_count = m_index; m_count = m_index;
GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); 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; return m_count;
} }
@@ -1357,7 +1379,7 @@ public:
#endif #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) switch (metaAttribute)
{ {
@@ -1396,17 +1418,17 @@ public:
static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT
{ {
return (char)0; return static_cast<char>(0);
} }
static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT
{ {
return (char)32; return static_cast<char>(32);
} }
static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT
{ {
return (char)126; return static_cast<char>(126);
} }
static SBE_CONSTEXPR std::size_t securityGroupEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t securityGroupEncodingLength() SBE_NOEXCEPT
@@ -1460,7 +1482,7 @@ public:
throw std::runtime_error("length too large for getSecurityGroup [E106]"); 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; return length;
} }
@@ -1473,7 +1495,7 @@ public:
SBE_NODISCARD std::string getSecurityGroupAsString() const SBE_NODISCARD std::string getSecurityGroupAsString() const
{ {
const char *buffer = m_buffer + m_offset + 0; const char *buffer = m_buffer + m_offset + 0;
size_t length = 0; std::size_t length = 0;
for (; length < 6 && *(buffer + length) != '\0'; ++length); for (; length < 6 && *(buffer + length) != '\0'; ++length);
std::string result(buffer, length); std::string result(buffer, length);
@@ -1518,7 +1540,7 @@ public:
SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT
{ {
const char *buffer = m_buffer + m_offset + 0; const char *buffer = m_buffer + m_offset + 0;
size_t length = 0; std::size_t length = 0;
for (; length < 6 && *(buffer + length) != '\0'; ++length); for (; length < 6 && *(buffer + length) != '\0'; ++length);
std::string_view result(buffer, length); std::string_view result(buffer, length);
@@ -1530,14 +1552,14 @@ public:
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
NoQuoteEntries &putSecurityGroup(const std::string_view str) NoQuoteEntries &putSecurityGroup(const std::string_view str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 6) if (srcLength > 6)
{ {
throw std::runtime_error("string too large for putSecurityGroup [E106]"); throw std::runtime_error("string too large for putSecurityGroup [E106]");
} }
std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); 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; m_buffer[m_offset + 0 + start] = 0;
} }
@@ -1547,14 +1569,14 @@ public:
#else #else
NoQuoteEntries &putSecurityGroup(const std::string& str) NoQuoteEntries &putSecurityGroup(const std::string& str)
{ {
const size_t srcLength = str.length(); const std::size_t srcLength = str.length();
if (srcLength > 6) if (srcLength > 6)
{ {
throw std::runtime_error("string too large for putSecurityGroup [E106]"); throw std::runtime_error("string too large for putSecurityGroup [E106]");
} }
std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); 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; m_buffer[m_offset + 0 + start] = 0;
} }
@@ -1563,7 +1585,7 @@ public:
} }
#endif #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) switch (metaAttribute)
{ {
@@ -1602,17 +1624,17 @@ public:
static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT
{ {
return 2147483647; return INT32_C(2147483647);
} }
static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT
{ {
return -2147483647; return INT32_C(-2147483647);
} }
static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT
{ {
return 2147483647; return INT32_C(2147483647);
} }
static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT
@@ -1661,13 +1683,13 @@ public:
return true; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -1772,8 +1794,8 @@ public:
m_buffer = buffer; m_buffer = buffer;
m_bufferLength = bufferLength; m_bufferLength = bufferLength;
GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); GroupSize dimensions(buffer, *pos, bufferLength, actingVersion);
dimensions.blockLength((std::uint16_t)10); dimensions.blockLength(static_cast<std::uint16_t>(10));
dimensions.numInGroup((std::uint8_t)count); dimensions.numInGroup(static_cast<std::uint8_t>(count));
m_index = 0; m_index = 0;
m_count = count; m_count = count;
m_blockLength = 10; m_blockLength = 10;
@@ -1844,7 +1866,7 @@ public:
{ {
m_count = m_index; m_count = m_index;
GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); 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; return m_count;
} }
@@ -1870,7 +1892,7 @@ public:
#endif #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) switch (metaAttribute)
{ {
@@ -1909,17 +1931,17 @@ public:
static SBE_CONSTEXPR std::uint32_t bidSizeNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t bidSizeNullValue() SBE_NOEXCEPT
{ {
return 4294967295; return UINT32_C(0xffffffff);
} }
static SBE_CONSTEXPR std::uint32_t bidSizeMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t bidSizeMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t bidSizeMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t bidSizeMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t bidSizeEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t bidSizeEncodingLength() SBE_NOEXCEPT
@@ -1941,7 +1963,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -1980,17 +2002,17 @@ public:
static SBE_CONSTEXPR std::uint32_t offerSizeNullValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t offerSizeNullValue() SBE_NOEXCEPT
{ {
return 4294967295; return UINT32_C(0xffffffff);
} }
static SBE_CONSTEXPR std::uint32_t offerSizeMinValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t offerSizeMinValue() SBE_NOEXCEPT
{ {
return 0; return UINT32_C(0x0);
} }
static SBE_CONSTEXPR std::uint32_t offerSizeMaxValue() SBE_NOEXCEPT static SBE_CONSTEXPR std::uint32_t offerSizeMaxValue() SBE_NOEXCEPT
{ {
return 4294967294; return UINT32_C(0xfffffffe);
} }
static SBE_CONSTEXPR std::size_t offerSizeEncodingLength() SBE_NOEXCEPT static SBE_CONSTEXPR std::size_t offerSizeEncodingLength() SBE_NOEXCEPT
@@ -2012,7 +2034,7 @@ public:
return *this; 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) switch (metaAttribute)
{ {
@@ -2056,12 +2078,12 @@ public:
static SBE_CONSTEXPR std::uint16_t quoteSetIDMinValue() SBE_NOEXCEPT 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 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 static SBE_CONSTEXPR std::size_t quoteSetIDEncodingLength() SBE_NOEXCEPT
@@ -2113,13 +2135,13 @@ public:
return true; return true;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() SBE_NODISCARD static std::size_t computeLength()
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
return length; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
@@ -2269,30 +2291,30 @@ SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT
return false; return false;
} }
SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength( SBE_NODISCARD static std::size_t computeLength(
std::size_t NoQuoteEntriesLength = 0, std::size_t noQuoteEntriesLength = 0,
std::size_t NoQuoteSetsLength = 0) std::size_t noQuoteSetsLength = 0)
{ {
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" #pragma GCC diagnostic ignored "-Wtype-limits"
#endif #endif
size_t length = sbeBlockLength(); std::size_t length = sbeBlockLength();
length += NoQuoteEntries::sbeHeaderSize(); 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(); 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; return length;
#if defined(__GNUG__) && !defined(__clang__) #if defined(__GNUG__) && !defined(__clang__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
+195 -152
View File
File diff suppressed because it is too large. Load diff
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,30 +94,30 @@ class QuoteCxlStatus
public: public:
enum Value enum Value
{ {
CancelperInstrument = (std::uint8_t)1, CancelperInstrument = static_cast<std::uint8_t>(1),
CancelperInstrumentgroup = (std::uint8_t)3, CancelperInstrumentgroup = static_cast<std::uint8_t>(3),
Cancelallquotes = (std::uint8_t)4, Cancelallquotes = static_cast<std::uint8_t>(4),
Rejected = (std::uint8_t)5, Rejected = static_cast<std::uint8_t>(5),
CancelperQuoteSet = (std::uint8_t)100, CancelperQuoteSet = static_cast<std::uint8_t>(100),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static QuoteCxlStatus::Value get(const std::uint8_t value) static QuoteCxlStatus::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 1: return CancelperInstrument; case static_cast<std::uint8_t>(1): return CancelperInstrument;
case 3: return CancelperInstrumentgroup; case static_cast<std::uint8_t>(3): return CancelperInstrumentgroup;
case 4: return Cancelallquotes; case static_cast<std::uint8_t>(4): return Cancelallquotes;
case 5: return Rejected; case static_cast<std::uint8_t>(5): return Rejected;
case 100: return CancelperQuoteSet; case static_cast<std::uint8_t>(100): return CancelperQuoteSet;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum QuoteCxlStatus [E103]"); 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) switch (value)
{ {
@@ -22,12 +22,6 @@
# define SBE_NOEXCEPT # define SBE_NOEXCEPT
#endif #endif
#if __cplusplus >= 201402L
# define SBE_CONSTEXPR_14 constexpr
#else
# define SBE_CONSTEXPR_14
#endif
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
# include <string_view> # include <string_view>
# define SBE_NODISCARD [[nodiscard]] # define SBE_NODISCARD [[nodiscard]]
@@ -48,6 +42,7 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple>
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) # define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v)
@@ -99,28 +94,28 @@ class QuoteCxlTyp
public: public:
enum Value enum Value
{ {
CancelperInstrument = (std::uint8_t)1, CancelperInstrument = static_cast<std::uint8_t>(1),
CancelperInstrumentgroup = (std::uint8_t)3, CancelperInstrumentgroup = static_cast<std::uint8_t>(3),
Cancelallquotes = (std::uint8_t)4, Cancelallquotes = static_cast<std::uint8_t>(4),
CancelperQuoteSet = (std::uint8_t)100, CancelperQuoteSet = static_cast<std::uint8_t>(100),
NULL_VALUE = (std::uint8_t)255 NULL_VALUE = static_cast<std::uint8_t>(255)
}; };
static QuoteCxlTyp::Value get(const std::uint8_t value) static QuoteCxlTyp::Value get(const std::uint8_t value)
{ {
switch (value) switch (value)
{ {
case 1: return CancelperInstrument; case static_cast<std::uint8_t>(1): return CancelperInstrument;
case 3: return CancelperInstrumentgroup; case static_cast<std::uint8_t>(3): return CancelperInstrumentgroup;
case 4: return Cancelallquotes; case static_cast<std::uint8_t>(4): return Cancelallquotes;
case 100: return CancelperQuoteSet; case static_cast<std::uint8_t>(100): return CancelperQuoteSet;
case 255: return NULL_VALUE; case static_cast<std::uint8_t>(255): return NULL_VALUE;
} }
throw std::runtime_error("unknown value for enum QuoteCxlTyp [E103]"); 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) switch (value)
{ {
Loaded 100 of 124 files, more files were not shown because too many files have changed in this diff. Show more