381 lines
23 KiB
C#
381 lines
23 KiB
C#
using bts.api;
|
|
using bts.api.orderman;
|
|
using bts.shell;
|
|
using bts.utils;
|
|
using mbts.spark;
|
|
using mbts.ui;
|
|
using mbts.ui.settings;
|
|
using mbts.ui.utility;
|
|
using mbts.utils;
|
|
using ProtoBuf;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reactive.Linq;
|
|
using OrderType = bts.api.orderman.CustomOrderDefinition.CustomOneofCase;
|
|
using PTOC = mbts.OrderRecordTuplePredicate.PredicateTypeOneofCase;
|
|
|
|
namespace mbts {
|
|
static class OrderRecordTuplePredicateVMFactory {
|
|
// TODO: uncomment the remaining cases when ready
|
|
public static Dictionary<PTOC, ITemplatedPropertyWrapperVM<OrderRecordTuplePredicate>> get_oneofs(IBus bus, OrdersModel orders_model) {
|
|
return new Dictionary<PTOC, ITemplatedPropertyWrapperVM<OrderRecordTuplePredicate>> {
|
|
{ PTOC.FilledEvent, wrap(rp => rp.filled_event, (rp, p) => rp.filled_event = p, p => p.predicate_type_case, OrderFilledEventPredicateVMFactory.get_oneofs(bus)) },
|
|
{ PTOC.CompletedEvent, wrap(rp => rp.completed_event, (rp, p) => rp.completed_event = p, p => p.predicate_type_case, OrderCompletedEventPredicateVMFactory.get_oneofs(bus)) },
|
|
{ PTOC.CanceledEvent, wrap(rp => rp.canceled_event, (rp, p) => rp.canceled_event = p, p => p.predicate_type_case, OrderCanceledEventPredicateVMFactory.get_oneofs(bus)) },
|
|
//{ PTOC.Security, wrap(rp => rp.security, (rp, p) => rp.security = p, p => p.predicate_type_case, SecurityCriteriaVMFactory.get_oneofs(bus)) },
|
|
//{ PTOC.Time, wrap(rp => rp.time_created, (rp, p) => rp.time_created = p, t => t.predicate_type_case, TimePredicateVMFactory.get_oneofs()) },
|
|
//{ PTOC.LastChange, wrap(rp => rp.last_change, (rp, p) => rp.last_change = p, t => t.predicate_type_case, TimePredicateVMFactory.get_oneofs()) },
|
|
//{ PTOC.User, wrap(rp => rp.user, (rp, p) => rp.user = p, p => p.predicate_type_case, DiscreteValuesPredicateVMFactory.get_oneofs<uint, uint, uint?, uint[], DiscreteUIntPredicate>(
|
|
// RXCollection.Create(orders_model.factory.subscribe_user_ids().Select(tups => tups.Select(convert_name_id))), id => id, id => id.Value, id => id, ids => ids, ids => ids.ToArray())) },
|
|
//{ PTOC.Account, wrap(rp => rp.account, (rp, p) => rp.account = p, p => p.predicate_type_case, DiscreteValuesPredicateVMFactory.get_oneofs<uint, uint, uint?, uint[], DiscreteUIntPredicate>(
|
|
// RXCollection.Create(orders_model.factory.subscribe_account_ids().Select(tups => tups.Select(convert_name_id))), id => id, id => id.Value, id => id, ids => ids, ids => ids.ToArray())) },
|
|
//{ PTOC.Exchange, wrap(rp => rp.exchange, (rp, p) => rp.exchange = p, p => p.predicate_type_case, DiscreteValuesPredicateVMFactory.get_oneofs_value_type<Venue, ExchangePredicate>(EnumHelper.get_values_except(Venue.Unset))) },
|
|
//{ PTOC.TimeInForce, wrap(rp => rp.time_in_force, (rp, p) => rp.time_in_force = p, p => p.predicate_type_case, DiscreteValuesPredicateVMFactory.get_oneofs_value_type<TimeInForce, TimeInForcePredicate>(EnumHelper.get_values_except(TimeInForce.Undefined))) },
|
|
//{ PTOC.Side, wrap(rp => rp.side, (rp, p) => rp.side = p, p => p.predicate_type_case, SidePredicateVMFactory.get_oneofs()) },
|
|
//{ PTOC.Price, wrap(rp => rp.price, (rp, p) => rp.price = p, p => p.predicate_type_case, DoublePredicateVMFactory.get_oneofs()) },
|
|
//{ PTOC.Size, wrap(rp => rp.quantity, (rp, p) => rp.quantity = p, p => p.predicate_type_case, UIntPredicateVMFactory.get_oneofs()) },
|
|
//{ PTOC.Filled, wrap(rp => rp.filled_quantity, (rp, p) => rp.filled_quantity = p, p => p.predicate_type_case, UIntPredicateVMFactory.get_oneofs()) },
|
|
//{ PTOC.AvgFilled, wrap(rp => rp.avg_price, (rp, p) => rp.avg_price = p, p => p.predicate_type_case, DoublePredicateVMFactory.get_oneofs()) },
|
|
//{ PTOC.LastPrice, wrap(rp => rp.last_price, (rp, p) => rp.last_price = p, p => p.predicate_type_case, DoublePredicateVMFactory.get_oneofs()) },
|
|
//{ PTOC.OrderType, wrap(rp => rp.order_type, (rp, p) => rp.order_type = p, p => p.predicate_type_case, DiscreteValuesPredicateVMFactory.get_oneofs_value_type<OrderType, OrderTypePredicate>(EnumHelper.get_values_except(OrderType.None))) },
|
|
//{ PTOC.SubType, wrap(rp => rp.order_sub_type, (rp, p) => rp.order_sub_type = p, p => p.predicate_type_case, DiscreteValuesPredicateVMFactory.get_oneofs_value_type<OrderSubType, OrderSubTypePredicate>(EnumHelper.get_values<OrderSubType>())) },
|
|
//{ PTOC.Status, wrap(rp => rp.order_status, (rp, p) => rp.order_status = p, p => p.predicate_type_case, DiscreteValuesPredicateVMFactory.get_oneofs_value_type<OrderStatus, OrderStatusPredicate>(EnumHelper.get_values<OrderStatus>())) },
|
|
//{ PTOC.LastMessage, wrap(rp => rp.last_message, (rp, p) => rp.last_message = p, p => p.predicate_type_case, StringPredicateVMFactory.get_oneofs()) },
|
|
//{ PTOC.SecurityKey, wrap(rp => rp.security_key, (rp, p) => rp.security_key = p, p => p.predicate_type_case, UIntPredicateVMFactory.get_oneofs()) },
|
|
//{ PTOC.OrderKey, wrap(rp => rp.order_key, (rp, p) => rp.order_key = p, p => p.predicate_type_case, UIntPredicateVMFactory.get_oneofs()) },
|
|
//{ PTOC.ParentKey, wrap(rp => rp.parent_key, (rp, p) => rp.parent_key = p, p => p.predicate_type_case, UIntPredicateVMFactory.get_oneofs()) },
|
|
};
|
|
|
|
//IViewValue<uint> convert_name_id((string name, uint id) tup) =>
|
|
// new ViewValueTuple<uint>(tup.id, tup.name);
|
|
|
|
ITemplatedPropertyWrapperVM<OrderRecordTuplePredicate> wrap<TChildPredicate, TChildPredicateOneof>(
|
|
Func<OrderRecordTuplePredicate, TChildPredicate> get,
|
|
Action<OrderRecordTuplePredicate, TChildPredicate> set,
|
|
Func<TChildPredicate, TChildPredicateOneof> key,
|
|
Dictionary<TChildPredicateOneof, ITemplatedPropertyWrapperVM<TChildPredicate>> oneofs) where TChildPredicateOneof : struct where TChildPredicate : new() =>
|
|
//
|
|
PredicateVMWrapper.wrap_child_oneof<OrderRecordTuplePredicate, TChildPredicate, TChildPredicateOneof>(get, set, key, oneofs);
|
|
}
|
|
}
|
|
|
|
[ProtoContract]
|
|
class OrderRecordTuplePredicate : IEquatable<OrderRecordTuplePredicate> {
|
|
SecurityPredicate _security;
|
|
SidePredicate _side;
|
|
DoublePredicate _price, _last_price, _avg_price;
|
|
UIntPredicate _quantity, _filled_quantity, _security_key, _order_key, _parent_key;
|
|
OrderStatusPredicate _order_status;
|
|
OrderTypePredicate _order_type;
|
|
OrderSubTypePredicate _order_sub_type;
|
|
TimePredicate _time_created, _last_change;
|
|
TimeInForcePredicate _time_in_force;
|
|
DiscreteUIntPredicate _account, _user;
|
|
StringPredicate _last_message;
|
|
ExchangePredicate _exchange;
|
|
OrderFilledEventPredicate _filled_event;
|
|
OrderCompletedEventPredicate _completed_event;
|
|
OrderCanceledEventPredicate _canceled_event;
|
|
|
|
public enum PredicateTypeOneofCase {
|
|
None,
|
|
[PredicateCase(is_toastable:false)]
|
|
Security,
|
|
[PredicateCase("Time created", is_toastable:false)]
|
|
Time,
|
|
[PredicateCase(is_toastable:false)]
|
|
LastChange,
|
|
[PredicateCase(is_toastable:false)]
|
|
User,
|
|
[PredicateCase(is_toastable:false)]
|
|
Account,
|
|
[PredicateCase(is_toastable:false)]
|
|
Exchange,
|
|
[PredicateCase(is_toastable:false)]
|
|
TimeInForce,
|
|
[PredicateCase(is_toastable:false)]
|
|
OrderType,
|
|
[PredicateCase("Order sub-type", is_toastable:false)]
|
|
SubType,
|
|
[PredicateCase(@"B\S", is_toastable:false)]
|
|
Side,
|
|
[PredicateCase(is_toastable:false)]
|
|
Size,
|
|
[PredicateCase(is_toastable:false)]
|
|
Price,
|
|
[PredicateCase("Filled qty", is_toastable:false)]
|
|
Filled,
|
|
[PredicateCase("Avg fill-price", is_toastable:false)]
|
|
AvgFilled,
|
|
[PredicateCase("Last fill-price", is_toastable:false)]
|
|
LastPrice,
|
|
[PredicateCase("Order status", is_toastable:false)]
|
|
Status,
|
|
[PredicateCase("Last message", is_toastable:false)]
|
|
LastMessage,
|
|
[PredicateCase(is_toastable:false)]
|
|
SecurityKey,
|
|
[PredicateCase(is_toastable:false)]
|
|
OrderKey,
|
|
[PredicateCase(is_toastable:false)]
|
|
ParentKey,
|
|
[PredicateCase("When order gets a fill", PredicateCategory.Event)]
|
|
FilledEvent,
|
|
[PredicateCase("When order is completed", PredicateCategory.Event)]
|
|
CompletedEvent,
|
|
[PredicateCase("When order is canceled", PredicateCategory.Event)]
|
|
CanceledEvent
|
|
}
|
|
|
|
[ProtoMember(1)]
|
|
public SecurityPredicate security { get => _security; set => _set(ref _security, value); }
|
|
[ProtoMember(2)]
|
|
public TimePredicate time_created { get => _time_created; set => _set(ref _time_created, value); }
|
|
[ProtoMember(3)]
|
|
public TimePredicate last_change { get => _last_change; set => _set(ref _last_change, value); }
|
|
[ProtoMember(4)]
|
|
public DiscreteUIntPredicate account { get => _account; set => _set(ref _account, value); }
|
|
[ProtoMember(5)]
|
|
public DiscreteUIntPredicate user { get => _user; set => _set(ref _user, value); }
|
|
[ProtoMember(6)]
|
|
public ExchangePredicate exchange { get => _exchange; set => _set(ref _exchange, value); }
|
|
[ProtoMember(7)]
|
|
public TimeInForcePredicate time_in_force { get => _time_in_force; set => _set(ref _time_in_force, value); }
|
|
[ProtoMember(8)]
|
|
public SidePredicate side { get => _side; set => _set(ref _side, value); }
|
|
[ProtoMember(9)]
|
|
public DoublePredicate price { get => _price; set => _set(ref _price, value); }
|
|
[ProtoMember(10)]
|
|
public UIntPredicate quantity { get => _quantity; set => _set(ref _quantity, value); }
|
|
[ProtoMember(11)]
|
|
public UIntPredicate filled_quantity { get => _filled_quantity; set => _set(ref _filled_quantity, value); }
|
|
[ProtoMember(12)]
|
|
public DoublePredicate last_price { get => _last_price; set => _set(ref _last_price, value); }
|
|
[ProtoMember(13)]
|
|
public DoublePredicate avg_price { get => _avg_price; set => _set(ref _avg_price, value); }
|
|
[ProtoMember(14)]
|
|
public OrderTypePredicate order_type { get => _order_type; set => _set(ref _order_type, value); }
|
|
[ProtoMember(15)]
|
|
public OrderSubTypePredicate order_sub_type { get => _order_sub_type; set => _set(ref _order_sub_type, value); }
|
|
[ProtoMember(16)]
|
|
public OrderStatusPredicate order_status { get => _order_status; set => _set(ref _order_status, value); }
|
|
[ProtoMember(17)]
|
|
public StringPredicate last_message { get => _last_message; set => _set(ref _last_message, value); }
|
|
[ProtoMember(18)]
|
|
public UIntPredicate security_key { get => _security_key; set => _set(ref _security_key, value); }
|
|
[ProtoMember(19)]
|
|
public UIntPredicate order_key { get => _order_key; set => _set(ref _order_key, value); }
|
|
[ProtoMember(20)]
|
|
public UIntPredicate parent_key { get => _parent_key; set => _set(ref _parent_key, value); }
|
|
[ProtoMember(21)]
|
|
public OrderFilledEventPredicate filled_event { get => _filled_event; set => _set(ref _filled_event, value); }
|
|
[ProtoMember(22)]
|
|
public OrderCompletedEventPredicate completed_event { get => _completed_event; set => _set(ref _completed_event, value); }
|
|
[ProtoMember(23)]
|
|
public OrderCanceledEventPredicate canceled_event { get => _canceled_event; set => _set(ref _canceled_event, value); }
|
|
[ProtoMember(24)]
|
|
public bool is_toast_enabled { get; set; }
|
|
|
|
public PTOC predicate_type_case {
|
|
get {
|
|
if (_security != null) return PTOC.Security;
|
|
if (_time_created != null) return PTOC.Time;
|
|
if (_last_change != null) return PTOC.LastChange;
|
|
if (_user != null) return PTOC.User;
|
|
if (_account != null) return PTOC.Account;
|
|
if (_exchange != null) return PTOC.Exchange;
|
|
if (_time_in_force != null) return PTOC.TimeInForce;
|
|
if (_order_type != null) return PTOC.OrderType;
|
|
if (_order_sub_type != null) return PTOC.SubType;
|
|
if (_side != null) return PTOC.Side;
|
|
if (_quantity != null) return PTOC.Side;
|
|
if (_price != null) return PTOC.Price;
|
|
if (_filled_quantity != null) return PTOC.Filled;
|
|
if (_avg_price != null) return PTOC.AvgFilled;
|
|
if (_last_price != null) return PTOC.LastPrice;
|
|
if (_order_status != null) return PTOC.Status;
|
|
if (_last_message != null) return PTOC.LastMessage;
|
|
if (_security_key != null) return PTOC.SecurityKey;
|
|
if (_order_key != null) return PTOC.OrderKey;
|
|
if (_parent_key != null) return PTOC.ParentKey;
|
|
if (_filled_event != null) return PTOC.FilledEvent;
|
|
if (_completed_event != null) return PTOC.CompletedEvent;
|
|
if (_canceled_event != null) return PTOC.CanceledEvent;
|
|
return PTOC.None;
|
|
}
|
|
}
|
|
|
|
public IPredicate<OrderSecurity> create_predicate(INotificationServiceDataCache data_cache) {
|
|
switch (predicate_type_case) {
|
|
case PTOC.Security: return wrap(_security.create(), r => r.security ?? SecurityDataHelper.Defaults.SecurityImmutable);
|
|
case PTOC.Time: return wrap(_time_created.create(), r => r.order.created());
|
|
case PTOC.LastChange: return wrap(_last_change.create(), r => r.order.last_change());
|
|
case PTOC.User: return wrap(_user.create(), r => r.order.user_id());
|
|
case PTOC.Account: return wrap(_account.create(), r => r.order.account_id());
|
|
case PTOC.Exchange: return wrap(_exchange.create(), r => r.security.exchange_or_default());
|
|
case PTOC.TimeInForce: return wrap(_time_in_force.create(), r => r.order.time_in_force());
|
|
case PTOC.OrderType: return wrap(_order_type.create(), r => r.order.order_type());
|
|
case PTOC.SubType: return wrap(_order_sub_type.create(), r => r.order.sub_type());
|
|
case PTOC.Side: return wrap(_side.create(), r => r.order.side());
|
|
case PTOC.Size: return wrap(_quantity.create(), r => r.order.quantity());
|
|
case PTOC.Price: return wrap(_price.create(), r => r.order.price());
|
|
case PTOC.Filled: return wrap(_filled_quantity.create(), r => r.order.filled());
|
|
case PTOC.AvgFilled: return wrap(_avg_price.create(), r => r.order.avg_price());
|
|
case PTOC.LastPrice: return wrap(_last_price.create(), r => r.order.last_price());
|
|
case PTOC.Status: return wrap(_order_status.create(), r => r.order.status());
|
|
case PTOC.LastMessage: return wrap(_last_message.create(), r => r.order.last_msg());
|
|
case PTOC.SecurityKey: return wrap(_security_key.create(), r => r.order.security_key());
|
|
case PTOC.OrderKey: return wrap(_order_key.create(), r => r.order.Key);
|
|
case PTOC.ParentKey: return wrap(_parent_key.create(), r => r.order.ParentKey);
|
|
case PTOC.FilledEvent: return _filled_event.create_predicate(data_cache);
|
|
case PTOC.CompletedEvent: return _completed_event.create_predicate(data_cache);
|
|
case PTOC.CanceledEvent: return _canceled_event.create(data_cache);
|
|
default: return null;
|
|
}
|
|
//
|
|
IPredicate<OrderSecurity> wrap<T>(IPredicate<T> trigger, Func<OrderSecurity, T> select) =>
|
|
trigger.wrap<OrderSecurity, T>(select);
|
|
}
|
|
|
|
public INotificationPredicate<OrderSecurity> create_notification_predicate(INotificationServiceDataCache notification_service_data_cache) {
|
|
if (!is_toast_enabled)
|
|
return null;
|
|
switch (predicate_type_case) {
|
|
case PTOC.FilledEvent: return _filled_event.create_toast(notification_service_data_cache);
|
|
case PTOC.CompletedEvent: return _completed_event.create_toast(notification_service_data_cache);
|
|
case PTOC.CanceledEvent: return _canceled_event.create_toast(notification_service_data_cache);
|
|
default: return null;
|
|
}
|
|
}
|
|
|
|
public bool Equals(OrderRecordTuplePredicate other) {
|
|
if (other == null)
|
|
return false;
|
|
PTOC ptoc = predicate_type_case;
|
|
if (ptoc != other.predicate_type_case)
|
|
return false;
|
|
switch (ptoc) {
|
|
case PTOC.Security: return _security.Equals(other._security);
|
|
case PTOC.Time: return _time_created.Equals(other._time_created);
|
|
case PTOC.LastChange: return _last_change.Equals(other._last_change);
|
|
case PTOC.User: return _user.Equals(other._user);
|
|
case PTOC.Account: return _account.Equals(other._account);
|
|
case PTOC.Exchange: return _exchange.Equals(other._exchange);
|
|
case PTOC.TimeInForce: return _time_in_force.Equals(other._time_in_force);
|
|
case PTOC.OrderType: return _order_type.Equals(other._order_type);
|
|
case PTOC.SubType: return _order_sub_type.Equals(other._order_sub_type);
|
|
case PTOC.Side: return _side.Equals(other._side);
|
|
case PTOC.Price: return _price.Equals(other._price);
|
|
case PTOC.Size: return _quantity.Equals(other._quantity);
|
|
case PTOC.Filled: return _filled_quantity.Equals(other._filled_quantity);
|
|
case PTOC.LastPrice: return _last_price.Equals(other._last_price);
|
|
case PTOC.AvgFilled: return _avg_price.Equals(other._avg_price);
|
|
case PTOC.Status: return _order_status.Equals(other._order_status);
|
|
case PTOC.LastMessage: return _last_message.Equals(other._last_message);
|
|
case PTOC.SecurityKey: return _security_key.Equals(other._security_key);
|
|
case PTOC.OrderKey: return _order_key.Equals(other._order_key);
|
|
case PTOC.ParentKey: return _parent_key.Equals(other._parent_key);
|
|
case PTOC.FilledEvent: return _filled_event.Equals(other._filled_event);
|
|
case PTOC.CompletedEvent: return _completed_event.Equals(other._completed_event);
|
|
case PTOC.CanceledEvent: return _canceled_event.Equals(other._canceled_event);
|
|
case PTOC.None: return true;
|
|
default: throw ExceptionHelper.unexpected_oneof_case(ptoc);
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object obj) => Equals(obj as OrderRecordTuplePredicate);
|
|
|
|
public override int GetHashCode() {
|
|
PTOC ptoc = predicate_type_case;
|
|
int raw_hash;
|
|
switch (ptoc) {
|
|
case PTOC.Security: raw_hash = _security.GetHashCode(); break;
|
|
case PTOC.Time: raw_hash = _time_created.GetHashCode(); break;
|
|
case PTOC.LastChange: raw_hash = _last_change.GetHashCode(); break;
|
|
case PTOC.User: raw_hash = _user.GetHashCode(); break;
|
|
case PTOC.Account: raw_hash = _account.GetHashCode(); break;
|
|
case PTOC.Exchange: raw_hash = _exchange.GetHashCode(); break;
|
|
case PTOC.TimeInForce: raw_hash = _time_in_force.GetHashCode(); break;
|
|
case PTOC.OrderType: raw_hash = _order_type.GetHashCode(); break;
|
|
case PTOC.SubType: raw_hash = _order_sub_type.GetHashCode(); break;
|
|
case PTOC.Side: raw_hash = _side.GetHashCode(); break;
|
|
case PTOC.Price: raw_hash = _price.GetHashCode(); break;
|
|
case PTOC.Size: raw_hash = _quantity.GetHashCode(); break;
|
|
case PTOC.Filled: raw_hash = _filled_quantity.GetHashCode(); break;
|
|
case PTOC.LastPrice: raw_hash = _last_price.GetHashCode(); break;
|
|
case PTOC.AvgFilled: raw_hash = _avg_price.GetHashCode(); break;
|
|
case PTOC.Status: raw_hash = _order_status.GetHashCode(); break;
|
|
case PTOC.LastMessage: raw_hash = _last_message.GetHashCode(); break;
|
|
case PTOC.SecurityKey: raw_hash = _security_key.GetHashCode(); break;
|
|
case PTOC.OrderKey: raw_hash = _order_key.GetHashCode(); break;
|
|
case PTOC.ParentKey: raw_hash = _parent_key.GetHashCode(); break;
|
|
case PTOC.FilledEvent: raw_hash = _filled_event.GetHashCode(); break;
|
|
case PTOC.CompletedEvent: raw_hash = _completed_event.GetHashCode(); break;
|
|
case PTOC.CanceledEvent: raw_hash = _canceled_event.GetHashCode(); break;
|
|
case PTOC.None: raw_hash = 0; break;
|
|
default: throw ExceptionHelper.unexpected_oneof_case(ptoc);
|
|
}
|
|
return EqualityComparer.phase_hash(raw_hash, (int)ptoc);
|
|
}
|
|
|
|
static string _get_order_placed_toast_msg(OrderSecurity order) =>
|
|
$"Order Sent: {order.security.display_name()} {order.order.short_description(order.security.spec_or_default())}";
|
|
|
|
void _set<T>(ref T field, T value) {
|
|
if (value != null) {
|
|
_security = null;
|
|
_time_created = null;
|
|
_last_change = null;
|
|
_exchange = null;
|
|
_account = null;
|
|
_user = null;
|
|
_time_in_force = null;
|
|
_order_sub_type = null;
|
|
_order_type = null;
|
|
_side = null;
|
|
_price = null;
|
|
_quantity = null;
|
|
_filled_quantity = null;
|
|
_last_price = null;
|
|
_avg_price = null;
|
|
_order_status = null;
|
|
_last_message = null;
|
|
_security_key = null;
|
|
_order_key = null;
|
|
_parent_key = null;
|
|
_filled_event = null;
|
|
_completed_event = null;
|
|
_canceled_event = null;
|
|
}
|
|
field = value;
|
|
}
|
|
}
|
|
|
|
[ProtoContract]
|
|
class OrderRecordTuplePredicateAnimations : IPredicateAnimationsData<OrderSecurity, OrderRecordTuplePredicate> {
|
|
[ProtoMember(1)]
|
|
OrderRecordTuplePredicate _predicate;
|
|
[ProtoMember(2)]
|
|
List<CellAnimation> _cell_animations;
|
|
[ProtoMember(3)]
|
|
List<RowAnimation> _row_animations;
|
|
[ProtoMember(4)]
|
|
List<SoundNotification> _sound_animations;
|
|
|
|
public OrderRecordTuplePredicateAnimations() { }
|
|
|
|
public OrderRecordTuplePredicateAnimations(OrderRecordTuplePredicate predicate, IEnumerable<CellAnimation> cell_animations, IEnumerable<RowAnimation> row_animations, IEnumerable<SoundNotification> sound_animations) {
|
|
_predicate = predicate;
|
|
_cell_animations = new List<CellAnimation>(cell_animations);
|
|
_row_animations = new List<RowAnimation> ( row_animations );
|
|
_sound_animations = new List<SoundNotification> ( sound_animations );
|
|
}
|
|
|
|
public OrderRecordTuplePredicate predicate_data => _predicate;
|
|
public IReadOnlyList<CellAnimation> cell_animations => _cell_animations ?? (_cell_animations = new List<CellAnimation>());
|
|
public IReadOnlyList<RowAnimation> row_animations => _row_animations ?? (_row_animations = new List<RowAnimation>());
|
|
public IReadOnlyList<SoundNotification> sound_notifications => _sound_animations ?? (_sound_animations = new List<SoundNotification>());
|
|
}
|
|
}
|