public DataHistoryUpdate GetDataHistoryUpdate(DataSessionInfo session, DataHistoryRequest request)
{
if (!IsPeriodSupported(request.Period))
{
SystemMonitor.OperationWarning("Source queried for historic information of wrong period.");
return(null);
}
List <DataBar> bars = GetSymbolData(session.Symbol, request.Period);
if (bars != null)
{
return(new DataHistoryUpdate(request.Period, bars));
}
return(null);
}
public DataHistoryUpdate GetDataHistoryUpdate(DataSessionInfo session, DataHistoryRequest request)
{
if (request.IsTickBased)
{
SystemMonitor.NotImplementedWarning();
return(new DataHistoryUpdate(request.Period, new DataTick[] { }));
}
if (request.Period != _period)
{
return(new DataHistoryUpdate(request.Period, new DataBar[] { }));
}
lock (this)
{
return(new DataHistoryUpdate(request.Period, _history.ToArray()));
}
}
public bool RequestDataHistoryUpdate(DataSessionInfo sessionInfo, DataHistoryRequest request, bool waitResult)
{
if (OperationalState != OperationalStateEnum.Operational)
{
return(false);
}
RequestDataHistoryMessage requestMessage = new RequestDataHistoryMessage(sessionInfo, request)
{
RequestResponse = false
};
requestMessage.RequestResponse = waitResult;
if (waitResult)
{
ResponseMessage response = SendAndReceiveResponding <ResponseMessage>(SourceTransportInfo, requestMessage, this.DefaultTimeOut);
return(response != null && response.OperationResult);
}
else
{
SendResponding(SourceTransportInfo, requestMessage);
return(true);
}
}
public DataHistoryUpdate GetDataHistoryUpdate(DataSessionInfo session, DataHistoryRequest request)
{
MBTradingConnectionManager manager = _manager;
if (manager != null)
{
DataHistoryOperation operation = new DataHistoryOperation(session.Symbol.Name, request);
if (manager.History.Place(operation) == false)
{
SystemMonitor.OperationError("Failed to place data history operation.");
return(null);
}
if (operation.CompletionEvent.WaitOne(TimeSpan.FromSeconds(120)) == false)
{
SystemMonitor.OperationError("Data history operation timed out.");
return(null);
}
return(operation.Responce);
}
return(null);
}
/// <summary>
///
/// </summary>
public bool RequestDataHistoryUpdate(DataSessionInfo sessionInfo, DataHistoryRequest request, bool waitResult)
{
if (_sourceDataBarProvider == null)
{
ConstructSourceDataBarProvider(request.Period);
//SystemMonitor.Warning("Source data bar provider not created yet.");
return(true);
}
if (request.StartIndex.HasValue == false)
{
request.StartIndex = -1;
}
if (request.MaxValuesRetrieved.HasValue == false)
{
request.MaxValuesRetrieved = int.MaxValue;
}
if (request.Period != _sourceDataBarProvider.Period)
{
SystemMonitor.NotImplementedCritical("Mode not supported.");
return(false);
}
if (request.IsTickBased)
{
SystemMonitor.NotImplementedCritical("Mode not supported.");
return(false);
}
List <DataBar> bars = new List <DataBar>();
if (request.StartIndex < 0)
{
for (int i = Math.Max(0, _sourceDataBarProvider.BarCount - request.MaxValuesRetrieved.Value);
i < _sourceDataBarProvider.BarCount; i++)
{
lock (_sourceDataBarProvider)
{
bars.Add(_sourceDataBarProvider.BarsUnsafe[i]);
}
}
}
else
{
for (int i = request.StartIndex.Value;
i < request.MaxValuesRetrieved && i < _sourceDataBarProvider.BarCount; i++)
{
lock (_sourceDataBarProvider)
{
bars.Add(_sourceDataBarProvider.BarsUnsafe[i]);
}
}
}
if (this.DataHistoryUpdateEvent != null)
{
this.DataHistoryUpdateEvent(this, sessionInfo, new DataHistoryUpdate(request.Period, bars));
}
return(true);
}
void SendDataHistoryUpdate(TransportInfo[] receivers, DataSessionInfo session, DataHistoryRequest request)
{
DataSourceStub.IImplementation implementation = Implementation;
if (implementation == null)
{
return;
}
DataHistoryUpdate responce = implementation.GetDataHistoryUpdate(session, request);
SendRespondingToMany(receivers, new DataHistoryUpdateMessage(session, responce, responce != null));
}
/// <summary>
///
/// </summary>
/// <param name="expertID"></param>
public RequestDataHistoryMessage(DataSessionInfo sessionInfo, DataHistoryRequest request)
: base(sessionInfo)
{
_request = request;
}
/// <summary>
/// Request bar dataDelivery from entry.
/// </summary>
public bool RequestDataHistoryUpdate(DataSessionInfo sessionInfo, DataHistoryRequest request, bool waitResult)
{
DataStoreEntry entry = DataStore.Instance.GetEntryBySessionInfo(sessionInfo);
if (this.OperationalState != OperationalStateEnum.Operational ||
entry == null)
{
SystemMonitor.OperationError("Data history request received while not operational, or invalid session requrested.");
return(false);
}
if (entry.Period != request.Period)
{
SystemMonitor.OperationError("Data history request received but period not recognized.");
return(false);
}
if (request.MaxValuesRetrieved.HasValue == false)
{
request.MaxValuesRetrieved = int.MaxValue;
}
if (request.StartIndex.HasValue == false)
{
request.StartIndex = -1;
}
GeneralHelper.GenericReturnDelegate <bool> operationDelegate = delegate()
{
if (request.IsTickBased)
{
DataReaderWriter <DataTick> readerWriter = entry.GetDataTickReaderWriter();
List <DataTick> dataTicks;
DataHistoryUpdate update = new DataHistoryUpdate(request.Period, new DataTick[] { });
if (readerWriter.Read(request.StartIndex.Value, request.MaxValuesRetrieved.Value, out dataTicks))
{
update.DataTicksUnsafe.AddRange(dataTicks);
if (DataHistoryUpdateEvent != null)
{
DataHistoryUpdateEvent(this, sessionInfo, update);
}
return(true);
}
}
else
{
DataReaderWriter <DataBar> readerWriter = entry.GetDataBarReaderWriter();
if (readerWriter == null)
{
SystemMonitor.OperationError("Failed to establish file reader writer for entry.");
return(false);
}
List <DataBar> dataBars;
DataHistoryUpdate update = new DataHistoryUpdate(request.Period, new DataBar[] { });
bool readResult = false;
if (request.StartIndex.Value < 0)
{// Instruction is to read the last count items.
readResult = readerWriter.ReadLast(
request.MaxValuesRetrieved.Value, out dataBars);
}
else
{
readResult = readerWriter.Read(request.StartIndex.Value,
request.MaxValuesRetrieved.Value, out dataBars);
}
if (readResult)
{
update.DataBarsUnsafe.AddRange(dataBars);
if (DataHistoryUpdateEvent != null)
{
DataHistoryUpdateEvent(this, sessionInfo, update);
}
return(true);
}
}
return(false);
};
if (waitResult)
{
return(operationDelegate());
}
else
{
GeneralHelper.FireAndForget(operationDelegate);
return(true);
}
}
/// <summary>
///
/// </summary>
public DataHistoryOperation(string symbol, DataHistoryRequest request)
{
_symbol = symbol;
_request = request;
}
