From 38f212e6333fe21c7c30ded74571192bb096981c Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Wed, 23 May 2018 18:41:19 -0400 Subject: [PATCH 01/13] SPARK-1162 UserPersist should use ID --- .../spark/core/Settings/UserPersistFactory.cs | 17 +++---- .../spark/core/ShellInterface/UISettings.cs | 4 +- .../spark/view/Shell/Login/LoginModel.cs | 44 ++++++++++++------- .../spark/view/Shell/Login/LoginViewModel.cs | 5 ++- .../Login/PreloginWorkspaceEnumerator.cs | 10 ++--- 5 files changed, 46 insertions(+), 34 deletions(-) diff --git a/src/client/spark/core/Settings/UserPersistFactory.cs b/src/client/spark/core/Settings/UserPersistFactory.cs index 1d0504b9e..472e14557 100644 --- a/src/client/spark/core/Settings/UserPersistFactory.cs +++ b/src/client/spark/core/Settings/UserPersistFactory.cs @@ -15,25 +15,26 @@ namespace mbts.ui.settings [Export(typeof(IUserPersistFactory))] class UISettingsFactory : IUserPersistFactory { - Task _users; + Task _users; readonly PersistenceService _persist; [ImportingConstructor] - public UISettingsFactory([Import("username")] string current_user, UserService login, [Import("settings")] PersistenceService persist) { + public UISettingsFactory(UserService login, [Import("settings")] PersistenceService persist) { _persist = persist; _users = get_users(login); } - async Task get_users(UserService login) { + async Task get_users(UserService login) { var users = await login.get_users_async(null); - if (users.success) return users.value.Users.Select(x => x.Login).ToArray(); - else return new string[0]; + if (users.success) return users.value.Users.ToArray(); + else return new User[0]; } - public IEnumerable users() { return _users.Result; } + public IEnumerable users() { return _users.Result.Select(u => u.Login); } - public IUserPersist get_persist_for(string user) { - return new UserUISettings(user, _persist); + public IUserPersist get_persist_for(string name) { + var user = _users.Result.FirstOrDefault(u => u.Login == name); + return new UserUISettings(user.Id, _persist); } } } diff --git a/src/client/spark/core/ShellInterface/UISettings.cs b/src/client/spark/core/ShellInterface/UISettings.cs index 242d12a87..ee668550a 100644 --- a/src/client/spark/core/ShellInterface/UISettings.cs +++ b/src/client/spark/core/ShellInterface/UISettings.cs @@ -140,9 +140,9 @@ namespace mbts.persist string _user; [ImportingConstructor] - public UserUISettings([Import("username")]string user, [Import("settings")]PersistenceService persist) + public UserUISettings([Import("userid")]uint user, [Import("settings")]PersistenceService persist) : base(persist) { - _user = user; + _user = $"User {user}"; } protected override string user() { return _user; } diff --git a/src/client/spark/view/Shell/Login/LoginModel.cs b/src/client/spark/view/Shell/Login/LoginModel.cs index 91125a460..caf25b55b 100644 --- a/src/client/spark/view/Shell/Login/LoginModel.cs +++ b/src/client/spark/view/Shell/Login/LoginModel.cs @@ -30,7 +30,9 @@ namespace mbts.ui.shell model.provide_services(user, persist); // await_login pumps the dispatcher but doesn't allow control to return to MEF until the username and workspace are available model.await_login(); - UserName = model.get_username(); + var u = model.get_user(); + UserName = u.name; + UserId = u.id; Workspace = model.get_workspace(); model.Dispose(); } @@ -45,16 +47,24 @@ namespace mbts.ui.shell [Export("username")] public string UserName { get; private set; } + [Export("userid")] + public uint UserId { get; private set; } + [Export("workspace")] public string Workspace { get; private set; } } + public struct User { + public string name; + public UInt32 id; + } + public class LoginModel : IDisposable { // Singleton to help bootstrap the system private static LoginModel _instance = new LoginModel(); public static LoginModel instance { get { return _instance; } } - private string _username; + private User _user; private string _workspace; private PreloginWorkspaceEnumerator _enum_workspace; @@ -69,18 +79,19 @@ namespace mbts.ui.shell public event Action Ready; public string ErrorMessage { get; private set; } public bool HasFatalError { get; set; } - public string[] UserNames { get; private set; } + public User[] Users { get; private set; } // The final username - public string get_username() { - Logger.assert_d(!string.IsNullOrEmpty(_username)); - return _username; + public User get_user() { + Logger.assert_d(!string.IsNullOrEmpty(_user.name)); + return _user; } public string get_workspace() { return _workspace ?? ""; } - public Task> workspaces_for(string user) { + + public Task> workspaces_for(User user) { return _enum_workspace.get_workspaces(user); } @@ -105,8 +116,7 @@ namespace mbts.ui.shell _enum_workspace = new PreloginWorkspaceEnumerator(persist); var response = await _logon.get_users_async(new GetUsersRequest()); if (response.success) { - UserNames = response.value.Users.Select(x => x.Login).ToArray(); - Array.Sort(UserNames); + Users = response.value.Users.Select(x => new User { name = x.Login, id = x.Id }).OrderBy(u => u.name).ToArray(); } else { ErrorMessage = "Logon: " + response.error_message; @@ -118,7 +128,7 @@ namespace mbts.ui.shell #endregion public async Task<(bool success,string info)> do_login(string username, string workspace, string password) { - if (UserNames.Contains(username)) { + if (Users.Select(u => u.name).Contains(username)) { var response = await _logon.authenticate_login_async(new AuthenticateLoginRequest() { Login = username, Password = password ??"" @@ -126,7 +136,7 @@ namespace mbts.ui.shell if (response.success) { if (response.value.IsValid) { _workspace = workspace; - set_authenticated_user(username); + set_authenticated_user(new User { name =username, id = response.value.UserId}); return (true, ""); } else { @@ -140,16 +150,16 @@ namespace mbts.ui.shell return (false, "Invalid username"); } - private void set_authenticated_user(string name) { - Logger.assert(!string.IsNullOrEmpty(name)); - Logger.assert(UserNames.Contains(name)); - _username = name; - Environment.SetEnvironmentVariable("BTS_USER", name); + private void set_authenticated_user(User user) { + Logger.assert(!string.IsNullOrEmpty(user.name)); + Logger.assert(Users.Select(u => u.name).Contains(user.name)); + _user = user; + Environment.SetEnvironmentVariable("BTS_USER", user.name); _frame.Continue = false; } public void await_login() { - if (string.IsNullOrEmpty(_username)) { + if (string.IsNullOrEmpty(_user.name)) { Dispatcher.PushFrame(_frame); } } diff --git a/src/client/spark/view/Shell/Login/LoginViewModel.cs b/src/client/spark/view/Shell/Login/LoginViewModel.cs index 44e2999d7..c2140dc91 100644 --- a/src/client/spark/view/Shell/Login/LoginViewModel.cs +++ b/src/client/spark/view/Shell/Login/LoginViewModel.cs @@ -42,7 +42,7 @@ namespace mbts.ui.shell void _model_Ready() { _dispatcher.BeginInvoke(() => { if (!_model.HasFatalError) { - this.UserNames.AddRange(_model.UserNames); + this.UserNames.AddRange(_model.Users.Select(u => u.name)); this.VisualState = "LoginState"; load_username(); LoginCommand.RaiseCanExecuteChanged(); @@ -82,7 +82,8 @@ namespace mbts.ui.shell private async void update_workspaces(string name) { Workspaces.Clear(); Workspaces.Add("New workspace..."); - var to_add = await _model.workspaces_for(name); + var user = _model.Users.First(u => u.name == name); + var to_add = await _model.workspaces_for(user); this.SelectedWorkspace = Workspaces.First(); if (to_add != null && name == _name && Workspaces.Count == 1) { Workspaces.AddRange(to_add); diff --git a/src/client/spark/view/Shell/Login/PreloginWorkspaceEnumerator.cs b/src/client/spark/view/Shell/Login/PreloginWorkspaceEnumerator.cs index 8e18a08b2..128e853c6 100644 --- a/src/client/spark/view/Shell/Login/PreloginWorkspaceEnumerator.cs +++ b/src/client/spark/view/Shell/Login/PreloginWorkspaceEnumerator.cs @@ -12,7 +12,7 @@ namespace mbts.ui.shell { class PreloginWorkspaceEnumerator { - private Dictionary> _cache = new Dictionary>(); + private Dictionary> _cache = new Dictionary>(); private PersistenceService _persist; public PreloginWorkspaceEnumerator(PersistenceService p) { @@ -27,12 +27,12 @@ namespace mbts.ui.shell return name; } - public async Task> get_workspaces(string username) { - if (!_cache.TryGetValue(username, out List result)) { - using (var svc = new UserUISettings(username, _persist)) { + public async Task> get_workspaces(User user) { + if (!_cache.TryGetValue(user.id, out List result)) { + using (var svc = new UserUISettings(user.id, _persist)) { var workspaces = await svc.query(WorkspacesModel.WORKSPACE_NAMESPACE, ".*"); result = workspaces.Select(w => w.key).ToList(); - _cache[username] = result; + _cache[user.id] = result; return result; } } From d3f2ecc78e011ed0da7f1ad3c1fba5e0df015df2 Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Wed, 23 May 2018 19:27:37 -0400 Subject: [PATCH 02/13] SPARK-1147 Add requited glbx fields to enable this work. --- src/lib/domain_model/Security.proto | 3 +++ src/lib/md/Diag/ShmDumper.cpp | 3 +++ src/lib/md/Shm/FixedSecurity.cpp | 6 ++++++ src/lib/md/Shm/FixedSecurity.h | 4 ++++ src/server/sparkd/md/platforms/mdp3_onixs/MDP3Listener.cpp | 5 +++++ 5 files changed, 21 insertions(+) diff --git a/src/lib/domain_model/Security.proto b/src/lib/domain_model/Security.proto index 34b38d3f5..dbc716d47 100644 --- a/src/lib/domain_model/Security.proto +++ b/src/lib/domain_model/Security.proto @@ -55,6 +55,9 @@ message GLBXExchangeData { string security_desc = 20; string cfi_code = 21; string cme_symbol = 22; + uint32 main_fraction = 30; + uint32 sub_fraction = 31; + uint32 price_display_format = 32; } message CBOEExchangeData { int64 exchange_id = 10; diff --git a/src/lib/md/Diag/ShmDumper.cpp b/src/lib/md/Diag/ShmDumper.cpp index 307ee421e..486c5577f 100644 --- a/src/lib/md/Diag/ShmDumper.cpp +++ b/src/lib/md/Diag/ShmDumper.cpp @@ -71,6 +71,9 @@ string dump_security(const FixedSecurity& security) { res << "'display_factor': " << (int)security.display_factor << ", "; res << "'numeric_id': " << security.numeric_id << ", "; res << "'cboe_class_key': " << security.cboe_class_key << ", "; + res << "'cme_main_frac': " << (int)security.cme_main_fraction << ", "; + res << "'cme_sub_fract': " << (int)security.cme_sub_fraction << ", "; + res << "'cme_price_dformat': " << (int)security.cme_price_display_format << ", "; res << "'market_segment': " << security.cme_market_segment_id << ", "; diff --git a/src/lib/md/Shm/FixedSecurity.cpp b/src/lib/md/Shm/FixedSecurity.cpp index 73f0773f4..05c95fff4 100644 --- a/src/lib/md/Shm/FixedSecurity.cpp +++ b/src/lib/md/Shm/FixedSecurity.cpp @@ -157,6 +157,9 @@ void convert_security(const FixedSecurity& source, Security* presult) { dest.mutable_glbx()->set_security_desc(source.security_desc()); dest.mutable_glbx()->set_cfi_code(source.cfi_code()); dest.mutable_glbx()->set_cme_symbol(source.alt_symbol()); + if (source.cme_main_fraction != 0) dest.mutable_glbx()->set_main_fraction(source.cme_main_fraction); + if (source.cme_sub_fraction != 0) dest.mutable_glbx()->set_sub_fraction(source.cme_sub_fraction); + if (source.cme_price_display_format) dest.mutable_glbx()->set_price_display_format(source.cme_price_display_format); break; case Venue::VENUE_BTS: break; @@ -254,6 +257,9 @@ void convert_security(const Security& src, FixedSecurity& dest, bool set_securit dest.security_desc(src.glbx().security_desc()); dest.cfi_code(src.glbx().cfi_code()); dest.alt_symbol(src.glbx().cme_symbol()); + dest.cme_main_fraction = src.glbx().main_fraction(); + dest.cme_sub_fraction = src.glbx().sub_fraction(); + dest.cme_price_display_format = src.glbx().price_display_format(); break; case Security::ExchangeDataCase::kCboe: dest.cboe_class_key = src.cboe().class_key(); diff --git a/src/lib/md/Shm/FixedSecurity.h b/src/lib/md/Shm/FixedSecurity.h index d6a086e7d..3bf0486ab 100644 --- a/src/lib/md/Shm/FixedSecurity.h +++ b/src/lib/md/Shm/FixedSecurity.h @@ -54,6 +54,10 @@ public: double high_tick; double cash_per_point; + uint8_t cme_main_fraction; + uint8_t cme_sub_fraction; + uint8_t cme_price_display_format; + private: char _symbol[16]; // CME defines this as a char[6] but I'm padding char _cfi_code[8]; // CME defines this as char[6] diff --git a/src/server/sparkd/md/platforms/mdp3_onixs/MDP3Listener.cpp b/src/server/sparkd/md/platforms/mdp3_onixs/MDP3Listener.cpp index c0d564c82..44bbb7fc5 100644 --- a/src/server/sparkd/md/platforms/mdp3_onixs/MDP3Listener.cpp +++ b/src/server/sparkd/md/platforms/mdp3_onixs/MDP3Listener.cpp @@ -201,6 +201,10 @@ void set_security_common(const Definition& def, FixedSecurity& fsec) { // tickRule not present in futures fsec.cme_market_segment_id = def.marketSegmentId(); fsec.display_factor = def.displayFactor().exponent() + floorlog10(def.displayFactor().mantissa()); + + def.mainFraction(fsec.cme_main_fraction); + def.subFraction(fsec.cme_sub_fraction); + def.priceDisplayFormat(fsec.cme_price_display_format); } void MDP3Listener::onDefinition(onixs::Handler&, const onixs::Security& osec, const onixs::InstrumentDefinitionFutureArgs& def) { @@ -211,6 +215,7 @@ void MDP3Listener::onDefinition(onixs::Handler&, const onixs::Security& osec, co bts_assert(exchange_id == osec.id()); FixedFutureSecurity fsec; + set_security_common(sec, fsec); fsec.price_break = 0; // low/high tick are stored non-premultiplied and multiplied in conversion to api::Secutity From 9b2a4ca6b1d734b75ae85c37d56f0a040730f2d0 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Sat, 26 May 2018 19:49:15 -0400 Subject: [PATCH 03/13] prehedge payless tests --- .../spreader_orders/tests/spreader_tests.cpp | 60 ++++++++++++++++++- 1 file changed, 59 insertions(+), 1 deletion(-) diff --git a/src/server/sparkd/orderman/orders/spreader_orders/tests/spreader_tests.cpp b/src/server/sparkd/orderman/orders/spreader_orders/tests/spreader_tests.cpp index 6837223bd..655bec030 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/tests/spreader_tests.cpp +++ b/src/server/sparkd/orderman/orders/spreader_orders/tests/spreader_tests.cpp @@ -2208,7 +2208,7 @@ TEST_CASE ("find_target_price_in_book", "[spreader]"){ Quantity out_level_qty, out_cum_qty; bts::orderman::Book book; uint16_t sizes[] = { 12, 91, 5, 24, 33 }; - double prices[] = { 100.21875, 100.28125, 101, 101.53125, 101.71875 }; + double prices[] = { 100.21875, 100.28125, 101, 101.53125, 101.71875 }; fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL); // first bool res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_SELL, Price(100.21875), 0.03125, out_level_qty, out_cum_qty); @@ -2241,6 +2241,64 @@ TEST_CASE ("find_target_price_in_book", "[spreader]"){ REQUIRE(out_cum_qty.value()==132); } } +TEST_CASE ("prehedge_payless", "[spreader]"){ + SECTION("payup_true_abs_threshold"){ + bts::orderman::Book book; + Price out_price; + uint16_t sizes[] = { 12, 14, 17, 19, 23 }; + double prices[] = { 21.00, 21.05, 21.10, 22, 23 }; + fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL); + spark::PreHedgeQuantityBasedPayLessTicks payless_params; + payless_params.set_payless_ticks(1); + payless_params.mutable_quantity_threshold()->set_absolute(25); + auto res = SpreaderUtils::prehedge_quantity_base_payless_ticks_reprice(payless_params, book, api::Side::SIDE_BUY, + 0.05, Price(21.05), Quantity(5), out_price); + REQUIRE(res); + REQUIRE(out_price.value()==21.00); + } + SECTION("payup_false_abs_threshold"){ + bts::orderman::Book book; + Price out_price; + uint16_t sizes[] = { 10, 14, 17, 19, 23 }; + double prices[] = { 21.00, 21.05, 21.10, 22, 23 }; + fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL); + spark::PreHedgeQuantityBasedPayLessTicks payless_params; + payless_params.set_payless_ticks(1); + payless_params.mutable_quantity_threshold()->set_absolute(25); + auto res = SpreaderUtils::prehedge_quantity_base_payless_ticks_reprice(payless_params, book, api::Side::SIDE_BUY, + 0.05, Price(21.05), Quantity(5), out_price); + REQUIRE(!res); + REQUIRE(out_price.value()==21.05); + } + SECTION("payup_true_ratio_threshold"){ + bts::orderman::Book book; + Price out_price; + uint16_t sizes[] = { 11, 14, 26, 19, 23 }; + double prices[] = { 21.00, 21.05, 21.10, 22, 23 }; + fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL); + spark::PreHedgeQuantityBasedPayLessTicks payless_params; + payless_params.set_payless_ticks(2); + payless_params.mutable_quantity_threshold()->set_ratio(5); + auto res = SpreaderUtils::prehedge_quantity_base_payless_ticks_reprice(payless_params, book, api::Side::SIDE_BUY, + 0.05, Price(21.10), Quantity(10), out_price); + REQUIRE(res); + REQUIRE(out_price.value()==21.00); + } + SECTION("payup_true_ratio_threshold"){ + bts::orderman::Book book; + Price out_price; + uint16_t sizes[] = { 11, 14, 26, 19, 23 }; + double prices[] = { 21.00, 21.05, 21.10, 22, 23 }; + fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL); + spark::PreHedgeQuantityBasedPayLessTicks payless_params; + payless_params.set_payless_ticks(2); + payless_params.mutable_quantity_threshold()->set_ratio(6); + auto res = SpreaderUtils::prehedge_quantity_base_payless_ticks_reprice(payless_params, book, api::Side::SIDE_BUY, + 0.05, Price(21.10), Quantity(10), out_price); + REQUIRE(!res); + REQUIRE(out_price.value()==21.10); + } +} // class Temp // { From b2eeddc628fcf51f8c6a12a8b05064aa1153b873 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Sat, 26 May 2018 22:10:50 -0400 Subject: [PATCH 04/13] prehedge payup tests --- .../spreader_orders/tests/spreader_tests.cpp | 31 ++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/src/server/sparkd/orderman/orders/spreader_orders/tests/spreader_tests.cpp b/src/server/sparkd/orderman/orders/spreader_orders/tests/spreader_tests.cpp index 655bec030..b4917ecc0 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/tests/spreader_tests.cpp +++ b/src/server/sparkd/orderman/orders/spreader_orders/tests/spreader_tests.cpp @@ -2299,7 +2299,36 @@ TEST_CASE ("prehedge_payless", "[spreader]"){ REQUIRE(out_price.value()==21.10); } } - +TEST_CASE ("prehedge_payup", "[spreader]"){ + SECTION("payup_true_abs_threshold"){ + bts::orderman::Book book; + Price out_price; + uint16_t sizes[] = { 12, 18, 20, 19, 23 }; + double prices[] = { 21.00, 21.05, 21.10, 22, 23 }; + fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL); + spark::PreHedgeQuantityBasedPayupTicks payup_params; + payup_params.set_payup_ticks(1); + payup_params.mutable_quantity_threshold()->set_absolute(55); + auto res = SpreaderUtils::prehedge_quantity_base_payup_ticks_reprice(payup_params, book, api::Side::SIDE_BUY, + 0.05, Price(21.10), Quantity(5), out_price); + REQUIRE(res); + REQUIRE(bts::securities::test_price_equality(out_price.value(),21.15,0.05)); + } + SECTION("payup_false_abs_threshold"){ + bts::orderman::Book book; + Price out_price; + uint16_t sizes[] = { 12, 18, 20, 19, 23 }; + double prices[] = { 21.00, 21.05, 21.10, 22, 23 }; + fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL); + spark::PreHedgeQuantityBasedPayupTicks payup_params; + payup_params.set_payup_ticks(1); + payup_params.mutable_quantity_threshold()->set_absolute(50); + auto res = SpreaderUtils::prehedge_quantity_base_payup_ticks_reprice(payup_params, book, api::Side::SIDE_BUY, + 0.05, Price(21.10), Quantity(5), out_price); + REQUIRE(!res); + REQUIRE(bts::securities::test_price_equality(out_price.value(),21.10,0.05)); + } +} // class Temp // { // public: From 7e54eea62f3247346448156363f9d9634038a256 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Sun, 27 May 2018 15:36:36 -0400 Subject: [PATCH 05/13] DIYGrid - fix sorting initialization bug (when initial sort comes from Rows.SortDescriptions) --- .../spark/view/Controls/DIYGrid/DIYGrid.cs | 32 +++++++++++++------ 1 file changed, 23 insertions(+), 9 deletions(-) diff --git a/src/client/spark/view/Controls/DIYGrid/DIYGrid.cs b/src/client/spark/view/Controls/DIYGrid/DIYGrid.cs index f80274431..5e09f0dc1 100644 --- a/src/client/spark/view/Controls/DIYGrid/DIYGrid.cs +++ b/src/client/spark/view/Controls/DIYGrid/DIYGrid.cs @@ -150,16 +150,25 @@ namespace mbts.ui.controls { } public DIYGrid() { + var sort_map = new Dictionary(); _sort_descriptions_collection_changed_cb = WPFHelper.create_collection_changed_cb( - sd => Columns?.ApplyToFirst(c => c.sort_member_path == sd.PropertyName, c => c.SortDirection = sd.Direction), - sd => Columns?.ApplyToFirst(C => C.sort_member_path == sd.PropertyName, c => c.SortDirection = null), - s => { + sd => { + if (Columns.TryGetFirst(c => c.sort_member_path == sd.PropertyName, out ColumnBase col)) { + sort_map[sd.PropertyName] = col; + col.SortDirection = sd.Direction; + } + }, sd => { + if (Columns.TryGetFirst(c => c.sort_member_path == sd.PropertyName, out ColumnBase col)) { + col.SortDirection = null; + sort_map.Remove(sd.PropertyName); + } + }, s => { + sort_map.Clear(); if (Columns is IEnumerable cols) { foreach (var c in cols) c.SortDirection = null; } }); - var sort_map = new Dictionary(); CommandBindings.Add(new CommandBinding(ApplicationCommands.Copy, OnCopy, OnCopyCanExecute)); CommandBindings.Add(new CommandBinding(SortCommand, (s, e) => { if (e.Parameter is GridViewColumnHeader col_header && col_header.Column is ColumnBase cb) { @@ -177,15 +186,16 @@ namespace mbts.ui.controls { sort_map.Remove(sd.PropertyName); } cv_rows.SortDescriptions.Clear(); + cb.SortDirection = next; cv_rows.SortDescriptions.Add(new SortDescription(path, next)); } else { var sort_desc = new SortDescription(path, next); int i = cv_rows.SortDescriptions.IndexOf(sort_desc, EqualityComparer.Create(x => x.PropertyName)); + cb.SortDirection = next; if (i >= 0) { cv_rows.SortDescriptions[i] = sort_desc; } else cv_rows.SortDescriptions.Add(new SortDescription(path, next)); } - cb.SortDirection = next; sort_map[path] = cb; } } @@ -563,10 +573,14 @@ namespace mbts.ui.controls { public static readonly DependencyProperty RowsProperty = WPFHelper.create_dp( nameof(Rows), - (s, oldval, newval) => WPFHelper.manage_collection_change( - (oldval as ICollectionView)?.SortDescriptions, - (newval as ICollectionView)?.SortDescriptions, - s._sort_descriptions_collection_changed_cb), + (s, oldval, newval) => { + WPFHelper.manage_collection_change( + (oldval as ICollectionView)?.SortDescriptions, + (newval as ICollectionView)?.SortDescriptions, + s._sort_descriptions_collection_changed_cb, + old_ncc => s._sort_descriptions_collection_changed_cb(old_ncc, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)), + new_ncc => s._sort_descriptions_collection_changed_cb(new_ncc, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, (IList)new_ncc))); + }, Enumerable.Empty()); public DataTemplate RowTemplate { From 701e883aeaae35be4525939f482ccba6087ff23f Mon Sep 17 00:00:00 2001 From: John Colvin Date: Sun, 27 May 2018 15:42:33 -0400 Subject: [PATCH 06/13] DiscreteValuesFilter - guard against null desired-items --- .../Controls/DataGridEx/Filters/VM/DiscreteValuesFilterVM.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/client/spark/view/Controls/DataGridEx/Filters/VM/DiscreteValuesFilterVM.cs b/src/client/spark/view/Controls/DataGridEx/Filters/VM/DiscreteValuesFilterVM.cs index d68de88ad..e0e9dec8c 100644 --- a/src/client/spark/view/Controls/DataGridEx/Filters/VM/DiscreteValuesFilterVM.cs +++ b/src/client/spark/view/Controls/DataGridEx/Filters/VM/DiscreteValuesFilterVM.cs @@ -110,7 +110,7 @@ namespace mbts.spark.filters { selected_items.CollectionChanged += on_selected_items_CollectionChanged; Action>>> ah = cb => _on_state_loaded += cb, rh = cb => _on_state_loaded -= cb; _resources.Add(Observable.FromEvent(ah, rh).SelectMany(src => src).ObserveOnDispatcher().Subscribe(dsi => { - if (!_override_desired_selection) { + if (!_override_desired_selection && dsi != null) { var copy = new HashSet(_selected_items_set, equality_comparer); _selected_items_set = new HashSet(dsi, equality_comparer); using (selected_items.SuspendHandler(on_selected_items_CollectionChanged)) { From 4b9e0460464c2b4f96e6cd05c31ce399eb3c62dd Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Sun, 27 May 2018 11:15:44 -0400 Subject: [PATCH 07/13] limits were still using ints for accont ids, fixed that --- .../api/service_helpers/AdminServiceUtils.cpp | 6 +- .../api/service_helpers/AdminServiceUtils.h | 2 +- .../sparkd/orderman/limiter/LimitStore.h | 33 +++++++---- .../orderman/limiter/ProductLimitNode.cpp | 4 +- .../orderman/limiter/ProductLimitNode.h | 8 +-- .../orderman/limiter/ProductLimitTree.h | 2 +- .../orderman/limiter/SecurityClipTree.h | 55 ------------------- .../orderman/limiter/SecurityLimitNode.cpp | 4 +- .../orderman/limiter/SecurityLimitNode.h | 6 +- .../orderman/limiter/SecurityLimitTree.h | 6 +- 10 files changed, 40 insertions(+), 86 deletions(-) delete mode 100644 src/server/sparkd/orderman/limiter/SecurityClipTree.h diff --git a/src/lib/api/service_helpers/AdminServiceUtils.cpp b/src/lib/api/service_helpers/AdminServiceUtils.cpp index 4dcf68c4b..6edd4935b 100644 --- a/src/lib/api/service_helpers/AdminServiceUtils.cpp +++ b/src/lib/api/service_helpers/AdminServiceUtils.cpp @@ -187,11 +187,11 @@ std::string AdminServiceUtils::find_account_exchange_account (const bts::api::ad } return rv; } -std::map AdminServiceUtils::accounts_map(const bts::api::admin::AdminData& admin_data){ - std::map rv; +std::map AdminServiceUtils::accounts_map(const bts::api::admin::AdminData& admin_data){ + std::map rv; auto account_ptrs = accounts(admin_data, false); for(const bts::api::admin::BTSAccount* account_ptr : account_ptrs) - rv.insert(std::pair(account_ptr->id(),account_ptr->is_active())); + rv.insert(std::pair(account_ptr->id(),account_ptr->is_active())); return rv; } void AdminServiceUtils::validate_account_update (const bts::api::admin::AdminData& admin_data, diff --git a/src/lib/api/service_helpers/AdminServiceUtils.h b/src/lib/api/service_helpers/AdminServiceUtils.h index e24497af6..6dafc2b03 100644 --- a/src/lib/api/service_helpers/AdminServiceUtils.h +++ b/src/lib/api/service_helpers/AdminServiceUtils.h @@ -70,7 +70,7 @@ public: api::Venue exchange, bts::api::admin::AdminServiceOperationResult& out_result); // returns a map of the accounts vs their 'is_active' - static std::map accounts_map(const bts::api::admin::AdminData& admin_data); + static std::map accounts_map(const bts::api::admin::AdminData& admin_data); // validates that the update to the account is valid static void validate_account_update (const bts::api::admin::AdminData& admin_data, const bts::api::admin::BTSAccount& updated_account, diff --git a/src/server/sparkd/orderman/limiter/LimitStore.h b/src/server/sparkd/orderman/limiter/LimitStore.h index 357596d1d..8290e504b 100644 --- a/src/server/sparkd/orderman/limiter/LimitStore.h +++ b/src/server/sparkd/orderman/limiter/LimitStore.h @@ -9,14 +9,18 @@ #include "Limiter.h" #include "ProductLimitTree.h" #include "SecurityLimitTree.h" -#include "SecurityClipTree.h" namespace bts { namespace orderman { -// this is the data unit for a product for an account. -// it contains the limit and the live values +// this contains all the data needed to enforce +// risk limits. all the data derived from the +// AdminData (user account relationships, position +// limits, clip sizes etc) are constant. The non const +// data are the positions class LimitStore{ private: + // for a single user, contains the trading accounts + // the user can trade in class UserData { public: const bts::api::admin::BTSUser* user; @@ -31,10 +35,13 @@ private: }; const bts::api::admin::AdminData _admin_data; // just an easy way to find accounts - const std::map _account_map; + const std::map _account_map; // map of user id's vs the user pointer and acccounts std::map _user_data_map; - std::map _sec_map; + // map of securities vs their account limits and positions + std::map _sec_map; + // this is passed over to the SecurityLimitTree + // entried (above) std::vector _prod_map; // these are kept here and references passes to each node const bts::api::admin::AccountProductPositionLimitUnit _zero_product_limit; @@ -43,13 +50,15 @@ public: LimitStore(const bts::api::admin::AdminData& admin_data, const std::map& sec_map); - // accessors - //////////// - bool has_account (AccountID account_id) const{return _account_map.find(account_id.value()) != _account_map.end();} - bool has_security (uint32_t sec_id) const {return _sec_map.find(sec_id) != _sec_map.end();} + // accessors /////////////// + //////////////////////////// + bool has_account (AccountID account_id) const + {return _account_map.find(account_id.value()) != _account_map.end();} + bool has_security (uint32_t sec_id) const + {return _sec_map.find(sec_id) != _sec_map.end();} const bts::api::admin::AdminData& admin_data () const {return _admin_data;} - // position updates - /////////////////// + // position updates //////// + //////////////////////////// void copy_positions_from(LimitStore& source); void add_position(const api::Security& security, AccountID account_id, api::Side side, @@ -87,7 +96,7 @@ public: //ii. user should be activated //iii. user should be permitted to trade in the account //iv. account should be activated - Limiter::LimiterQueryResult can_trade(UserID user_id, + Limiter::LimiterQueryResult can_trade(UserID user_id, AccountID account_id) const{ Limiter::LimiterQueryResult result; result.ok = true; auto user_it = _user_data_map.find(user_id.value()); diff --git a/src/server/sparkd/orderman/limiter/ProductLimitNode.cpp b/src/server/sparkd/orderman/limiter/ProductLimitNode.cpp index 25783c41a..d35e3ce42 100644 --- a/src/server/sparkd/orderman/limiter/ProductLimitNode.cpp +++ b/src/server/sparkd/orderman/limiter/ProductLimitNode.cpp @@ -3,8 +3,8 @@ namespace bts{ namespace orderman{ -ProductLimitNode::ProductLimitNode(int account_id, - int, // parent_account_id, +ProductLimitNode::ProductLimitNode(uint32_t account_id, + uint32_t, // parent_account_id, const bts::api::admin::AccountProductPositionLimitUnit& limit) : _account_id(account_id), diff --git a/src/server/sparkd/orderman/limiter/ProductLimitNode.h b/src/server/sparkd/orderman/limiter/ProductLimitNode.h index d0cbe2b06..4edff342d 100644 --- a/src/server/sparkd/orderman/limiter/ProductLimitNode.h +++ b/src/server/sparkd/orderman/limiter/ProductLimitNode.h @@ -18,17 +18,17 @@ namespace orderman{ // clip size. class ProductLimitNode{ private: - const int _account_id; // , _parent_account_id; + const uint32_t _account_id; // , _parent_account_id; const bts::api::admin::AccountProductPositionLimitUnit& _limit; const int _long_pos_limit, _short_pos_limit; int _net_pos; public: - ProductLimitNode(int account_id, - int parent_account_id, + ProductLimitNode(uint32_t account_id, + uint32_t parent_account_id, const bts::api::admin::AccountProductPositionLimitUnit& limit); // accessors //////////// - int account_id() const {return _account_id;} + uint32_t account_id() const {return _account_id;} int net_pos() const {return _net_pos;} // position updates /////////////////// diff --git a/src/server/sparkd/orderman/limiter/ProductLimitTree.h b/src/server/sparkd/orderman/limiter/ProductLimitTree.h index fc3a2b648..9c1e91f6e 100644 --- a/src/server/sparkd/orderman/limiter/ProductLimitTree.h +++ b/src/server/sparkd/orderman/limiter/ProductLimitTree.h @@ -25,7 +25,7 @@ public: const bts::api::admin::AccountProductPositionLimitUnit& zero_limit); // accessors //////////// - ProductLimitNode* find_account (int account_id){ + ProductLimitNode* find_account (uint32_t account_id){ for(auto it=_tree.begin(); it!=_tree.end(); it++) if(it->account_id()==account_id) return &*it; diff --git a/src/server/sparkd/orderman/limiter/SecurityClipTree.h b/src/server/sparkd/orderman/limiter/SecurityClipTree.h deleted file mode 100644 index dcbd99d9e..000000000 --- a/src/server/sparkd/orderman/limiter/SecurityClipTree.h +++ /dev/null @@ -1,55 +0,0 @@ -#pragma once - -#include -#include "lib/api/services/OrderService.pb.h" -#include "server/sparkd/orderman/orderman_utils/orderman_common.h" -#include "lib/domain_model/Security.pb.h" -#include "lib/api/services/AdminService.server.pb.h" -#include "lib/api/service_helpers/AdminServiceUtils.h" -#include "Limiter.h" - -namespace bts{ -namespace orderman{ - -class SecurityClipTree{ -private: - std::vector> _account_clips; -public: - SecurityClipTree (const api::Security& security, - const bts::api::admin::AdminData& admin_data){ - for(int i=0; ifirst == account_id) - return it->second; - return 0; - } - Limiter::LimiterQueryResult can_send_new_order(int account_id, uint32_t quantity) const{ - Limiter::LimiterQueryResult result; - result.ok = false; - for(auto it=_account_clips.begin(); it!=_account_clips.end(); it++){ - if(it->first==account_id){ - if(quantity>it->second){ - result.ok = false; - result.error_msg = fmt::format("Security Clip Size (Max {} Qty {})", it->second, quantity); - return result; - } - else{ - result.ok = true; - return result; - } - } - } - bts_assert(false); - return result; - } - Limiter::LimiterQueryResult can_update_order(int account_id, uint32_t to) const{ - return can_send_new_order(account_id, to); - } -}; -}} \ No newline at end of file diff --git a/src/server/sparkd/orderman/limiter/SecurityLimitNode.cpp b/src/server/sparkd/orderman/limiter/SecurityLimitNode.cpp index fdd56c560..bc7e12298 100644 --- a/src/server/sparkd/orderman/limiter/SecurityLimitNode.cpp +++ b/src/server/sparkd/orderman/limiter/SecurityLimitNode.cpp @@ -3,8 +3,8 @@ namespace bts { namespace orderman { -SecurityLimitNode::SecurityLimitNode(int account_id, - int, // parent_account_id, +SecurityLimitNode::SecurityLimitNode(uint32_t account_id, + uint32_t, // parent_account_id, const bts::api::admin::AccountSecurityPositionLimitUnit& limit, bool apply_sec_position_limits, ProductLimitNode& product_node, diff --git a/src/server/sparkd/orderman/limiter/SecurityLimitNode.h b/src/server/sparkd/orderman/limiter/SecurityLimitNode.h index a4847fd85..37025c849 100644 --- a/src/server/sparkd/orderman/limiter/SecurityLimitNode.h +++ b/src/server/sparkd/orderman/limiter/SecurityLimitNode.h @@ -20,7 +20,7 @@ namespace orderman{ // node, that is updated as fills come in. class SecurityLimitNode{ private: - const int _account_id; // , _parent_account_id; + const uint32_t _account_id; // , _parent_account_id; const bts::api::admin::AccountSecurityPositionLimitUnit& _limit; const int _long_pos_limit, _short_pos_limit; const bool _apply_sec_position_limits; @@ -28,14 +28,14 @@ private: const uint32_t _clip_size; int _net_pos; public: - SecurityLimitNode(int account_id, int parent_account_id, + SecurityLimitNode(uint32_t account_id, uint32_t parent_account_id, const bts::api::admin::AccountSecurityPositionLimitUnit& limit, bool apply_sec_position_limits, ProductLimitNode& product_limit, uint32_t clip_size); //accessors /////////// - int account_id() const {return _account_id;} + uint32_t account_id() const {return _account_id;} int net_pos() const {return _net_pos;} // position updates /////////////////// diff --git a/src/server/sparkd/orderman/limiter/SecurityLimitTree.h b/src/server/sparkd/orderman/limiter/SecurityLimitTree.h index b0b3bc77e..0b647cf8b 100644 --- a/src/server/sparkd/orderman/limiter/SecurityLimitTree.h +++ b/src/server/sparkd/orderman/limiter/SecurityLimitTree.h @@ -64,17 +64,17 @@ public: } // accessors //////////// - const SecurityLimitNode* find_account (int account_id) const{ + const SecurityLimitNode* find_account (uint32_t account_id) const{ return _find_account(account_id); } private: - SecurityLimitNode* _find_account (int account_id){ + SecurityLimitNode* _find_account (uint32_t account_id){ for(auto it=_tree.begin(); it!=_tree.end(); it++) if(it->account_id()==account_id) return &*it; return nullptr; } - const SecurityLimitNode* _find_account (int account_id) const{ + const SecurityLimitNode* _find_account (uint32_t account_id) const{ for(auto it=_tree.begin(); it!=_tree.end(); it++) if(it->account_id()==account_id) return &*it; From 85643adcf35ebe4cc945ae6c234ffaa34d1ebb95 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Sun, 27 May 2018 22:25:18 -0400 Subject: [PATCH 08/13] comments and some stylistic changes for the limiter --- .../sparkd/orderman/limiter/LimitStore.cpp | 6 +++--- .../sparkd/orderman/limiter/Limiter.cpp | 8 ++++---- .../orderman/limiter/ProductLimitTree.cpp | 16 +++++++--------- .../orderman/limiter/ProductLimitTree.h | 6 +++--- .../orderman/limiter/SecurityLimitTree.cpp | 19 +++++++++---------- .../orderman/limiter/SecurityLimitTree.h | 18 +++++++++--------- 6 files changed, 35 insertions(+), 38 deletions(-) diff --git a/src/server/sparkd/orderman/limiter/LimitStore.cpp b/src/server/sparkd/orderman/limiter/LimitStore.cpp index 5f34ca64c..ae8395f9f 100644 --- a/src/server/sparkd/orderman/limiter/LimitStore.cpp +++ b/src/server/sparkd/orderman/limiter/LimitStore.cpp @@ -55,9 +55,9 @@ ProductLimitTree* LimitStore::_find_product_for_security(const api::Security& se return _find_product(product); } ProductLimitTree* LimitStore::_find_product(const api::Product& product){ - for(auto it=_prod_map.begin(); it!= _prod_map.end(); it++) - if(product.exchange() == it->product().exchange() && product.type() == it->product().type() && product.symbol() == it->product().symbol()) - return &*it; + for(ProductLimitTree& plt : _prod_map) + if(product.exchange() == plt.product().exchange() && product.type() == plt.product().type() && product.symbol() == plt.product().symbol()) + return &plt; return nullptr; } const SecurityLimitNode* LimitStore::test_only_func_find_security_node(AccountID account_id, diff --git a/src/server/sparkd/orderman/limiter/Limiter.cpp b/src/server/sparkd/orderman/limiter/Limiter.cpp index 648978838..6cc2e0708 100644 --- a/src/server/sparkd/orderman/limiter/Limiter.cpp +++ b/src/server/sparkd/orderman/limiter/Limiter.cpp @@ -25,8 +25,8 @@ void Limiter::update(api::admin::AdminData const& admin_data) { } void Limiter::add_securities(std::vector const& new_securities){ LOG(OrderMan, Info, "Limiter::add_securities {} securities", me->sec_map.size()); - for(auto it=new_securities.begin(); it!=new_securities.end(); it++) - _add_security(*it); + for(const api::Security* s : new_securities) + _add_security(s); _reset(me->limit_store->admin_data()); } void Limiter::add_security(api::Security const & security) { @@ -88,8 +88,8 @@ void Limiter::_add_security (const api::Security* sec){ if (!_contains_security(sec)){ me->sec_map.insert(std::pair(sec->id(), sec)); if (sec->has_spread()) - for(int i=0; ispread().legs_size(); i++) - _add_security(&(sec->spread().legs(i).security())); + for(const auto& leg : sec->spread().legs()) + _add_security(&leg.security()); } } diff --git a/src/server/sparkd/orderman/limiter/ProductLimitTree.cpp b/src/server/sparkd/orderman/limiter/ProductLimitTree.cpp index 5df844d20..836ade264 100644 --- a/src/server/sparkd/orderman/limiter/ProductLimitTree.cpp +++ b/src/server/sparkd/orderman/limiter/ProductLimitTree.cpp @@ -6,14 +6,12 @@ namespace orderman{ ProductLimitTree::ProductLimitTree(const api::Product& product, const bts::api::admin::AdminData& admin_data, const bts::api::admin::AccountProductPositionLimitUnit& zero_limit) - : - _product (product) - { - for(int i=0; iaccount_id()==account_id) - return &*it; + for(ProductLimitNode& node : _tree) + if(node.account_id()==account_id) + return &node; return nullptr; } const api::Product& product() const {return _product;} diff --git a/src/server/sparkd/orderman/limiter/SecurityLimitTree.cpp b/src/server/sparkd/orderman/limiter/SecurityLimitTree.cpp index 024ada803..2fa39b585 100644 --- a/src/server/sparkd/orderman/limiter/SecurityLimitTree.cpp +++ b/src/server/sparkd/orderman/limiter/SecurityLimitTree.cpp @@ -7,15 +7,14 @@ SecurityLimitTree::SecurityLimitTree(const api::Security& security, ProductLimitTree& product_tree, const bts::api::admin::AdminData& admin_data, const bts::api::admin::AccountSecurityPositionLimitUnit& zero_limit) - { - for(int i=0; iremove_position(side, quantity.value()); } void copy_positions_from(SecurityLimitTree& source){ - for (auto it=_tree.begin(); it!=_tree.end(); it++){ - SecurityLimitNode* source_node_ptr = source._find_account(it->account_id()); + for (SecurityLimitNode& node : _tree){ + SecurityLimitNode* source_node_ptr = source._find_account(node.account_id()); if(source_node_ptr != nullptr) - it->copy_positions_from(*source_node_ptr); + node.copy_positions_from(*source_node_ptr); } } // risk limit checks @@ -69,15 +69,15 @@ public: } private: SecurityLimitNode* _find_account (uint32_t account_id){ - for(auto it=_tree.begin(); it!=_tree.end(); it++) - if(it->account_id()==account_id) - return &*it; + for(auto& node : _tree) + if(node.account_id()==account_id) + return &node; return nullptr; } const SecurityLimitNode* _find_account (uint32_t account_id) const{ - for(auto it=_tree.begin(); it!=_tree.end(); it++) - if(it->account_id()==account_id) - return &*it; + for(const auto& node : _tree) + if(node.account_id()==account_id) + return &node; return nullptr; } }; From bcaf65d7c607efd2dab1a50d5c89f22e79a278b1 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Mon, 28 May 2018 15:55:21 -0400 Subject: [PATCH 09/13] code moved for the wrappers around SpreaderorderBuilder into their own cpp's --- .../spreader/ISpreaderManager.h | 15 +- .../spreader/LegPropertyData.cpp | 23 +++ .../spreader/LegPropertyData.h | 35 +---- .../spreader/SpreaderChildOrderState.h | 5 +- .../SpreaderOrderBuilder.cpp | 36 +++++ .../SpreaderOrderBuilder.h | 144 ++++++------------ .../SpreaderOrderServices.cpp | 22 +++ .../SpreaderPreActivationOrderServices.cpp | 30 ++++ .../spreader_orders/tests/spreader_tests.cpp | 16 +- .../spreader_orders/tests/tests_common.h | 11 +- 10 files changed, 188 insertions(+), 149 deletions(-) create mode 100644 src/server/sparkd/orderman/orders/spreader_orders/spreader/LegPropertyData.cpp create mode 100644 src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.cpp create mode 100644 src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderServices.cpp create mode 100644 src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderPreActivationOrderServices.cpp diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/ISpreaderManager.h b/src/server/sparkd/orderman/orders/spreader_orders/spreader/ISpreaderManager.h index 837a3ceba..bccd62307 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader/ISpreaderManager.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/ISpreaderManager.h @@ -5,13 +5,12 @@ namespace bts { namespace orderman { class LegPropertyData; -// The SpreaderOrder spawns a bunch of SingleLegQuoters (to quote each active -// leg) and SingleFillHedgers (to hedge each fill), and offers them -// this interface to -// i. get data such as book and leg properties (in O(1) access time) -// ii. place, modify and cancel orders -class ISpreaderManager -{ +// The Spreader spawns a bunch of quoters and +// hedgers and hands them this interface to +// i. get data such as book and leg properties +// (in O(1) access time) +// ii. create new quoter order +class ISpreaderManager{ public: virtual bts::orderman::OrderKey spreader_order_key() const = 0; virtual bts::TimeStamp current_time() const = 0; @@ -24,4 +23,4 @@ public: // and updates the bookkeeping data virtual void setup_new_quoter_order (size_t leg_index) = 0; }; -}} +}} \ No newline at end of file diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/LegPropertyData.cpp b/src/server/sparkd/orderman/orders/spreader_orders/spreader/LegPropertyData.cpp new file mode 100644 index 000000000..1b8622e4d --- /dev/null +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/LegPropertyData.cpp @@ -0,0 +1,23 @@ +#include "LegPropertyData.h" +#include "ISpreaderManager.h" +#include "SpreaderUtils.h" + +namespace bts { +namespace orderman { + +LegPropertyData::LegPropertyData(size_t leg_index, + const bts::api::ContractLeg& leg_contract, + const bts::spark::LegSpreaderParams& leg_params, + api::Side trading_side, + const bts::api::orderman::OrderDefinition& quoter_order_definition, + const bts::api::orderman::OrderDefinition& hedger_order_definition) +: +_leg_index(leg_index), +_leg_contract(leg_contract), +_leg_params(leg_params), +_trading_side(trading_side), +_quoter_order_definition (quoter_order_definition), +_hedger_order_definition (hedger_order_definition){ + LOG(OrderMan, Info, "LegPropertyData.cons leg_idx: {} sec_key: {} side: {}", leg_index, leg_contract.security().id(), trading_side); +} +}} \ No newline at end of file diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/LegPropertyData.h b/src/server/sparkd/orderman/orders/spreader_orders/spreader/LegPropertyData.h index fa2b0bbe5..29aec71e5 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader/LegPropertyData.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/LegPropertyData.h @@ -3,11 +3,14 @@ #include "lib/domain_model/Security.pb.h" #include "lib/sparkproto/SparkProtos.pb.h" #include "lib/api/services/OrderService.pb.h" +#include "server/sparkd/orderman/orderman_utils/orderman_common.h" namespace bts { namespace orderman { -// collection of immutable leg data properties, shared -// between the Spreader, SingleLegQuoter and SingleFillHedger +// collection of immutable leg data. +// this copies all the data (there are +// no refs or pointers to outside this +// class) class LegPropertyData { private: @@ -17,43 +20,19 @@ private: const api::Side _trading_side; const bts::api::orderman::OrderDefinition _quoter_order_definition; const bts::api::orderman::OrderDefinition _hedger_order_definition; -public: - LegPropertyData(size_t leg_index, - const bts::api::ContractLeg& leg_contract, - const bts::spark::LegSpreaderParams& leg_params, - api::Side trading_side) - : - // copying the values via copy cons - _leg_index(leg_index), - _leg_contract(leg_contract), - _leg_params(leg_params), - _trading_side(trading_side) - { - } +public: LegPropertyData(size_t leg_index, const bts::api::ContractLeg& leg_contract, const bts::spark::LegSpreaderParams& leg_params, api::Side trading_side, const bts::api::orderman::OrderDefinition& quoter_order_definition, - const bts::api::orderman::OrderDefinition& hedger_order_definition) - : - // copying the values via copy cons - _leg_index(leg_index), - _leg_contract(leg_contract), - _leg_params(leg_params), - _trading_side(trading_side), - _quoter_order_definition (quoter_order_definition), - _hedger_order_definition (hedger_order_definition) - { - LOG(OrderMan, Info, "LegPropertyData.cons leg_idx: {} sec_key: {} side: {}", leg_index, leg_contract.security().id(), trading_side); - } + const bts::api::orderman::OrderDefinition& hedger_order_definition); size_t leg_index() const {return _leg_index;} const bts::api::ContractLeg& leg_contract() const {return _leg_contract;} const bts::spark::LegSpreaderParams& leg_params () const {return _leg_params;} api::Side trading_side() const {return _trading_side;} uint32_t security_key() const { return _leg_contract.security().id(); } // TODO: use seckey SecurityKey leg_security_key() const {return SecurityKey(_leg_contract.security().id());} - //const bts::SecurityKey& security_key() const {return bts::SecurityKey (_leg_contract.security().id());} const bts::api::Security& security() const { return _leg_contract.security(); } double price_multiplier() const { return _leg_contract.price_multiplier(); } double size_multiplier() const { return _leg_contract.quantity(); } diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderChildOrderState.h b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderChildOrderState.h index 790b75080..1614d5e4e 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderChildOrderState.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderChildOrderState.h @@ -169,10 +169,9 @@ public: Quantity last_update_filled_quantity () const {return _last_filled_quantity;} bool terminal_status() const { return SpreaderUtils::order_in_terminal_state(_status); } bool acknowledged () const {return SpreaderUtils::order_acknowledged (_status);} - void total_fills (Quantity& out_filled, Price& out_price) - { + void total_fills (Quantity& out_filled, Price& out_price) const{ SpreaderUtils::compute_average_price(_base_price, _base_quantity, _filled_price, _filled_quantity, out_price, out_filled); } - Quantity total_fills() {return Quantity(_base_quantity.value() + _filled_quantity.value());} + Quantity total_fills() const {return Quantity(_base_quantity.value() + _filled_quantity.value());} }; }} diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.cpp b/src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.cpp new file mode 100644 index 000000000..4a4fda9d7 --- /dev/null +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.cpp @@ -0,0 +1,36 @@ +#include "SpreaderOrderBuilder.h" + +namespace bts { +namespace orderman { + +SpreaderOrderBuilder::SpreaderOrderBuilder (bts::orderman::OrderKey parent_key, + const api::orderman::OrderDefinition& order_def, + const SpreaderPreActivationOrderServices& spreader_pao_services, + size_t reserve_sz) +: +_is_live(spreader_pao_services.is_live()){ + if (_is_live){ + LOG(OrderMan, Info, "SpreaderOrderBuilder.cons parent_key: {} sec_key: {}", parent_key, order_def.security_key()); + _real_order_builder = bts::orderman::OrderBuilder(parent_key, order_def, spreader_pao_services.pre_services(), reserve_sz); + } +} +SpreaderOrderBuilder::SpreaderOrderBuilder(SpreaderOrderBuilder&&) +: +_is_live(true){ + // this cons should never be called. the reason we need this + // is because SpreaderOrderBuilder's are stored in a vector. + // however we know the length of the vector (n of legs), and + // hence can reserve it at construction + bts_assert(false); +} +bts::orderman::ChildOrder SpreaderOrderBuilder::build(){ + if (_is_live) + return _real_order_builder.build(); + else + return bts::orderman::ChildOrder(); +} +void SpreaderOrderBuilder::activate(SpreaderOrderServices& order_services){ + if (_is_live) + _real_order_builder.activate(order_services.order_services()); +} +}} \ No newline at end of file diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.h b/src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.h index 23c09ce59..afd4ae40f 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.h @@ -7,85 +7,60 @@ namespace bts { namespace orderman { - -class TestOnlySpreaderPreActivationOrderServices -{ -private: - bool _resolve; - const std::vector _secs; -public: - TestOnlySpreaderPreActivationOrderServices (const std::vector& secs) - : _resolve(true), - _secs(secs) - {} - const bts::api::Security* resolve (SecurityKey key) const - { - if (_resolve) - { - for (size_t idx = 0; idx < _secs.size(); idx++) - if (_secs[idx].id() == key.value()) - return &_secs[idx]; - } - return nullptr; - } - void set_resolve_flag (bool resolve) {_resolve = resolve;} -}; - class SpreaderPreActivationOrderServices -{ +{ +public: + class TestOnlySpreaderPreActivationOrderServices + { + private: + bool _resolve; + const std::vector _secs; + public: + TestOnlySpreaderPreActivationOrderServices (const std::vector& secs) + : + _resolve(true), + _secs(secs) + {} + const bts::api::Security* resolve (SecurityKey key) const{ + if (_resolve) + for (const auto& sec : _secs) + if (sec.id() == key.value()) + return &sec; + return nullptr; + } + void set_resolve_flag (bool resolve) {_resolve = resolve;} + }; private: const bts::orderman::PreActivationOrderServices* _pre_services; const TestOnlySpreaderPreActivationOrderServices* _test_only_pre_services; public: - SpreaderPreActivationOrderServices (const bts::orderman::PreActivationOrderServices* pre_services) - : - _pre_services(pre_services), - _test_only_pre_services (nullptr) - {} - SpreaderPreActivationOrderServices (TestOnlySpreaderPreActivationOrderServices* test_only_pre_services) - : - _pre_services(nullptr), - _test_only_pre_services (test_only_pre_services) - {} - const bts::api::Security* resolve (SecurityKey key) const - { - if (is_live ()) - return _pre_services->sec_db.resolve(key); - else - return _test_only_pre_services->resolve(key); - } - bool is_live () const {return _pre_services != nullptr;} - const bts::orderman::PreActivationOrderServices& pre_services() const - { - bts_assert(is_live ()); - return *_pre_services; - } + SpreaderPreActivationOrderServices (const bts::orderman::PreActivationOrderServices* pre_services); + SpreaderPreActivationOrderServices (TestOnlySpreaderPreActivationOrderServices* test_only_pre_services); + const bts::api::Security* resolve (SecurityKey key) const; + bool is_live () const; + const bts::orderman::PreActivationOrderServices& pre_services() const; }; - +// SpreaderOrderServices pro class SpreaderOrderServices { private: const bool _is_live; bts::orderman::OrderServices* _order_services; public: - SpreaderOrderServices (bts::orderman::OrderServices* order_services) - : - _is_live(order_services != nullptr), - _order_services(order_services) - {} - bts::orderman::OrderServices& order_services() - { - bts_assert(_is_live); - return *_order_services; - } - void report_state(const api::orderman::OrderState &state) - { - if (is_live()) - _order_services->report_state(state); - } - bool is_live() const {return _is_live;} + SpreaderOrderServices (bts::orderman::OrderServices* order_services); + bts::orderman::OrderServices& order_services(); + void report_state(const api::orderman::OrderState &state); + bool is_live(); }; +// SpreaderOrderBuilder is a thin layer on top of +// OrderBuilder, which is used to build and activate +// orders. This layer is needed so that unit tests +// can be run without actually building the +// OrderBuilder. +// The spreader has 2 SpreaderOrderBuilder for +// each leg, 1 for the quoter and 1 for the hedger +// (cons'ed and housed in SpreaderBookKeepingData) class SpreaderOrderBuilder { private: @@ -95,43 +70,16 @@ public: SpreaderOrderBuilder (bts::orderman::OrderKey parent_key, const api::orderman::OrderDefinition& order_def, const SpreaderPreActivationOrderServices& spreader_pao_services, - size_t reserve_sz) - : - _is_live(spreader_pao_services.is_live()) - { - if (_is_live) - { - LOG(OrderMan, Info, "SpreaderOrderBuilder.cons parent_key: {} sec_key: {}", parent_key, order_def.security_key()); - _real_order_builder = bts::orderman::OrderBuilder(parent_key, order_def, spreader_pao_services.pre_services(), reserve_sz); - } - } + size_t reserve_sz); SpreaderOrderBuilder() = delete; SpreaderOrderBuilder(const SpreaderOrderBuilder&) = delete; - SpreaderOrderBuilder(SpreaderOrderBuilder&& other) - : _is_live(other._is_live) - { - if (_is_live) - _real_order_builder=std::move(other._real_order_builder); - // this cons should never be called. the reason we need this - // is because SpreaderOrderBuilder's are stored in a vector. - // however we know the length of the vector (n of legs), and - // hence can reserve it at construction - bts_assert(false); - } + SpreaderOrderBuilder(SpreaderOrderBuilder&& other); SpreaderOrderBuilder& operator=(const SpreaderOrderBuilder) = delete; SpreaderOrderBuilder& operator=(SpreaderOrderBuilder&& other) = delete; - bts::orderman::ChildOrder build() - { - if (_is_live) - return _real_order_builder.build(); - else - return bts::orderman::ChildOrder(); - } - void activate(SpreaderOrderServices& order_services) - { - if (_is_live) - _real_order_builder.activate(order_services.order_services()); - } + // public functions //////////////////// + //////////////////////////////////////// + bts::orderman::ChildOrder build(); + void activate(SpreaderOrderServices& order_services); }; }} diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderServices.cpp b/src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderServices.cpp new file mode 100644 index 000000000..088455daf --- /dev/null +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderServices.cpp @@ -0,0 +1,22 @@ +#include "SpreaderOrderBuilder.h" + +namespace bts{ +namespace orderman{ + +SpreaderOrderServices::SpreaderOrderServices (bts::orderman::OrderServices* order_services) +: +_is_live(order_services != nullptr), +_order_services(order_services) +{} +bts::orderman::OrderServices& SpreaderOrderServices::order_services(){ + bts_assert(_is_live); + return *_order_services; +} +void SpreaderOrderServices::report_state(const api::orderman::OrderState &state){ + if (is_live()) + _order_services->report_state(state); +} +bool SpreaderOrderServices::is_live() +{return _is_live;} + +}} \ No newline at end of file diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderPreActivationOrderServices.cpp b/src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderPreActivationOrderServices.cpp new file mode 100644 index 000000000..e4ba33b7c --- /dev/null +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderPreActivationOrderServices.cpp @@ -0,0 +1,30 @@ +#include "SpreaderOrderBuilder.h" + +namespace bts{ +namespace orderman{ + +SpreaderPreActivationOrderServices::SpreaderPreActivationOrderServices (const bts::orderman::PreActivationOrderServices* pre_services) +: +_pre_services(pre_services), +_test_only_pre_services (nullptr) +{} +SpreaderPreActivationOrderServices::SpreaderPreActivationOrderServices (TestOnlySpreaderPreActivationOrderServices* test_only_pre_services) +: +_pre_services(nullptr), +_test_only_pre_services (test_only_pre_services) +{} +const bts::api::Security* SpreaderPreActivationOrderServices::resolve (SecurityKey key) const{ + if (is_live ()) + return _pre_services->sec_db.resolve(key); + else + return _test_only_pre_services->resolve(key); +} +bool SpreaderPreActivationOrderServices::is_live () const{ + return _pre_services != nullptr; +} +const bts::orderman::PreActivationOrderServices& SpreaderPreActivationOrderServices::pre_services() const{ + bts_assert(is_live ()); + return *_pre_services; +} + +}} \ No newline at end of file diff --git a/src/server/sparkd/orderman/orders/spreader_orders/tests/spreader_tests.cpp b/src/server/sparkd/orderman/orders/spreader_orders/tests/spreader_tests.cpp index b4917ecc0..fea8a4cc9 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/tests/spreader_tests.cpp +++ b/src/server/sparkd/orderman/orders/spreader_orders/tests/spreader_tests.cpp @@ -141,7 +141,8 @@ TEST_CASE ("test_leg_quantity_normalization", "[spreader]") fill_quote_params(qp, 1.0); LegSpreaderParams lsp; fill_leg_spreader_params (lsp, 1.0, true, qp); - LegPropertyData leg_prop_data (0, leg, lsp, api::Side::SIDE_BUY); + bts::api::orderman::OrderDefinition order_def; + LegPropertyData leg_prop_data (0, leg, lsp, api::Side::SIDE_BUY, order_def, order_def); Quantity calc_value = SpreaderUtils::get_leg_quantity_from_spreader_quantity (leg_prop_data, Quantity (spr_qty)), expected_value = Quantity(static_cast (std::round(std::abs(leg_mult * spr_qty)))); REQUIRE (calc_value == expected_value); @@ -161,8 +162,9 @@ TEST_CASE ("test_leg_quantity_normalization", "[spreader]") LegSpreaderParams lsp_1, lsp_2; fill_leg_spreader_params (lsp_1, 1.0, true, qp_1); fill_leg_spreader_params (lsp_2, 1.0, true, qp_2); - LegPropertyData leg_prop_data_1 (0, leg_1, lsp_1, api::Side::SIDE_BUY); - LegPropertyData leg_prop_data_2 (1, leg_2, lsp_2, api::Side::SIDE_BUY); + bts::api::orderman::OrderDefinition order_def; + LegPropertyData leg_prop_data_1 (0, leg_1, lsp_1, api::Side::SIDE_BUY,order_def,order_def); + LegPropertyData leg_prop_data_2 (1, leg_2, lsp_2, api::Side::SIDE_BUY,order_def,order_def); Quantity calc_value = SpreaderUtils::get_leg_quantity_from_another_leg_quantity (leg_prop_data_1, Quantity(leg_qty), leg_prop_data_2), expected_value = Quantity(static_cast (std::round(std::abs(leg_qty * leg_mult_2 / leg_mult_1)))); REQUIRE (calc_value == expected_value); @@ -265,7 +267,7 @@ TEST_CASE ("spreader bookkeeping data", "[spreader]") bts::api::orderman::OrderDefinition order_def; fill_spreader_order_definition(order_def, Side::SIDE_BUY, synthetic_security, spreader_params); // putting it together in SpreaderBookkeepingData - TestOnlySpreaderPreActivationOrderServices testonly_spreader_pao_services = _create_spreader_pao_services(synthetic_security); + SpreaderPreActivationOrderServices::TestOnlySpreaderPreActivationOrderServices testonly_spreader_pao_services = _create_spreader_pao_services(synthetic_security); SpreaderPreActivationOrderServices pao_services (&testonly_spreader_pao_services); std::vector leg_props; SpreaderUtils::resolve_synthetic_spread(pao_services, order_def, leg_props); @@ -1578,7 +1580,7 @@ TEST_CASE ("spreader_START", "[spreader]") bts::api::orderman::OrderDefinition order_def; fill_spreader_order_definition(order_def, Side::SIDE_BUY, synthetic_security, spreader_params); // putting it together in SpreaderBookkeepingData - TestOnlySpreaderPreActivationOrderServices testonly_spreader_pao_services = _create_spreader_pao_services(synthetic_security); + SpreaderPreActivationOrderServices::TestOnlySpreaderPreActivationOrderServices testonly_spreader_pao_services = _create_spreader_pao_services(synthetic_security); SpreaderPreActivationOrderServices pao_services (&testonly_spreader_pao_services); std::vector leg_props; SpreaderUtils::resolve_synthetic_spread(pao_services, order_def, leg_props); @@ -1634,7 +1636,7 @@ TEST_CASE ("spreader_WORKING", "[spreader]") bts::api::orderman::OrderDefinition order_def; fill_spreader_order_definition(order_def, Side::SIDE_BUY, synthetic_security, spreader_params); // putting it together in SpreaderBookkeepingData - TestOnlySpreaderPreActivationOrderServices testonly_spreader_pao_services = _create_spreader_pao_services(synthetic_security); + SpreaderPreActivationOrderServices::TestOnlySpreaderPreActivationOrderServices testonly_spreader_pao_services = _create_spreader_pao_services(synthetic_security); SpreaderPreActivationOrderServices pao_services (&testonly_spreader_pao_services); std::vector leg_props; SpreaderUtils::resolve_synthetic_spread(pao_services, order_def, leg_props); @@ -1962,7 +1964,7 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") bts::api::orderman::OrderDefinition order_def; fill_spreader_order_definition(order_def, Side::SIDE_BUY, synthetic_security, spreader_params); // putting it together in SpreaderBookkeepingData - TestOnlySpreaderPreActivationOrderServices testonly_spreader_pao_services = _create_spreader_pao_services(synthetic_security); + SpreaderPreActivationOrderServices::TestOnlySpreaderPreActivationOrderServices testonly_spreader_pao_services = _create_spreader_pao_services(synthetic_security); SpreaderPreActivationOrderServices pao_services (&testonly_spreader_pao_services); std::vector leg_props; SpreaderUtils::resolve_synthetic_spread(pao_services, order_def, leg_props); diff --git a/src/server/sparkd/orderman/orders/spreader_orders/tests/tests_common.h b/src/server/sparkd/orderman/orders/spreader_orders/tests/tests_common.h index 40faf514f..d6f346c86 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/tests/tests_common.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/tests/tests_common.h @@ -206,9 +206,10 @@ LegPropertyData create_leg_property_data (const ContractLeg& leg, PreHedgeParams pre_hp; PostHedgeParams post_hp; fill_leg_spreader_params (lsp, price_multiplier, is_active_quoting, qp, pre_hp, post_hp); - return LegPropertyData (leg_index, leg, lsp, leg.side()); + bts::api::orderman::OrderDefinition order_def; + return LegPropertyData (leg_index, leg, lsp, leg.side(),order_def,order_def); } -TestOnlySpreaderPreActivationOrderServices _create_spreader_pao_services(const Security& synthetic_security) +SpreaderPreActivationOrderServices::TestOnlySpreaderPreActivationOrderServices _create_spreader_pao_services(const Security& synthetic_security) { std::vector rv; rv.push_back(synthetic_security); @@ -217,7 +218,7 @@ TestOnlySpreaderPreActivationOrderServices _create_spreader_pao_services(const S const bts::api::ContractLeg& leg = *it; rv.push_back(leg.security()); } - TestOnlySpreaderPreActivationOrderServices test_spreader_pao_services(rv); + SpreaderPreActivationOrderServices::TestOnlySpreaderPreActivationOrderServices test_spreader_pao_services(rv); return test_spreader_pao_services; } /**********************************************************************/ @@ -297,7 +298,7 @@ SpreaderManagerForTest* create_spreader_manager_2_legs (bts::orderman::OrderKey bts::api::orderman::OrderDefinition order_def; fill_spreader_order_definition(order_def, Side::SIDE_BUY, synthetic_security, spreader_params); - TestOnlySpreaderPreActivationOrderServices testonly_spreader_pao_services = _create_spreader_pao_services(synthetic_security); + SpreaderPreActivationOrderServices::TestOnlySpreaderPreActivationOrderServices testonly_spreader_pao_services = _create_spreader_pao_services(synthetic_security); SpreaderPreActivationOrderServices pao_services (&testonly_spreader_pao_services); std::vector leg_props; SpreaderUtils::resolve_synthetic_spread(pao_services, order_def, leg_props); @@ -314,7 +315,7 @@ SpreaderManagerForTest* create_spreader_manager_n_legs (bts::orderman::OrderKey bts::api::orderman::OrderDefinition order_def; fill_spreader_order_definition(order_def, Side::SIDE_BUY, synthetic_security, leg_params); - TestOnlySpreaderPreActivationOrderServices testonly_spreader_pao_services = _create_spreader_pao_services(synthetic_security); + SpreaderPreActivationOrderServices::TestOnlySpreaderPreActivationOrderServices testonly_spreader_pao_services = _create_spreader_pao_services(synthetic_security); SpreaderPreActivationOrderServices pao_services (&testonly_spreader_pao_services); std::vector leg_props; SpreaderUtils::resolve_synthetic_spread(pao_services, order_def, leg_props); From ca8b69116074751fb27555e164bad0414b373a8b Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Mon, 28 May 2018 19:34:06 -0400 Subject: [PATCH 10/13] SpreaderLegData broken into h and cpp, adding more comments and tightening some const's --- .../spreader/SpreaderBookkeepingData.h | 2 +- .../spreader/SpreaderLegData.cpp | 34 +++++++ .../spreader/SpreaderLegData.h | 98 +++++++++---------- .../SpreaderOrderBuilder.h | 6 +- 4 files changed, 84 insertions(+), 56 deletions(-) create mode 100644 src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderLegData.cpp diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderBookkeepingData.h b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderBookkeepingData.h index 48a324576..995ec4835 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderBookkeepingData.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderBookkeepingData.h @@ -116,7 +116,7 @@ public: LOG(OrderMan, Info, "SpreaderHedgerData::add_new_hedger end leg_index: {} hedge_price: {} hedge_quantity: {}", leg_index, hedge_price, hedge_quantity); return leg_hedgers.back(); } - void total_fills (Quantity& out_quantity, Price& out_price) + void total_fills (Quantity& out_quantity, Price& out_price) const { double avg_price = 0.0; double fills = std::numeric_limits::max(); diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderLegData.cpp b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderLegData.cpp new file mode 100644 index 000000000..95024068d --- /dev/null +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderLegData.cpp @@ -0,0 +1,34 @@ +#include "SpreaderLegData.h" + +namespace bts{ +namespace orderman{ + +SpreaderLegData::SpreaderLegData (const LegPropertyData& leg_property_data, + SingleLegQuoter& quoter, + SpreaderOrderBuilder& quoter_order_builder, + SpreaderOrderBuilder& hedger_order_builder, + std::vector& hedger_data_vector, + SpreaderChildOrderState& quoter_child_order_state) +: +_leg_property_data (leg_property_data), +_quoter(quoter), +_quoter_order_builder (quoter_order_builder), +_hedger_order_builder (hedger_order_builder), +_quoter_child_order_state (quoter_child_order_state), +_hedger_data_vector (hedger_data_vector), +_book() +{} + +SpreaderLegData::SpreaderLegData(SpreaderLegData&& other) +: +_leg_property_data (other._leg_property_data), +_quoter (other._quoter), +_quoter_order_builder(other._quoter_order_builder), +_hedger_order_builder(other._hedger_order_builder), +_quoter_child_order_state (other._quoter_child_order_state), +_hedger_data_vector (other._hedger_data_vector), +_book(){ + bts_assert (false); +} + +}} \ No newline at end of file diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderLegData.h b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderLegData.h index da4e92b8c..b9dd9ffd3 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderLegData.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderLegData.h @@ -9,15 +9,16 @@ namespace bts{ namespace orderman{ -// all the data for a leg : -// 1. leg property data -// 2. quoter -// 3. order builders -// 4. quoter child order -// 6. all the hedgers for this leg (ie when fills happens -// on other legs, and they are hedged in this leg) -// the higher level objects are returned by ref to mutate -// their state +// this class is a conveniance per leg wrapper +// on the SpreaderBookkeepingData's data. +// keeping it this way provides easy access +// to the leg data (vs searching for them in +// SpreaderBookkeepingData). + +// this class is created (and mantained) by +// SpreaderBookkeeping. all the data except +// for the Book and LegPropertyData +// are references to SpreaderBookkeeping class SpreaderLegData { private: @@ -34,32 +35,20 @@ public: SpreaderOrderBuilder& quoter_order_builder, SpreaderOrderBuilder& hedger_order_builder, std::vector& hedger_data_vector, - SpreaderChildOrderState& quoter_child_order_state) - : _leg_property_data (leg_property_data), - _quoter(quoter), - _quoter_order_builder (quoter_order_builder), - _hedger_order_builder (hedger_order_builder), - _quoter_child_order_state (quoter_child_order_state), - _hedger_data_vector (hedger_data_vector), - _book() - { - } + SpreaderChildOrderState& quoter_child_order_state); SpreaderLegData() = delete; SpreaderLegData(const SpreaderLegData&) = delete; - SpreaderLegData(SpreaderLegData&& other) - : _leg_property_data (other._leg_property_data), - _quoter (other._quoter), - _quoter_order_builder(other._quoter_order_builder), - _hedger_order_builder(other._hedger_order_builder), - _quoter_child_order_state (other._quoter_child_order_state), - _hedger_data_vector (other._hedger_data_vector), - _book() - { - bts_assert (false); - } - SpreaderLegData& operator=(const SpreaderLegData&) = delete; + // this cons is not deleted since for each leg, + // SpreaderLegData is stored in a vector, and + // vectors need either a copy cons or a move cons. + // however, since we dont grow the vector beyond + // the reserved size, this cons will NEVER be called + // and we assert in it. + SpreaderLegData(SpreaderLegData&& other); + SpreaderLegData& operator=(const SpreaderLegData&) = delete; SpreaderLegData& operator=(SpreaderLegData&&) = delete; - // accessors + // accessors //////////////////// + ///////////////////////////////// const LegPropertyData& leg_property_data() const {return _leg_property_data;} SingleLegQuoter& quoter() {return _quoter;} const bts::orderman::Book& book () const {return _book;} @@ -69,41 +58,42 @@ public: SpreaderOrderBuilder& quoter_order_builder() {return _quoter_order_builder;} SpreaderOrderBuilder& hedger_order_builder() {return _hedger_order_builder;} // returns the number of active hedgers - size_t n_hedgers() { return _hedger_data_vector.size(); } + size_t n_hedgers() const { return _hedger_data_vector.size(); } // returns the hedger at a given index - SpreaderHedgerData& get_hedger(size_t index) {return _hedger_data_vector[index];} + SpreaderHedgerData& get_hedger(size_t index) { + bts_assert(index<_hedger_data_vector.size()); + return _hedger_data_vector[index]; + } // returns a hedger from its order_key - SpreaderHedgerData* find_hedger_from_orderkey(bts::orderman::OrderKey order_key) - { - for (auto h_it = _hedger_data_vector.begin(); h_it != _hedger_data_vector.end(); ++h_it) - if (h_it->order_update_message().order_key() == order_key) - return &(*h_it); + SpreaderHedgerData* find_hedger_from_orderkey(bts::orderman::OrderKey order_key){ + for (SpreaderHedgerData& hedger : _hedger_data_vector) + if (hedger.order_update_message().order_key() == order_key) + return &hedger; return nullptr; } - std::vector& get_hedgers () {return _hedger_data_vector;} - // mutators - // called for every book update (copied by value) - void update_book(const bts::orderman::Book& book_arg) {_book = book_arg;} - void total_fills (Quantity& out_quantity, Price& out_price) const - { + // computes the total fills and the average price of + // the fills - across the quoter and all the hedgers + void total_fills (Quantity& out_quantity, + Price& out_price) const{ _quoter_child_order_state.total_fills(out_quantity, out_price); double sum = out_quantity.value() * out_price.value(); - for(auto it = _hedger_data_vector.begin(); it != _hedger_data_vector.end(); it++) - { + for (SpreaderHedgerData& hedger : _hedger_data_vector){ Quantity hedger_quantity; Price hedger_price; - SpreaderChildOrderState& hedge_order = it->order_update_message(); - hedge_order.total_fills(hedger_quantity, hedger_price); + hedger.order_update_message().total_fills(hedger_quantity, hedger_price); sum += hedger_quantity.value() * hedger_price.value(); out_quantity = Quantity(out_quantity.value() + hedger_quantity.value()); } out_price = out_quantity.value() == 0 ? Price(0) : Price(sum / out_quantity.value()); } - Quantity total_fills() const - { + Quantity total_fills() const{ uint32_t rv = _quoter_child_order_state.total_fills().value(); - for(auto it = _hedger_data_vector.begin(); it != _hedger_data_vector.end(); it++) - rv += it->order_update_message().total_fills().value(); + for (SpreaderHedgerData& hedger : _hedger_data_vector) + rv += hedger.order_update_message().total_fills().value(); return Quantity(rv); } + // mutators //////////////////// + //////////////////////////////// + // called for every book update + void update_book(const bts::orderman::Book& book_arg) {_book = book_arg;} }; -}} +}} \ No newline at end of file diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.h b/src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.h index afd4ae40f..149378eac 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.h @@ -40,7 +40,11 @@ public: bool is_live () const; const bts::orderman::PreActivationOrderServices& pre_services() const; }; -// SpreaderOrderServices pro +// SpreaderOrderServices is a thin wrapper around +// OrderServices. The solitary instance of this +// is held in the Spreader. +// (OrderServices is used to report status, sub to +// events etc) class SpreaderOrderServices { private: From eccd965ce1955f1ea78e28a2d961ca1efc5a74e1 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Mon, 28 May 2018 22:11:06 -0400 Subject: [PATCH 11/13] adding SpreaderBookkeepingData's cpp file --- .../spreader/SpreaderBookkeepingData.cpp | 62 +++++++++ .../spreader/SpreaderBookkeepingData.h | 119 ++++++------------ 2 files changed, 101 insertions(+), 80 deletions(-) create mode 100644 src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderBookkeepingData.cpp diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderBookkeepingData.cpp b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderBookkeepingData.cpp new file mode 100644 index 000000000..d34e45705 --- /dev/null +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderBookkeepingData.cpp @@ -0,0 +1,62 @@ +#include "SpreaderBookkeepingData.h" + +namespace bts{ +namespace orderman{ + +SpreaderBookkeepingData::SpreaderBookkeepingData (ISpreaderManager& spreader_manager, + bts::orderman::OrderKey spreader_order_key, + const api::orderman::OrderDefinition& order_def, + const SpreaderPreActivationOrderServices& spreader_pao_services, + const std::vector& legs) +: +_is_live(spreader_pao_services.is_live()), +_n_legs(legs.size()), +_order_def(order_def){ + LOG(OrderMan, Info, "SpreaderBookkeepingData.cons started key: {} n_legs: {}", spreader_order_key.value(), _n_legs); + _quoter_order_builders.reserve(_n_legs); + _hedger_order_builders.reserve(_n_legs); + _quoter_child_order_states.reserve(_n_legs); + _quoters.reserve (_n_legs); + _hedgers.reserve (_n_legs); + _leg_data.reserve (_n_legs); + for (size_t l_idx = 0; l_idx < legs.size(); l_idx++){ + const LegPropertyData& leg_property_data = legs[l_idx]; + _quoter_order_builders.emplace_back(spreader_order_key, leg_property_data.quoter_order_definition(), spreader_pao_services, 10); + _hedger_order_builders.emplace_back(spreader_order_key, leg_property_data.hedger_order_definition(), spreader_pao_services, 10); + _quoter_child_order_states.emplace_back (_is_live, leg_property_data); + _quoters.emplace_back(spreader_manager, leg_property_data, _n_legs, _quoter_child_order_states.back()); + _hedgers.emplace_back (); + _leg_data.emplace_back(leg_property_data, _quoters.back(), _quoter_order_builders.back(), _hedger_order_builders.back(), _hedgers.back (), _quoter_child_order_states.back()); + bts_assert (_sec_key_to_index.find(leg_property_data.security_key()) == _sec_key_to_index.end()); + _sec_key_to_index.insert(std::pair(leg_property_data.security_key(), leg_property_data.leg_index())); + } + LOG(OrderMan, Info, "SpreaderBookkeepingData.cons completed key: {} n_legs: {}", spreader_order_key.value(), _n_legs); +} +void SpreaderBookkeepingData::total_fills (Quantity& out_quantity, + Price& out_price) const{ + double avg_price = 0.0; + double fills = std::numeric_limits::max(); + for (const SpreaderLegData& leg_data : _leg_data){ + Quantity leg_fill_qty; Price leg_fill_price; + leg_data.total_fills(leg_fill_qty, leg_fill_price); + double normalized_qty = std::abs(static_cast(leg_fill_qty.value()) / leg_data.leg_property_data().size_multiplier()); + fills = normalized_qty < fills ? normalized_qty : fills; + avg_price += leg_fill_price.value() * leg_data.leg_property_data().price_multiplier(); + } + out_quantity = Quantity(fills); + out_price = Price(avg_price); +} +SpreaderHedgerData& SpreaderBookkeepingData::add_new_hedger(ISpreaderManager& spreader_manager, + size_t leg_index, + bts::Price hedge_price, + bts::Quantity hedge_quantity){ + LOG(OrderMan, Info, "SpreaderHedgerData::add_new_hedger begin leg_index: {} hedge_price: {} hedge_quantity: {}", leg_index, hedge_price, hedge_quantity); + bts_assert(leg_index < _n_legs); + SpreaderLegData& leg_data = _leg_data[leg_index]; + std::vector& leg_hedgers = _hedgers[leg_index]; + bts::orderman::ChildOrder hedge_order = leg_data.hedger_order_builder().build(); + leg_hedgers.emplace_back (spreader_manager, leg_data.leg_property_data(), hedge_order, _is_live, hedge_price, hedge_quantity); + LOG(OrderMan, Info, "SpreaderHedgerData::add_new_hedger end leg_index: {} hedge_price: {} hedge_quantity: {}", leg_index, hedge_price, hedge_quantity); + return leg_hedgers.back(); +} +}} \ No newline at end of file diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderBookkeepingData.h b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderBookkeepingData.h index 995ec4835..662980da7 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderBookkeepingData.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderBookkeepingData.h @@ -12,8 +12,10 @@ namespace bts{ namespace orderman { class SpreaderHedgerData; -// encapsulates, organizes and provides easy access and lookups -// for data needed by the spreader +// encapsulates, organizes and provides easy access +// and lookups for data needed by the spreader. +// this data includes the book, orders, quoters, +// hedgers, price/qty etc class SpreaderBookkeepingData { private: @@ -34,108 +36,65 @@ public: bts::orderman::OrderKey spreader_order_key, const api::orderman::OrderDefinition& order_def, const SpreaderPreActivationOrderServices& spreader_pao_services, - const std::vector& legs) - : - _is_live(spreader_pao_services.is_live()), - _n_legs(legs.size()), - _order_def(order_def) - { - LOG(OrderMan, Info, "SpreaderBookkeepingData.cons started key: {} n_legs: {}", spreader_order_key.value(), _n_legs); - _quoter_order_builders.reserve(_n_legs); - _hedger_order_builders.reserve(_n_legs); - _quoter_child_order_states.reserve(_n_legs); - _quoters.reserve (_n_legs); - _hedgers.reserve (_n_legs); - _leg_data.reserve (_n_legs); - for (size_t l_idx = 0; l_idx < legs.size(); l_idx++) - { - const LegPropertyData& leg_property_data = legs[l_idx]; - _quoter_order_builders.emplace_back(spreader_order_key, leg_property_data.quoter_order_definition(), spreader_pao_services, 10); - _hedger_order_builders.emplace_back(spreader_order_key, leg_property_data.hedger_order_definition(), spreader_pao_services, 10); - _quoter_child_order_states.emplace_back (_is_live, leg_property_data); - _quoters.emplace_back(spreader_manager, leg_property_data, _n_legs, _quoter_child_order_states.back()); - _hedgers.emplace_back (); - _leg_data.emplace_back(leg_property_data, _quoters.back(), _quoter_order_builders.back(), _hedger_order_builders.back(), _hedgers.back (), _quoter_child_order_states.back()); - bts_assert (_sec_key_to_index.find(leg_property_data.security_key()) == _sec_key_to_index.end()); - _sec_key_to_index.insert(std::pair(leg_property_data.security_key(), leg_property_data.leg_index())); - } - LOG(OrderMan, Info, "SpreaderBookkeepingData.cons completed key: {} n_legs: {}", spreader_order_key.value(), _n_legs); - } + const std::vector& legs); SpreaderBookkeepingData (const SpreaderBookkeepingData&) = delete; SpreaderBookkeepingData (SpreaderBookkeepingData&&) = delete; SpreaderBookkeepingData& operator=(const SpreaderBookkeepingData&) = delete; SpreaderBookkeepingData& operator=(SpreaderBookkeepingData&&) = delete; - SpreaderLegData& get_leg_data (SecurityKey security_key) - { + // accessors //////////////////// + ///////////////////////////////// + size_t n_legs() const { return _n_legs; } + bool all_legs_resolved() const {return n_legs() > 0;} + const api::orderman::OrderDefinition& order_def() const {return _order_def;} + Price price () const {return _price;} + Quantity quantity () const {return _quantity;} + // gets leg data from leg's sec key + SpreaderLegData& get_leg_data (SecurityKey security_key){ boost::container::flat_map::const_iterator l_it = _sec_key_to_index.find(security_key.value()); bts_assert (l_it != _sec_key_to_index.end()); return _leg_data[l_it->second]; } - SpreaderLegData& get_leg_data(size_t index) - { + // gets leg data from leg index + SpreaderLegData& get_leg_data(size_t index){ bts_assert(index < _leg_data.size()); return _leg_data[index]; } - const SpreaderLegData& get_leg_data (size_t index) const - { + // same as above for const access + const SpreaderLegData& get_leg_data (size_t index) const{ bts_assert(index < _leg_data.size()); return _leg_data[index]; } - size_t n_legs() const { return _n_legs; } - bool all_legs_resolved() const {return n_legs() > 0;} - const api::orderman::OrderDefinition& order_def() const {return _order_def;} - SpreaderLegData* find_leg_from_quoter_orderkey(bts::orderman::OrderKey order_key) - { - for (auto q_it = _leg_data.begin(); q_it != _leg_data.end(); q_it++) - if (q_it->leg_property_data().is_active_quoting()) - if (q_it->key() == order_key) - return &(*q_it); + // finds the quoter that has the arg order key + SpreaderLegData* find_leg_from_quoter_orderkey(bts::orderman::OrderKey order_key){ + for (SpreaderLegData& leg : _leg_data) + if (leg.leg_property_data().is_active_quoting()) + if (leg.key() == order_key) + return ⋚ return nullptr; } - SpreaderHedgerData* find_hedger_from_orderkey(bts::orderman::OrderKey order_key) - { - for (auto l_it = _leg_data.begin(); l_it != _leg_data.end(); ++l_it) - { - SpreaderHedgerData* rv = l_it->find_hedger_from_orderkey (order_key); + // finds the hedger that has the arg order key + SpreaderHedgerData* find_hedger_from_orderkey(bts::orderman::OrderKey order_key){ + for (SpreaderLegData& leg : _leg_data){ + SpreaderHedgerData* rv = leg.find_hedger_from_orderkey (order_key); if (rv != nullptr) return rv; } return nullptr; } + // creates a new hedger for a given leg index, + // adds it to appropriate place in _hedgers, + // and returns a ref to it + // (dont keep pointers to hedgers since the vector + // can resize) SpreaderHedgerData& add_new_hedger(ISpreaderManager& spreader_manager, size_t leg_index, bts::Price hedge_price, - bts::Quantity hedge_quantity) - { - LOG(OrderMan, Info, "SpreaderHedgerData::add_new_hedger begin leg_index: {} hedge_price: {} hedge_quantity: {}", leg_index, hedge_price, hedge_quantity); - bts_assert(leg_index < _n_legs); - SpreaderLegData& leg_data = _leg_data[leg_index]; - std::vector& leg_hedgers = _hedgers[leg_index]; - bts::orderman::ChildOrder hedge_order = leg_data.hedger_order_builder().build(); - leg_hedgers.emplace_back (spreader_manager, leg_data.leg_property_data(), hedge_order, _is_live, hedge_price, hedge_quantity); - LOG(OrderMan, Info, "SpreaderHedgerData::add_new_hedger end leg_index: {} hedge_price: {} hedge_quantity: {}", leg_index, hedge_price, hedge_quantity); - return leg_hedgers.back(); - } - void total_fills (Quantity& out_quantity, Price& out_price) const - { - double avg_price = 0.0; - double fills = std::numeric_limits::max(); - for (auto it = _leg_data.begin(); it != _leg_data.end(); it++) - { - const SpreaderLegData& leg_data = *it; - Quantity leg_fill_qty; Price leg_fill_price; - leg_data.total_fills(leg_fill_qty, leg_fill_price); - double normalized_qty = std::abs(static_cast(leg_fill_qty.value()) / leg_data.leg_property_data().size_multiplier()); - fills = normalized_qty < fills ? normalized_qty : fills; - avg_price += leg_fill_price.value() * leg_data.leg_property_data().price_multiplier(); - } - out_quantity = Quantity(fills); - out_price = Price(avg_price); - } - Price price () const {return _price;} - Quantity quantity () const {return _quantity;} - void update_order (Price price, Quantity quantity) - { + bts::Quantity hedge_quantity); + // finds the spreader fill, price (ie averages it out, using + // the size and price ratio, across all legs) + void total_fills (Quantity& out_quantity, Price& out_price) const; + // updates the price, qty of the spreader order + void update_order (Price price, Quantity quantity){ _price = price; _quantity = quantity; } From 77d47fd38729b8f18c2d4b7e3d555f34d64e2f0e Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Mon, 28 May 2018 23:44:34 -0400 Subject: [PATCH 12/13] header file include culling --- .../spreader/SpreaderLegData.h | 2 +- .../spreader/SpreaderUtils.cpp | 31 ++++++++----------- .../spreader_orders/spreader/SpreaderUtils.h | 12 ++----- .../spreader_orders/tests/tests_common.h | 1 + 4 files changed, 18 insertions(+), 28 deletions(-) diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderLegData.h b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderLegData.h index b9dd9ffd3..c8fad15fb 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderLegData.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderLegData.h @@ -5,7 +5,7 @@ #include "SpreaderHedgerData.h" #include "SpreaderChildOrderState.h" #include "server/sparkd/orderman/actors/order_manager/OrderBuilder.h" -#include +#include "server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.h" namespace bts{ namespace orderman{ diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.cpp b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.cpp index 23fbcb5b3..7602de226 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.cpp +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.cpp @@ -1,4 +1,8 @@ #include "SpreaderUtils.h" +#include "server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.h" +#include "server/sparkd/orderman/orders/PreActivationOrderServices.h" +#include "server/sparkd/orderman/events/BookUpdateEvent.h" +#include namespace bts{ namespace orderman{ @@ -17,21 +21,16 @@ bool SpreaderUtils::resolve_synthetic_spread (const SpreaderPreActivationOrderSe bts_assert(order_def.has_custom_def() && order_def.custom_def().has_spreader()); const bts::api::Security* sec_ptr = resolve_synthetic ? spreader_pao_services.resolve (SecurityKey(order_def.security_key())) : &order_def.custom_def().spreader().security(); - if (sec_ptr != nullptr) - { + if (sec_ptr != nullptr){ const spark::ExecutionStrategy& execution_strategy = order_def.custom_def().spreader().execution_strategy(); const bts::api::Security& sec = *sec_ptr; - if (sec.has_synthetic() && sec.synthetic().legs().size() > 0) - { + if (sec.has_synthetic() && sec.synthetic().legs().size() > 0){ size_t leg_idx = 0; - for (auto it = sec.synthetic().legs().begin(); it != sec.synthetic().legs().end(); ++it) - { + for (auto it = sec.synthetic().legs().begin(); it != sec.synthetic().legs().end(); ++it){ const bts::api::ContractLeg& leg = *it; - if (leg.security().has_future() || leg.security().has_spread()) - { + if (leg.security().has_future() || leg.security().has_spread()){ const bts::api::Security* leg_sec_ptr = spreader_pao_services.resolve(bts::SecurityKey (leg.security().id())); - if (leg_sec_ptr != nullptr) - { + if (leg_sec_ptr != nullptr){ bts_assert(leg_sec_ptr->id() == leg.security().id()); LOG(OrderMan, Info, "resolve_synthetic_spread resolved leg key {}", leg_sec_ptr->id()); auto leg_exec_strategy_it = execution_strategy.leg_params_map().find(leg.security().id()); @@ -50,28 +49,24 @@ bool SpreaderUtils::resolve_synthetic_spread (const SpreaderPreActivationOrderSe out_resolved.push_back(leg_property_data); leg_idx++; } - else - { + else{ LOG(OrderMan, Error, "resolve_synthetic_spread failure: could not resolve leg key: {}", leg.security().id()); return false; } } - else - { + else{ LOG(OrderMan, Error, "resolve_synthetic_spread failure: leg with key: {} was not a future or future spread", leg.security().id()); return false; } } return true; } - else - { + else{ LOG(OrderMan, Error, "resolve_synthetic_spread failure: no legs in the spread"); return false; } } - else - { + else{ LOG(OrderMan, Error, "resolve_synthetic_spread failure: could not resolve synthetic security key: {}", order_def.security_key()); return false; } diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.h b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.h index d07af8777..a2f176dbd 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.h @@ -1,27 +1,21 @@ #pragma once -#include -#include "lib/config/protos/MarketData.pb.h" #include "lib/utils/bts_chrono.h" #include "lib/md/PriceSize.h" #include "lib/domain_model/Security.h" #include "server/sparkd/orderman/orderman_utils/Book.h" #include "server/sparkd/orderman/orders/spreader_orders/spreader/LegPropertyData.h" -#include "server/sparkd/orderman/orders/spreader_orders/spreader/QuoteLegPriceQuantityState.h" -#include "server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.h" #include "server/sparkd/orderman/orders/spreader_orders/spreader/ISpreaderManager.h" #include "server/sparkd/orderman/orders/spreader_orders/spreader/quoter/QuoterLegDriverData.h" -#include "server/sparkd/securities/ISecurityDB.h" #include "lib/api/services/OrderService.pb.h" #include "server/sparkd/orderman/actors/order_manager/OrderBuilder.h" -#include "server/sparkd/orderman/orders/PreActivationOrderServices.h" -#include "server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.h" -#include "server/sparkd/orderman/events/BookUpdateEvent.h" -#include namespace bts { namespace orderman { +class SpreaderPreActivationOrderServices; +class BookUpdateEvent; + // collection of helper functions used by the quoter, hedger // and the spreader glue class SpreaderUtils diff --git a/src/server/sparkd/orderman/orders/spreader_orders/tests/tests_common.h b/src/server/sparkd/orderman/orders/spreader_orders/tests/tests_common.h index d6f346c86..cc26ff5de 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/tests/tests_common.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/tests/tests_common.h @@ -13,6 +13,7 @@ #include "lib/utils/bts_chrono.h" #include "server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderChildOrderState.h" #include "server/sparkd/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.h" +#include namespace bts { namespace orderman { From c22ce4b886d4dd3c0eb890b75f6ba7a42950399b Mon Sep 17 00:00:00 2001 From: Jake Norbut Date: Tue, 29 May 2018 10:19:15 -0500 Subject: [PATCH 13/13] SPARK-1165 - Fills windows default filtes to since Globex open --- src/client/spark/Modules/Trading/Fills/FillsVM.cs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/client/spark/Modules/Trading/Fills/FillsVM.cs b/src/client/spark/Modules/Trading/Fills/FillsVM.cs index 7c64699f5..dd1d48300 100644 --- a/src/client/spark/Modules/Trading/Fills/FillsVM.cs +++ b/src/client/spark/Modules/Trading/Fills/FillsVM.cs @@ -58,6 +58,13 @@ namespace mbts.spark { fill_key_filter.load_state(filters.fill_key); order_key_filter.load_state(filters.order_key); security_key_filter.load_state(filters.security_key); + } else { + fill_time_filter.load_state( + new TimeFilterTuple(ui.controls.TimeFilterMode.CMEOpen, + TimeTextTuple.FromDateTime(DateTime.Today), + TimeTextTuple.FromDateTime(DateTime.Today.AddDays(1)) + ) + ); } // columns add_col(Columns.Security, DefaultColumnHeaders.Security, r => r.security.ToString(null), nameof(Row.security), security_filter, DataGridFilterKnownTemplates.DiscreteValues, DefaultColumnWidths.Security);