private void Check(bool isHistory, MapsFolder mapsFolder)
{
TicksFileData ticksFileData = isHistory ? _history : _cache;
if (ticksFileData == null)
{
return;
}
TicksFileMapData[] mapsFiles = mapsFolder.Pop(_symbolName);
List <TicksFileMapData> listDelete = new List <TicksFileMapData>();
foreach (TicksFileMapData mapFile in mapsFiles)
{
if (ticksFileData.Count == mapFile.CountTicks)
{
if (isHistory)
{
_map.History = mapFile;
}
else
{
_map.Cache = mapFile;
}
}
else
{
listDelete.Add(mapFile);
}
}
foreach (TicksFileMapData barsFile in listDelete)
{
barsFile.CloseStream();
barsFile.File.Delete();
}
}
public TicksCacher(TicksFileData ticksFileData, BarsFileData[] barsFiles)
{
_listBarsFileData = new List <BarsFileData>(barsFiles);
_ticksFileData = ticksFileData;
string dir = _ticksFileData.File.Directory.FullName + "\\" + BARS_DIR;
_dirBars = new DirectoryInfo(dir);
if (!_dirBars.Exists)
{
_dirBars.Create();
}
}
private void Check(bool isHistory, BarsFolder barsFolder)
{
TicksFileData ticksFileData = isHistory ? _history : _cache;
BarsFileData[] barsFiles = barsFolder.Pop(_symbolName);
List <BarsFileData> listDelete = new List <BarsFileData>();
foreach (BarsFileData barsFile in barsFiles)
{
if (ticksFileData.Count == barsFile.CountTicks)
{
BarManager bm = (BarManager)this._barsManager[barsFile.TimeFrameSecond];
if (bm == null)
{
listDelete.Add(barsFile);
}
else
{
if (isHistory)
{
bm.History = barsFile;
}
else
{
bm.Cache = barsFile;
}
}
}
else
{
listDelete.Add(barsFile);
}
}
foreach (BarsFileData barsFile in listDelete)
{
barsFile.CloseStream();
barsFile.File.Delete();
}
}
private void ExecuteTaskUpdateTicks(TaskUpdateTicks task)
{
Trace.TraceInformation("{0} TicksManager.ExecuteTaskUpdateTicks({1}) - Start", this.Name, task);
bool isCutBeginCache = false;
Tick[] ticks = task.Ticks;
#region if (ticks.Length == 0) {...}
if (ticks.Length == 0)
{
if (task.Task == TicksManagerTask.UpdateCache &&
this.Cache.Count > 0 && this.History.Count > 0 &&
this.Cache.TimeFrom < this.History.TimeTo)
{
isCutBeginCache = true;
}
else
{
return;
}
}
#endregion
TicksFileData tfdCurrent = task.Task == TicksManagerTask.UpdateHistory ? this.History : this.Cache;
FileInfo ticksFileTemp = new FileInfo(tfdCurrent.File.FullName + ".tmp");
if (ticksFileTemp.Exists)
{
ticksFileTemp.Delete();
}
TicksFileData tfdTemp = new TicksFileData(ticksFileTemp, this.Name, this.Digits);
int index = 0;
bool abort = false;
long savedTime = DateTime.Now.Ticks;
if (isCutBeginCache)
{
Trace.TraceInformation("{0} - Cut Begin Ticks in Cache File", this.Name);
long limitBeginTime = this.History.TimeTo;
int cCount = this.Cache.Count;
for (int i = 0; i < cCount; i++)
{
Tick tick = this.Cache.Read(i);
if (tick.Time < limitBeginTime)
{
continue;
}
tfdTemp.Write(tick, index++);
savedTime = ChangeUpdateProgress(savedTime, cCount, i);
if (CheckTaskPriorityUpdateTicks())
{
break;
}
}
}
else
{
UpdateMethod method = UpdateMethod.Unknow;
if (tfdCurrent.Count == 0)
{
method = UpdateMethod.AppendInEmpty;
}
if (method == UpdateMethod.AppendInEmpty)
{
Trace.TraceInformation("{0} - StartUpdate[Method={1}]", this.Name, method);
for (int i = 0; i < ticks.Length; i++)
{
tfdTemp.Write(ticks[i], index++);
savedTime = ChangeUpdateProgress(savedTime, ticks.Length, i);
if (CheckTaskPriorityUpdateTicks())
{
break;
}
}
}
else
{
#region Init Property
long mTimeFrom = tfdCurrent.TimeFrom;
long mTimeTo = tfdCurrent.TimeTo;
long cTimeFrom = ticks[0].Time;
long cTimeTo = ticks[ticks.Length - 1].Time;
int mCount = tfdCurrent.Count;
int cCount = ticks.Length;
int mIndex = 0, cIndex = 0;
Tick tick = new Tick();
Tick mTick = new Tick();
Tick cTick = new Tick();
int level = 0;
Tick cFirstTick = ticks[0];
Tick cEndTick = ticks[ticks.Length - 1];
#endregion
if (cTimeFrom > mTimeTo)
{
method = UpdateMethod.AdditionInEnd;
}
else if (cTimeTo < mTimeFrom)
{
method = UpdateMethod.InsertInBeginning;
}
else if (cTimeFrom < mTimeFrom && mTimeTo < cTimeTo)
{
method = UpdateMethod.ReplacementOfGreater;
}
else if (mTimeFrom < cTimeFrom && cTimeTo < mTimeTo)
{
method = UpdateMethod.InsertInBody;
}
else if (cTimeFrom <= mTimeFrom && cTimeTo > mTimeFrom && cTimeTo < mTimeTo)
{
method = UpdateMethod.AdditionInBeginReplacement;
}
else if (cTimeFrom > mTimeFrom && cTimeFrom < mTimeTo && cTimeTo > mTimeTo)
{
method = UpdateMethod.AdditionInEndReplacement;
}
string mPS = string.Format("Main[B={0},E={1},Count={2}]", new DateTime(mTimeFrom), new DateTime(mTimeTo), mCount);
string cPS = string.Format("New[B={0},E={1},Count={2}]", new DateTime(cTimeFrom), new DateTime(cTimeTo), cCount);
Trace.TraceInformation("{0} - StartUpdate[Method={1}], {2}, {3}", this.Name, method, mPS, cPS);
if (method == UpdateMethod.AdditionInEnd)
{
tfdTemp.CloseStream();
tfdTemp.File.Delete();
File.Copy(tfdCurrent.File.FullName, tfdTemp.File.FullName, true);
tfdTemp = new TicksFileData(ticksFileTemp);
tfdTemp.SeekWriterEnd();
index = mCount;
for (int i = 0; i < cCount; i++)
{
tfdTemp.Write(ticks[i], index++);
savedTime = ChangeUpdateProgress(savedTime, cCount, i);
if (CheckTaskPriorityUpdateTicks())
{
break;
}
}
}
else if (method == UpdateMethod.InsertInBeginning) // if (cTimeTo < mTimeFrom)
{
int count = tfdCurrent.Count + ticks.Length;
for (int i = 0; i < count; i++)
{
//if (cTimeFrom > mTimeTo)
// tick = (i < mCount) ? tfdCurrent.Read(i) : ticks[i - mCount];
//else
tick = (i < cCount) ? ticks[i] : tfdCurrent.Read(i - cCount);
tfdTemp.Write(tick, index++);
savedTime = ChangeUpdateProgress(savedTime, count, i);
if (CheckTaskPriorityUpdateTicks())
{
break;
}
}
}
else if (method == UpdateMethod.ReplacementOfGreater) //if (cTimeFrom < mTimeFrom && mTimeTo < cTimeTo)
{
#region Replacement of the greater
for (int i = 0; i < ticks.Length; i++)
{
tfdTemp.Write(ticks[i], index++);
savedTime = ChangeUpdateProgress(savedTime, ticks.Length, i);
if (CheckTaskPriorityUpdateTicks())
{
break;
}
}
#endregion
}
else if (mTimeFrom < cTimeFrom && cTimeTo < mTimeTo)
{
#region Insert in a body
while (mIndex < mCount)
{
tick = new Tick(-1, 0);
mTick = tfdCurrent.Read(mIndex);
if (cIndex < cCount)
{
cTick = ticks[cIndex];
}
if (level == 0)
{
if (mTick.Time < cTick.Time)
{
tick = mTick;
mIndex++;
}
else
{
level++;
}
}
if (level == 1)
{
if (cIndex < cCount)
{
tick = cTick;
cIndex++;
}
else
{
level++;
}
}
if (level == 2)
{
if (mTick.Time > cTick.Time)
{
tick = mTick;
}
mIndex++;
}
if (tick.Time > -1)
{
tfdTemp.Write(tick, index++);
}
savedTime = ChangeUpdateProgress(savedTime, mCount + cCount, index);
if (CheckTaskPriorityUpdateTicks())
{
break;
}
}
#endregion
}
else if (cTimeFrom <= mTimeFrom && cTimeTo > mTimeFrom && cTimeTo < mTimeTo)
{
#region To add in the beginning
while (mIndex < mCount)
{
tick = new Tick(-1, 0);
if (cIndex < cCount)
{
tick = cTick = ticks[cIndex++];
}
else
{
mTick = tfdCurrent.Read(mIndex);
if (mTick.Time > cTick.Time)
{
tick = mTick;
}
mIndex++;
}
if (tick.Time > -1)
{
tfdTemp.Write(tick, index++);
}
savedTime = ChangeUpdateProgress(savedTime, mCount + cCount, index);
if (CheckTaskPriorityUpdateTicks())
{
break;
}
}
#endregion
}
else if (cTimeFrom > mTimeFrom && cTimeFrom < mTimeTo && cTimeTo > mTimeTo)
{
#region To add in the end
while (cIndex < cCount)
{
tick = new Tick(-1, 0);
cTick = ticks[cIndex];
if (mIndex < mCount)
{
mTick = tfdCurrent.Read(mIndex);
if (mTick.Time < cTick.Time)
{
tick = mTick;
mIndex++;
}
else
{
mIndex = mCount;
}
}
else
{
tick = cTick;
cIndex++;
}
if (tick.Time > -1)
{
tfdTemp.Write(tick, index++);
}
savedTime = ChangeUpdateProgress(savedTime, mCount + cCount, index);
if (CheckTaskPriorityUpdateTicks())
{
break;
}
}
#endregion
}
else
{
abort = true;
}
}
}
tfdTemp.CloseStream();
if (_abortTask)
{
abort = true;
}
Trace.TraceInformation("{0} - Stop Update {1}", this.Name, abort?"Abort":"");
if (abort)
{
tfdTemp.File.Delete();
return;
}
if (task.Task == TicksManagerTask.UpdateHistory && this.Cache.Count > 0)
{
this.Update(new Tick[0], false);
}
lock (_locked) {
tfdCurrent.CloseStream();
tfdCurrent.File.Delete();
tfdTemp.CloseStream();
File.Move(tfdTemp.File.FullName, tfdCurrent.File.FullName);
tfdTemp = new TicksFileData(tfdCurrent.File);
if (task.Task == TicksManagerTask.UpdateHistory)
{
_history = tfdTemp;
_sessionSource.IncrementsLevel1();
}
else
{
_cache = tfdTemp;
_sessionSource.IncrementsLevel2();
}
}
this.AddTask(new TaskDataCache());
Trace.TraceInformation("{0} TicksManager.ExecuteTaskUpdateTicks({1}) - Stop", this.Name, task);
}
private void CacheBars(bool isHistory, Dictionary <int, BarsFileData> bfds, long beginTime)
{
List <BarsFileDataCacher> cacher = new List <BarsFileDataCacher>();
TicksFileData tfd = isHistory ? this.History : this.Cache;
TicksFileMapData tfmd = isHistory ? this.Map.History : this.Map.Cache;
TicksFileMapDataCacher mapCacher = new TicksFileMapDataCacher(this, isHistory, tfmd);
foreach (BarManager bm in (BarsManager)this.BarsDataList)
{
BarsFileData bfdBad = null;
bfds.TryGetValue(bm.TimeFrame.Second, out bfdBad);
BarsFileDataCacher bfdc =
new BarsFileDataCacher(this, bm, isHistory, bfdBad, bm.TimeFrame);
cacher.Add(bfdc);
}
long time = DateTime.Now.Ticks;
for (int i = 0; i < tfd.Count; i++)
{
Tick tick = tfd.Read(i);
for (int ii = 0; ii < cacher.Count; ii++)
{
cacher[ii].Add(tick);
}
mapCacher.Add(tick);
if (DateTime.Now.Ticks - time > 5000000L)
{
this.OnTaskProcessChanged(new TicksManagerProcessEventArgs(_currentTask.Task, tfd.Count, i));
time = DateTime.Now.Ticks;
}
if (this.CheckTaskPriority())
{
_abortTask = true;
break;
}
}
for (int i = 0; i < cacher.Count; i++)
{
if (_abortTask)
{
cacher[i].Abort();
}
else
{
/* блокировка */
lock (_locked)
cacher[i].Complete();
}
}
if (_abortTask)
{
mapCacher.Abort();
}
else
{
lock (_locked)
mapCacher.Complete();
}
}
public void Load()
{
List <FileInfo> filesHistory = new List <FileInfo>();
List <FileInfo> filesCache = new List <FileInfo>();
Dictionary <string, TicksManager> symbols = new Dictionary <string, TicksManager>();
FileInfo[] files = _dirHistory.GetFiles("*." + TICKS_FILE_EXT);
foreach (FileInfo file in files)
{
try {
TicksManager ticksManager = new TicksManager();
ticksManager.History = new TicksFileData(file);
symbols.Add(ticksManager.Name, ticksManager);
} catch (Exception e) {
Trace.TraceError("Load {0} - {1}", file.FullName, e.Message);
}
}
files = _dirCache.GetFiles("*." + TICKS_FILE_EXT);
foreach (FileInfo file in files)
{
try {
TicksManager ticksManager = null;
TicksFileData fileData = new TicksFileData(file);
symbols.TryGetValue(fileData.SymbolName, out ticksManager);
if (ticksManager == null)
{
ticksManager = new TicksManager();
symbols.Add(fileData.SymbolName, ticksManager);
}
ticksManager.Cache = fileData;
} catch (Exception e) {
Trace.TraceError("Load {0} - {1}", file.FullName, e.Message);
}
}
BarsFolder barsFolderHistory = new BarsFolder(_dirHistory);
BarsFolder barsFolderCache = new BarsFolder(_dirCache);
MapsFolder mapsFolderHistory = new MapsFolder(_dirHistory);
MapsFolder mapsFolderCache = new MapsFolder(_dirCache);
this.Clear();
foreach (TicksManager ticks in symbols.Values)
{
if (ticks.History == null)
{
ticks.History = new TicksFileData(_dirHistory, ticks.Name, ticks.Digits);
}
if (ticks.Cache == null)
{
ticks.Cache = new TicksFileData(_dirCache, ticks.Name, ticks.Digits);
}
ticks.InitializeBarsFiles(barsFolderHistory, barsFolderCache);
ticks.InitializeMapsFiles(mapsFolderHistory, mapsFolderCache);
Symbol symbol = new Symbol(ticks);
this.Add(symbol);
}
barsFolderHistory.DeleteEmpty();
barsFolderCache.DeleteEmpty();
}
