/// <summary>
/// Serialize the specified storage into file.
/// </summary>
/// <param name="settings"><see cref="SettingsStorage"/></param>
/// <param name="fileName">File name.</param>
public static void SerializeInvariant(this SettingsStorage settings, string fileName)
{
if (settings is null)
{
throw new ArgumentNullException(nameof(settings));
}
if (fileName.IsEmpty())
{
throw new ArgumentNullException(nameof(fileName));
}
Do.Invariant(() => settings.Serialize(fileName));
}
byte[] ISnapshotSerializer <string, ExecutionMessage> .Serialize(Version version, ExecutionMessage message)
{
if (version == null)
{
throw new ArgumentNullException(nameof(version));
}
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (message.ExecutionType != ExecutionTypes.Transaction)
{
throw new ArgumentOutOfRangeException(nameof(message), message.ExecutionType, LocalizedStrings.Str1695Params.Put(message));
}
if (message.TransactionId == 0)
{
throw new InvalidOperationException("TransId == 0");
}
var snapshot = new TransactionSnapshot
{
SecurityId = message.SecurityId.ToStringId().VerifySize(Sizes.S100),
PortfolioName = message.PortfolioName.VerifySize(Sizes.S100),
LastChangeServerTime = message.ServerTime.To <long>(),
LastChangeLocalTime = message.LocalTime.To <long>(),
//OriginalTransactionId = message.OriginalTransactionId,
TransactionId = message.TransactionId,
HasOrderInfo = message.HasOrderInfo,
HasTradeInfo = message.HasTradeInfo,
BrokerCode = message.BrokerCode.VerifySize(Sizes.S100),
ClientCode = message.ClientCode.VerifySize(Sizes.S100),
Comment = message.Comment.VerifySize(Sizes.S100),
SystemComment = message.SystemComment.VerifySize(Sizes.S100),
Currency = message.Currency == null ? null : (short)message.Currency.Value,
DepoName = message.DepoName.VerifySize(Sizes.S100),
Error = (message.Error?.Message).VerifySize(Sizes.S200),
ExpiryDate = message.ExpiryDate?.To <long>(),
IsMarketMaker = message.IsMarketMaker?.ToByte(),
IsMargin = message.IsMargin?.ToByte(),
IsManual = message.IsManual?.ToByte(),
Side = (byte)message.Side,
OrderId = message.OrderId,
OrderStringId = message.OrderStringId.VerifySize(Sizes.S100),
OrderBoardId = message.OrderBoardId.VerifySize(Sizes.S100),
OrderPrice = (BlittableDecimal)message.OrderPrice,
OrderVolume = (BlittableDecimal?)message.OrderVolume,
VisibleVolume = (BlittableDecimal?)message.VisibleVolume,
OrderType = message.OrderType?.ToByte(),
OrderState = message.OrderState?.ToByte(),
OrderStatus = message.OrderStatus,
Balance = (BlittableDecimal?)message.Balance,
UserOrderId = message.UserOrderId.VerifySize(Sizes.S100),
StrategyId = message.StrategyId.VerifySize(Sizes.S100),
OriginSide = message.OriginSide?.ToByte(),
Latency = message.Latency?.Ticks,
PnL = (BlittableDecimal?)message.PnL,
Position = (BlittableDecimal?)message.Position,
Slippage = (BlittableDecimal?)message.Slippage,
Commission = (BlittableDecimal?)message.Commission,
TradePrice = (BlittableDecimal?)message.TradePrice,
TradeVolume = (BlittableDecimal?)message.TradeVolume,
TradeStatus = message.TradeStatus,
TradeId = message.TradeId,
TradeStringId = message.TradeStringId.VerifySize(Sizes.S100),
OpenInterest = (BlittableDecimal?)message.OpenInterest,
IsSystem = message.IsSystem?.ToByte(),
OrderTif = message.TimeInForce?.ToByte(),
AveragePrice = (BlittableDecimal?)message.AveragePrice,
Yield = (BlittableDecimal?)message.Yield,
MinVolume = (BlittableDecimal?)message.MinVolume,
PositionEffect = message.PositionEffect?.ToByte(),
PostOnly = message.PostOnly?.ToByte(),
Initiator = message.Initiator?.ToByte(),
SeqNum = message.SeqNum,
BuildFrom = message.BuildFrom == null ? default(SnapshotDataType?) : (SnapshotDataType)message.BuildFrom,
Leverage = message.Leverage,
ConditionType = (message.Condition?.GetType().GetTypeName(false)).VerifySize(Sizes.S256),
};
var conParams = message.Condition?.Parameters.Where(p => p.Value != null).ToArray() ?? Array.Empty <KeyValuePair <string, object> >();
snapshot.ConditionParamsCount = conParams.Length;
var paramSize = typeof(TransactionConditionParamV21).SizeOf();
var result = new List <byte>();
var buffer = new byte[typeof(TransactionSnapshot).SizeOf()];
var ptr = snapshot.StructToPtr();
ptr.CopyTo(buffer);
ptr.FreeHGlobal();
result.AddRange(buffer);
foreach (var conParam in conParams)
{
var paramType = conParam.Value.GetType();
var paramTypeName = paramType.GetTypeAsString(false);
var param = new TransactionConditionParamV21
{
ValueTypeLen = paramTypeName.UTF8().Length,
Name = conParam.Key.VerifySize(Sizes.S32)
};
byte[] stringValue = null;
switch (conParam.Value)
{
case byte b:
param.NumValue = b;
break;
case sbyte sb:
param.NumValue = sb;
break;
case int i:
param.NumValue = i;
break;
case short s:
param.NumValue = s;
break;
case long l:
param.NumValue = l;
break;
case uint ui:
param.NumValue = ui;
break;
case ushort us:
param.NumValue = us;
break;
case ulong ul:
param.NumValue = (long)ul;
break;
case DateTimeOffset dto:
param.NumValue = dto.To <long>();
break;
case DateTime dt:
param.NumValue = dt.To <long>();
break;
case TimeSpan ts:
param.NumValue = ts.To <long>();
break;
case float f:
param.DecimalValue = (BlittableDecimal)(decimal)f;
break;
case double d:
param.DecimalValue = (BlittableDecimal)(decimal)d;
break;
case decimal dec:
param.DecimalValue = (BlittableDecimal)dec;
break;
case bool bln:
param.BoolValue = bln;
break;
case Enum e:
param.NumValue = e.To <long>();
break;
case IRange r:
{
var storage = new SettingsStorage();
if (r.HasMinValue)
{
storage.SetValue(nameof(r.Min), r.Min);
}
if (r.HasMaxValue)
{
storage.SetValue(nameof(r.Max), r.Max);
}
if (storage.Count > 0)
{
stringValue = storage.Serialize();
}
break;
}
case IPersistable p:
{
var storage = p.Save();
if (storage.Count > 0)
{
stringValue = storage.Serialize();
}
break;
}
default:
stringValue = Paths.CreateSerializer(paramType).Serialize(conParam.Value);
break;
}
if (stringValue != null)
{
param.StringValueLen = stringValue.Length;
}
var paramBuff = new byte[paramSize];
var rowPtr = param.StructToPtr();
rowPtr.CopyTo(paramBuff);
rowPtr.FreeHGlobal();
result.AddRange(paramBuff);
if (version > SnapshotVersions.V20)
{
result.AddRange(paramTypeName.UTF8());
}
if (stringValue == null)
{
continue;
}
result.AddRange(stringValue);
}
return(result.ToArray());
}
/// <summary> /// Serialize the specified storage into byte array. /// </summary> /// <param name="settings"><see cref="SettingsStorage"/></param> /// <returns></returns> public static byte[] SerializeInvariant(this SettingsStorage settings) => Do.Invariant(() => settings.Serialize());
