/// <summary>
/// 得到指定BarPos所在的交易周期
/// </summary>
public double[] GetTradingPeriods(int barPos)
{
ITradingTime tradingTime = GetTradingTime(barPos);
int periodIndex = GetTradingPeriodsByBarPos(barPos).PeriodIndex;
return(tradingTime.TradingPeriods[periodIndex]);
}
private void Init(IKLineData klineData, IList <ITradingTime> tradingTimes)
{
int currentKLineBarPos = 0;
for (int i = 0; i < tradingTimes.Count; i++)
{
ITradingTime tradingTime = tradingTimes[i];
KLineDataTradingTimeInfo_Day timeInfo = CalcKLineTimeInfo_Day(tradingTime, klineData, currentKLineBarPos);
if (timeInfo == null)
{
continue;
}
this.dic_TradingDay_KLineTimeInfo.Add(timeInfo.TradingDay, timeInfo);
this.timeInfo_DayList.Add(timeInfo);
currentKLineBarPos = timeInfo.EndPos;
tradingDays.Add(tradingTime.TradingDay);
}
for (int i = 1; i < timeInfo_DayList.Count; i++)
{
int lastTradingDay = timeInfo_DayList[i - 1].TradingDay;
KLineDataTradingTimeInfo_Day tradingTimeInfo_Day = (KLineDataTradingTimeInfo_Day)timeInfo_DayList[i];
int currentTradingDay = tradingTimeInfo_Day.TradingDay;
tradingTimeInfo_Day.holidayCount = TimeUtils.Substract(currentTradingDay, lastTradingDay).Days - 1;
}
}
private List <ITradingTime> GetTradingSessionDataResult(IList <ITradingTime> updatedTradingSessionList, IList <ITradingTime> updateTradingSessionList)
{
HashSet <int> set_TradingDay = new HashSet <int>();
List <ITradingTime> result = new List <ITradingTime>();
if (updatedTradingSessionList != null)
{
for (int i = 0; i < updatedTradingSessionList.Count; i++)
{
ITradingTime session = updatedTradingSessionList[i];
if (set_TradingDay.Contains(session.TradingDay))
{
continue;
}
set_TradingDay.Add(session.TradingDay);
result.Add(session);
}
}
if (updateTradingSessionList == null)
{
return(result);
}
for (int i = 0; i < updateTradingSessionList.Count; i++)
{
ITradingTime session = updateTradingSessionList[i];
if (set_TradingDay.Contains(session.TradingDay))
{
continue;
}
set_TradingDay.Add(session.TradingDay);
result.Add(session);
}
return(result);
}
private int FindEndBarPos(ITickData tickData, ITradingTime tradingTime, int periodIndex)
{
double endTime = tradingTime.GetPeriodTime(periodIndex)[1];
double nextStartTime = tradingTime.GetPeriodTime(periodIndex + 1)[0];
endTime = (endTime + nextStartTime) / 2;
return(TimeIndeierUtils.IndexOfTime_Tick(tickData, endTime));
}
public ITickData_Extend GetTickData_Extend(string code, int date)
{
ITickData tickData = GetTickData(code, date);
if (tickData == null)
{
return(null);
}
ITradingTime tradingTime = this.dataReader.CreateTradingTimeReader(code).GetTradingTime(date);
return(new TickData_Extend(tickData, tradingTime));
}
public TickData_Extend(ITickData tickData, ITradingTime tradingTime)
{
this.tickData = tickData;
for (int i = 0; i < tradingTime.PeriodCount - 1; i++)
{
int barPos = FindEndBarPos(tickData, tradingTime, i);
tradingTimeEndBarPoses.Add(barPos);
set_TradingTimeEndBar.Add(barPos);
}
tradingTimeEndBarPoses.Add(tickData.Length - 1);
set_TradingTimeEndBar.Add(tickData.Length - 1);
}
private bool IsTimeInTradingSession(int tradingDay, double time)
{
if (tradingDay < 0)
{
return(false);
}
ITradingTime tradingSession = GetTradingTime(tradingDay);
if (tradingSession == null)
{
return(false);
}
return(time >= tradingSession.OpenTime && time <= tradingSession.CloseTime);
}
private void Init_Day(IKLineData klineData, IList <ITradingTime> tradingTimes)
{
for (int i = 0; i < tradingTimes.Count; i++)
{
ITradingTime tradingTime = tradingTimes[i];
int tradingDay = (int)klineData.GetBar(i).Time;
KLineDataTradingTimeInfo_Day timeInfo = new KLineDataTradingTimeInfo_Day(tradingDay);
timeInfo.StartPos = i;
timeInfo.EndPos = i;
this.dic_TradingDay_KLineTimeInfo.Add(timeInfo.TradingDay, timeInfo);
this.timeInfo_DayList.Add(timeInfo);
tradingDays.Add(tradingTime.TradingDay);
}
}
public KLineData_Extend(IKLineData klineData, IList <ITradingTime> tradingTimes)
{
if (klineData == null)
{
return;
}
this.klineData = klineData;
this.tradingTimes = tradingTimes;
for (int i = 0; i < tradingTimes.Count; i++)
{
ITradingTime tradingTime = tradingTimes[i];
dic_TradingDay_TradingTime.Add(tradingTime.TradingDay, tradingTime);
}
this.klineTimeInfo = new KLineDataTradingTimeInfo(klineData, tradingTimes);
this.currentTradingPeriods = klineTimeInfo.GetTradingPeriodsByBarPos(klineData.BarPos);
}
public CacheUtils_TradingTime(string instrumentId, IList <ITradingTime> tradingSessionList)
{
this.instrumentId = instrumentId;
this.tradingSessionList = tradingSessionList;
this.tradingDays = new List <int>(tradingSessionList.Count);
this.startTimes = new List <double>(tradingSessionList.Count);
this.dic_TradingDay_TradingSession = new Dictionary <int, ITradingTime>(tradingSessionList.Count);
this.dic_StartTime_TradingDay = new Dictionary <double, int>(tradingSessionList.Count);
for (int i = 0; i < tradingSessionList.Count; i++)
{
ITradingTime tradingSession = tradingSessionList[i];
this.tradingDays.Add(tradingSession.TradingDay);
this.startTimes.Add(tradingSession.OpenTime);
this.dic_TradingDay_TradingSession.Add(tradingSession.TradingDay, tradingSession);
this.dic_StartTime_TradingDay.Add(tradingSession.OpenTime, tradingSession.TradingDay);
}
}
private IList <double[]> GetTradingTime(string code, int date)
{
IList <ITradingTime> tradingTime = GetTradingTime(code);
if (tradingTime != null)
{
for (int i = 0; i < tradingTime.Count; i++)
{
ITradingTime tt = tradingTime[i];
if (tt.TradingDay == date)
{
return(tt.TradingPeriods);
}
}
}
return(null);
}
public ITradingTime GetTradingTime(string code, int date)
{
if (dic_Code_TradingTimeCache.ContainsKey(code))
{
return(dic_Code_TradingTimeCache[code][date]);
}
IList <ITradingTime> tradingTimes = updatedDataLoader.GetTradingTime(code);
Dictionary <int, ITradingTime> dic = new Dictionary <int, ITradingTime>();
for (int i = 0; i < tradingTimes.Count; i++)
{
ITradingTime tradingTime = tradingTimes[i];
dic.Add(tradingTime.TradingDay, tradingTime);
}
dic_Code_TradingTimeCache.Add(code, dic);
return(dic[date]);
}
private IList <double[]>[] GetPeriodArr(string code, int startDate, int endDate, KLinePeriod klinePeriod)
{
ITradingTimeReader_Code tradingTimeReader_Code = this.dataReader.CreateTradingTimeReader(code);
List <int> allTradingDays = klineDataStore.GetAllTradingDay(code, klinePeriod);
CacheUtils_TradingDay cache = new CacheUtils_TradingDay(allTradingDays);
IList <int> tradingDays = cache.GetTradingDays(startDate, endDate);
IList <double[]>[] periodArr = new List <double[]> [tradingDays.Count];
for (int i = 0; i < tradingDays.Count; i++)
{
int tradingDay = tradingDays[i];
ITradingTime time = tradingTimeReader_Code.GetTradingTime(tradingDay);
IList <double[]> periods = time.TradingPeriods;
periodArr[i] = periods;
}
return(periodArr);
}
public double GetRecentTradingTime(double time, bool findForward)
{
int tradingDay = GetRecentTradingDay(time, findForward);
if (tradingDay < 0)
{
return(-1);
}
ITradingTime tradingTime = GetTradingTime(tradingDay);
if (tradingTime.OpenTime <= time && tradingTime.CloseTime >= time)
{
double[] timeArr = tradingTime.GetPeriodTime(0);
if (timeArr[0] <= time && timeArr[1] >= time)
{
return(time);
}
for (int i = 1; i < tradingTime.PeriodCount; i++)
{
timeArr = tradingTime.GetPeriodTime(i);
if (timeArr[0] > time)
{
return(tradingTime.GetPeriodTime(i - 1)[1]);
}
if (timeArr[0] <= time && timeArr[1] >= time)
{
return(time);
}
}
return(tradingTime.CloseTime);
}
else
{
if (findForward)
{
return(tradingTime.OpenTime);
}
else
{
return(tradingTime.CloseTime);
}
}
}
private KLineDataTradingTimeInfo_Day CalcKLineTimeInfo_Day(ITradingTime tradingTime, IKLineData klineData, int currentBarPos)
{
if (tradingTime.PeriodCount == 0)
{
return(null);
}
KLineDataTradingTimeInfo_Day klineTimeInfo_Day = new KLineDataTradingTimeInfo_Day(tradingTime.TradingDay);
for (int i = 0; i < tradingTime.PeriodCount; i++)
{
double[] periodTime = tradingTime.GetPeriodTime(i);
int startPos = CalcEndBarPos(klineData, periodTime[0], currentBarPos);
int endPos = CalcEndBarPos(klineData, periodTime[1], startPos + 1);
currentBarPos = endPos + 1;
KLineDataTradingTimeInfo_Periods timeInfo = new KLineDataTradingTimeInfo_Periods(i, startPos, endPos);
klineTimeInfo_Day.AddTradingPeriods(timeInfo);
}
int dayStartPos = klineTimeInfo_Day.TradingPeriods[0].StartPos;
int dayEndPos = klineTimeInfo_Day.TradingPeriods[klineTimeInfo_Day.TradingPeriods.Count - 1].EndPos;
klineTimeInfo_Day.StartPos = dayStartPos;
klineTimeInfo_Day.EndPos = dayEndPos;
return(klineTimeInfo_Day);
}
public KLineData_ExtendBak(IKLineData klineData, ITradingTime tradingTime)
{
}
public int GetRecentTradingDay(double time, bool findForward)
{
if (dic_StartTime_TradingDay.ContainsKey(time))
{
return(dic_StartTime_TradingDay[time]);
}
int tradingDay = (int)time;
if (this.tradingDays.Count == 0)
{
return(tradingDay);
}
if (tradingDay > this.tradingDays.Last <int>() && !findForward)
{
return(this.tradingDays[tradingDays.Count - 1]);
}
if (tradingDay < this.tradingDays[0] && findForward)
{
return(this.tradingDays[0]);
}
ITradingTime tradingTime = GetTradingTime(tradingDay);
if (tradingTime != null)
{
if (time >= tradingTime.OpenTime && time <= tradingTime.CloseTime)
{
return(tradingDay);
}
if (time > tradingTime.CloseTime)
{
int nTradingDay = GetTradingDayCache().GetNextTradingDay(tradingDay);
ITradingTime ntradingTime = GetTradingTime(nTradingDay);
if (ntradingTime != null && time >= ntradingTime.OpenTime && time <= ntradingTime.CloseTime)
{
return(nTradingDay);
}
}
if (findForward)
{
if (time > tradingTime.CloseTime)
{
return(GetTradingDayCache().GetNextTradingDay(tradingDay));
}
return(tradingDay);
}
else
{
if (time < tradingTime.OpenTime)
{
return(GetTradingDayCache().GetPrevTradingDay(tradingDay));
}
return(tradingDay);
}
}
if (findForward)
{
return(GetTradingDayCache().GetNextTradingDay(tradingDay));
}
int nextTradingDay = GetTradingDayCache().GetNextTradingDay(tradingDay);
if (IsTimeInThisDay(nextTradingDay, time))
{
return(nextTradingDay);
}
return(GetTradingDayCache().GetPrevTradingDay(tradingDay));
}
/// <summary>
/// 获得交易时间
/// </summary>
/// <param name="tradingTime"></param>
/// <param name="klinePeriod"></param>
/// <returns></returns>
public static IList <double[]> GetKLineTimeList(ITradingTime tradingTime, KLinePeriod klinePeriod)
{
return(GetKLineTimeList(tradingTime.TradingPeriods, klinePeriod));
}
/// <summary>
/// 得到当前BarPos所在的交易周期
/// </summary>
public double[] GetTradingPeriods()
{
ITradingTime tradingTime = GetTradingTime();
return(tradingTime.GetPeriodTime(currentTradingPeriods.PeriodIndex));
}
