public Bars(string symbol, BarScaleInterval scaleInterval, string reasonToExist) : this(symbol, reasonToExist) {
this.ScaleInterval = scaleInterval;
// it's a flashing tail but ALWAYS added into Bars for easy enumeration/charting/serialization;
// ALWAYS ADDED, it is either still streaming (incomplete) OR it's complete (same instance becomes LastStaticBar);
// while in streaming, you use AbsorbIntoStreaming(), when complete use CreateNewStreaming
//this.BarStreaming = new Bar(this.Symbol, this.ScaleInterval, DateTime.MinValue);
}
public StreamingBarFactoryUnattached(string symbol, BarScaleInterval scaleInterval) {
Symbol = symbol;
ScaleInterval = scaleInterval;
LastBarFormedUnattached = null;
StreamingBarUnattached = new Bar(this.Symbol, this.ScaleInterval, DateTime.MinValue);
IntraBarSerno = 0;
}
public ChartControl() {
this.ChartSettings = new ChartSettings(); // was a component, used at InitializeComponent() (to draw SampleBars)
this.ScriptExecutorObjects = new ScriptExecutorObjects();
InitializeComponent();
//if (this.ChartSettings == null)
this.AutoScroll = false;
//this.HScroll = true;
this.hScrollBar.SmallChange = this.ChartSettings.ScrollNBarsPerOneKeyPress;
panelsFolding = new List<PanelNamedFolding>();
panelsFolding.Add(this.panelPrice);
panelsFolding.Add(this.panelVolume);
this.panelPrice.Initialize(this);
this.panelVolume.Initialize(this);
if (base.DesignMode == false) return;
//this.chartRenderer.Initialize(this);
BarScaleInterval chartShouldntCare = new BarScaleInterval(BarScale.Minute, 5);
//REFLECTION_FAILS_FOR_DESIGNER BarsBasic.GenerateRandom(chartShouldntCare)
//this.Initialize(BarsBasic.GenerateRandom(chartShouldntCare));
Bars generated = new Bars("RANDOM", chartShouldntCare, "test-ChartControl-DesignMode");
generated.GenerateAppend();
this.Initialize(generated);
}
public void ConsumerQuoteUnRegister(string symbol, BarScaleInterval scaleInterval, IStreamingConsumer consumer) {
lock (lockConsumersBySymbol) {
if (this.DistributionChannels.ContainsKey(symbol) == false) {
Assembler.PopupException("Can't unregister QuoteConsumer [" + consumer + "]: symbol[" + symbol + "] is not registered for any consumers; returning");
return;
}
Dictionary<BarScaleInterval, SymbolScaleDistributionChannel> channels = this.DistributionChannels[symbol];
if (channels.ContainsKey(scaleInterval) == false) {
string symbolDistributorsAsString = "";
foreach (SymbolScaleDistributionChannel d in channels.Values) symbolDistributorsAsString += d + ",";
symbolDistributorsAsString.TrimEnd(',');
Assembler.PopupException("Can't unregister QuoteConsumer [" + consumer + "]: scaleInterval[" + scaleInterval + "] not found among distributors [" + symbolDistributorsAsString + "]; returning");
return;
}
SymbolScaleDistributionChannel channel = channels[scaleInterval];
if (channel.ConsumersQuoteContains(consumer) == false) {
Assembler.PopupException("Can't unregister QuoteConsumer [" + consumer + "]: consumer not found in [" + channel.ConsumersQuoteAsString + "]; returning");
return;
}
channel.ConsumersQuoteRemove(consumer);
if (channel.ConsumersBarCount == 0 && channel.ConsumersQuoteCount == 0) {
//Assembler.PopupException("QuoteConsumer [" + consumer + "] was the last one using [" + symbol + "][" + scaleInterval + "]; removing QuoteBarDistributor[" + channel + "]");
channels.Remove(scaleInterval);
if (channels.Count == 0) {
//Assembler.PopupException("QuoteConsumer [" + scaleInterval + "] was the last one listening for [" + symbol + "]");
//Assembler.PopupException("...removing[" + symbol + "] from this.DistributionChannels[" + this.DistributionChannels + "]");
this.DistributionChannels.Remove(symbol);
//Assembler.PopupException("...UpstreamUnSubscribing [" + symbol + "]");
this.StreamingProvider.UpstreamUnSubscribe(symbol);
}
}
}
}
public bool ConsumerQuoteIsRegistered(string symbol, BarScaleInterval scaleInterval, IStreamingConsumer consumer) {
bool ret = false;
Dictionary<string, List<BarScaleInterval>> symbolsScaleIntervals = SymbolsScaleIntervalsQuoteConsumerRegistered(consumer);
if (symbolsScaleIntervals == null) return ret;
ret = symbolsScaleIntervals.ContainsKey(symbol);
return ret;
}
public void ConsumerQuoteRegister(string symbol, BarScaleInterval scaleInterval, IStreamingConsumer consumer) {
lock (lockConsumersBySymbol) {
if (this.DistributionChannels.ContainsKey(symbol) == false) {
SymbolScaleDistributionChannel newChannel = new SymbolScaleDistributionChannel(symbol, scaleInterval);
newChannel.ConsumersQuoteAdd(consumer);
Dictionary<BarScaleInterval, SymbolScaleDistributionChannel> newScaleChannels = new Dictionary<BarScaleInterval, SymbolScaleDistributionChannel>();
newScaleChannels.Add(scaleInterval, newChannel);
this.DistributionChannels.Add(symbol, newScaleChannels);
if (this.StreamingProvider.UpstreamIsSubscribed(symbol) == false) {
this.StreamingProvider.UpstreamSubscribe(symbol);
}
return;
}
Dictionary<BarScaleInterval, SymbolScaleDistributionChannel> channels = this.DistributionChannels[symbol];
if (channels.ContainsKey(scaleInterval) == false) {
SymbolScaleDistributionChannel newChannel = new SymbolScaleDistributionChannel(symbol, scaleInterval);
newChannel.ConsumersQuoteAdd(consumer);
channels.Add(scaleInterval, newChannel);
return;
}
SymbolScaleDistributionChannel channel = channels[scaleInterval];
if (channel.ConsumersQuoteContains(consumer) == false) {
channel.ConsumersQuoteAdd(consumer);
return;
}
Assembler.PopupException("QuoteConsumer [" + consumer + "] already registered for [" + channel + "]; returning");
}
}
public static Bars GenerateRandom(BarScaleInterval scaleInt, int howManyBars = 10,
string symbol = "SAMPLE", string reasonToExist = "test-ChartControl-DesignMode")
{
Bars ret = new Bars(symbol, scaleInt, reasonToExist);
ret.GenerateAppend(howManyBars);
return(ret);
}
public SymbolScaleDistributionChannel(string symbol, BarScaleInterval scaleInterval) {
Symbol = symbol;
ScaleInterval = scaleInterval;
StreamingBarFactoryUnattached = new StreamingBarFactoryUnattached(symbol, ScaleInterval);
consumersQuote = new List<IStreamingConsumer>();
consumersBar = new List<IStreamingConsumer>();
earlyBinders = new Dictionary<IStreamingConsumer, StreamingEarlyBinder>();
}
public Bars(string symbol, BarScaleInterval scaleInterval, string reasonToExist) : this(symbol, reasonToExist)
{
this.ScaleInterval = scaleInterval;
// it's a flashing tail but ALWAYS added into Bars for easy enumeration/charting/serialization;
// ALWAYS ADDED, it is either still streaming (incomplete) OR it's complete (same instance becomes LastStaticBar);
// while in streaming, you use AbsorbIntoStreaming(), when complete use CreateNewStreaming
//this.BarStreaming = new Bar(this.Symbol, this.ScaleInterval, DateTime.MinValue);
}
public RepositoryBarsSameScaleInterval(string dataSourceAbspath, BarScaleInterval scaleInterval, bool createNonExistingSubfolder = true, string extension = "BAR") {
this.DataSourceAbspath = dataSourceAbspath;
//if (this.FolderWithSymbolFiles.EndsWith(Path.DirectorySeparatorChar) == false) this.FolderWithSymbolFiles += Path.DirectorySeparatorChar;
if (Directory.Exists(this.DataSourceAbspath) == false) Directory.CreateDirectory(this.DataSourceAbspath);
this.Extension = extension;
this.ScaleInterval = scaleInterval;
this.createNonExistingSubfolder = createNonExistingSubfolder;
}
protected ContextChart() {
Name = "UNDEFINED";
Symbol = "UNDEFINED";
DataSourceName = "UNDEFINED";
ScaleInterval = new BarScaleInterval();
DataRange = new BarDataRange(500);
//ChartBarSpacing = 6;
ChartStreaming = false;
ShowRangeBar = false;
}
public override bool Equals(object obj)
{
BarScaleInterval other = obj as BarScaleInterval;
if (other == null)
{
return(false);
}
return(this.Scale == other.Scale && this.Interval == other.Interval);
}
public Bars CloneNoBars(string reasonToExist = null, BarScaleInterval scaleIntervalConvertingTo = null) {
if (scaleIntervalConvertingTo == null) scaleIntervalConvertingTo = this.ScaleInterval;
if (string.IsNullOrEmpty(reasonToExist)) reasonToExist = "InitializedFrom(" + this.ReasonToExist + ")";
Bars ret = new Bars(this.Symbol, scaleIntervalConvertingTo, reasonToExist);
ret.SymbolHumanReadable = this.SymbolHumanReadable;
ret.MarketInfo = this.MarketInfo;
ret.SymbolInfo = this.SymbolInfo;
ret.DataSource = this.DataSource;
return ret;
}
public void AbsorbFrom(ContextChart found) {
if (found == null) return;
//KEEP_CLONE_UNDEFINED this.Name = found.Name;
this.Symbol = found.Symbol;
this.DataSourceName = found.DataSourceName;
this.ScaleInterval = found.ScaleInterval.Clone();
this.DataRange = found.DataRange.Clone();
//this.ChartBarSpacing = found.ChartBarSpacing;
this.ChartStreaming = found.ChartStreaming;
this.ShowRangeBar = found.ShowRangeBar;
}
public Bar(string symbol, BarScaleInterval scaleInterval, DateTime dateTimeOpen) : this() {
this.Symbol = symbol;
this.ScaleInterval = scaleInterval;
if (dateTimeOpen == DateTime.MinValue) {
this.DateTimeOpen = DateTime.MinValue;
this.DateTimeNextBarOpenUnconditional = DateTime.MinValue;
this.DateTimePreviousBarOpenUnconditional = DateTime.MinValue;
} else {
this.RoundDateDownInitTwoAuxDates(dateTimeOpen);
}
}
public Bar(string symbol, BarScaleInterval scaleInterval, DateTime dateTimeOpen) : this()
{
this.Symbol = symbol;
this.ScaleInterval = scaleInterval;
if (dateTimeOpen == DateTime.MinValue)
{
this.DateTimeOpen = DateTime.MinValue;
this.DateTimeNextBarOpenUnconditional = DateTime.MinValue;
this.DateTimePreviousBarOpenUnconditional = DateTime.MinValue;
}
else
{
this.RoundDateDownInitTwoAuxDates(dateTimeOpen);
}
}
public Bars CloneNoBars(string reasonToExist = null, BarScaleInterval scaleIntervalConvertingTo = null)
{
if (scaleIntervalConvertingTo == null)
{
scaleIntervalConvertingTo = this.ScaleInterval;
}
if (string.IsNullOrEmpty(reasonToExist))
{
reasonToExist = "InitializedFrom(" + this.ReasonToExist + ")";
}
Bars ret = new Bars(this.Symbol, scaleIntervalConvertingTo, reasonToExist);
ret.SymbolHumanReadable = this.SymbolHumanReadable;
ret.MarketInfo = this.MarketInfo;
ret.SymbolInfo = this.SymbolInfo;
ret.DataSource = this.DataSource;
return(ret);
}
public bool CanConvertTo(BarScaleInterval scaleIntervalTo)
{
// for proper comparison, make sure Sq1.Core.DataTypes.BarScale enum has scales growing from Tick to Yearly
if (this.ScaleInterval.Scale > scaleIntervalTo.Scale)
{
return(false); //can't convert from 1hr to 5min
}
if (this.ScaleInterval.Scale < scaleIntervalTo.Scale)
{
return(true);
}
// here we are if (this.ScaleInterval.Scale == scaleIntervalTo.Scale)
if (this.ScaleInterval.Interval <= scaleIntervalTo.Interval)
{
return(true);
}
return(false);
}
void checkThrowCanConvert(BarScaleInterval scaleIntervalTo)
{
string msig = "checkThrowCanConvert(" + this.ScaleInterval + "=>" + scaleIntervalTo + ") for " + this + " datasource[" + this.DataSource + "]";
string msg = "";
bool canConvert = this.CanConvertTo(scaleIntervalTo);
if (canConvert == false)
{
msg += "CANNOT_CONVERT_TO_LARGER_SCALE_INTERVAL";
}
if (this.Count == 0)
{
msg += " EMPTY_BARS_FROM";
}
//if (barsFrom.ScaleInterval.Scale == BarScale.Tick) msg += " TICKS_CAN_NOT_BE_CONVERTED_TO_ANYTHING";
if (string.IsNullOrEmpty(msg))
{
return;
}
throw new Exception(msg + msig);
}
public Bars BarsLoadAll() {
string msig = " BarsLoadAll(this.Abspath=[" + this.Abspath + "]): ";
Bars bars = null;
DateTime dateTime = DateTime.Now;
FileStream fileStream = null;
try {
fileStream = File.Open(this.Abspath, FileMode.Open, FileAccess.Read, FileShare.Read);
BinaryReader binaryReader = new BinaryReader(fileStream);
double version = binaryReader.ReadDouble();
//Assembler.PopupException("LoadBars[" + this.Relpath + "]: version[" + version + "]");
string symbol = binaryReader.ReadString();
string symbolHumanReadable = binaryReader.ReadString();
BarScale barScale = (BarScale)binaryReader.ReadInt32();
int barInterval = binaryReader.ReadInt32();
BarScaleInterval scaleInterval = new BarScaleInterval(barScale, barInterval);
//string shortFnameIneedMorePathParts = Path.GetFileName(this.Abspath);
//string shortFname = this.Abspath.Substring(this.Abspath.IndexOf("" + Path.DirectorySeparatorChar + "Data" + Path.DirectorySeparatorChar + "") + 6);
string shortFname = this.Relpath;
bars = new Bars(symbol, scaleInterval, shortFname);
int barsStored = binaryReader.ReadInt32();
//int securityType = binaryReader.ReadInt32();
//bars.SymbolInfo.SecurityType = (SecurityType)securityType;
for (int barsRead = 0; barsRead<barsStored; barsRead++) {
DateTime dateTimeOpen = new DateTime(binaryReader.ReadInt64());
double open = binaryReader.ReadDouble();
double high = binaryReader.ReadDouble();
double low = binaryReader.ReadDouble();
double close = binaryReader.ReadDouble();
double volume = binaryReader.ReadDouble();
Bar barAdded = bars.BarCreateAppendBindStatic(dateTimeOpen, open, high, low, close, volume);
}
} catch (EndOfStreamException ex) {
Assembler.PopupException(ex.Message + msig, ex);
} finally {
if (fileStream != null) fileStream.Close();
}
return bars;
}
public Bars ToLargerScaleInterval(BarScaleInterval scaleIntervalTo)
{
if (this.ScaleInterval == scaleIntervalTo)
{
return(this);
}
this.checkThrowCanConvert(scaleIntervalTo);
Bars barsConverted = this.CloneNoBars(this.ReasonToExist + "=>[" + scaleIntervalTo + "]", scaleIntervalTo);
if (this.Count == 0)
{
return(barsConverted);
}
Bar barFromFirst = this[0];
Bar barCompressing = new Bar(this.Symbol, scaleIntervalTo, barFromFirst.DateTimeOpen); // I'm happy with RoundDateDownInitTwoAuxDates()
barCompressing.AbsorbOHLCVfrom(barFromFirst);
for (int i = 1; i < this.Count; i++)
{
Bar barEach = this[i];
if (barEach.DateTimeOpen >= barCompressing.DateTimeNextBarOpenUnconditional)
{
barsConverted.BarAppendBindStatic(barCompressing);
barCompressing = new Bar(this.Symbol, scaleIntervalTo, barEach.DateTimeOpen);
barCompressing.AbsorbOHLCVfrom(barEach);
}
else
{
barCompressing.MergeExpandHLCVwhileCompressingManyBarsToOne(barEach);
}
}
return(barsConverted);
}
public virtual void ConsumerBarRegister(string symbol, BarScaleInterval scaleInterval, IStreamingConsumer consumer) {
if (scaleInterval.Scale == BarScale.Unknown) {
string msg = "Failed to ConsumerBarRegister(): scaleInterval.Scale=Unknown; returning";
Assembler.PopupException(msg);
throw new Exception(msg);
}
this.DataDistributor.ConsumerBarRegister(symbol, scaleInterval, consumer);
}
// should be used by a programmer
public DataSource(string name, BarScaleInterval scaleInterval = null, MarketInfo marketInfo = null) : this() {
this.Name = name;
if (scaleInterval == null) {
scaleInterval = new BarScaleInterval(BarScale.Minute, 5);
}
this.ScaleInterval = scaleInterval;
if (marketInfo == null) {
marketInfo = Assembler.InstanceInitialized.MarketInfoRepository.FindMarketInfoOrNew("MOCK");
}
this.MarketInfo = marketInfo;
}
void step3syncCsvRawAndFieldSetupToParsedByFormat() {
List<CsvBar> csvParsedByFormat = new List<CsvBar>();
string symbol = null;
BarScaleInterval scaleInterval = null;
bool allCsvBarsHaveDOHLCV = true;
string dateAndTimeFormatsGlued = this.dataSnapshot.FieldSetupCurrent.DateAndTimeFormatsGlued;
foreach (OLVColumn each in this.olvParsedByFormat.Columns) {
each.HeaderForeColor = Color.Black;
}
foreach (List<string> row in this.csvUnnamed) {
try {
CsvBar newCsvBar = new CsvBar();
//foreach (string cell in row) {
for (int i=0; i<row.Count; i++) {
string cell = row[i];
var iColumn = this.dataSnapshot.FieldSetupCurrent[i];
try {
iColumn.Parser.ParseAndPushThrows(cell, newCsvBar, dateAndTimeFormatsGlued);
} catch (Exception ex) {
//YOULL_RESET_COLUMNS_DESIGNER_this.olvParsedByFormat.Reset();
//UPSTACK_CATCH_DOES_THIS this.olvParsedByFormat.SetObjects(null);
//UPSTACK_CATCH_DOES_THIS this.olvParsedByFormat.EmptyListMsg = msg;
string msg = "value[" + cell + "] column#[" + i + "] type[" + iColumn.Parser.CsvType + "]"
+ "\r\n" + ex.Message;
throw new Exception(msg, ex);
}
switch (iColumn.Parser.CsvType) {
case CsvFieldType.Symbol:
if (String.IsNullOrEmpty(symbol) == false) break;
symbol = cell;
break;
case CsvFieldType.Interval_Min:
if (scaleInterval != null) break;
int minutes = 0;
bool minutesParsedOk = int.TryParse(cell, out minutes);
if (minutesParsedOk == false) break;
if (minutes <= 0) break;
scaleInterval = new BarScaleInterval(BarScale.Minute, minutes);
break;
case CsvFieldType.Interval_Hrs:
if (scaleInterval != null) break;
int hours = 0;
bool hoursParsedOk = int.TryParse(cell, out hours);
if (hoursParsedOk == false) break;
if (hours <= 0) break;
scaleInterval = new BarScaleInterval(BarScale.Hour, hours);
break;
case CsvFieldType.Interval_Days:
if (scaleInterval != null) break;
int days = 0;
bool daysParsedOk = int.TryParse(cell, out days);
if (daysParsedOk == false) break;
if (days <= 0) break;
scaleInterval = new BarScaleInterval(BarScale.Daily, days);
break;
}
}
allCsvBarsHaveDOHLCV &= newCsvBar.IsFullyFilledDOHLCV;
csvParsedByFormat.Add(newCsvBar);
} catch (Exception ex) {
this.olvCsvParsedRaw.SelectObject(row);
throw ex;
}
}
this.olvParsedByFormat.SetObjects(csvParsedByFormat);
if (allCsvBarsHaveDOHLCV == false || csvParsedByFormat.Count == 0) {
this.disableRangeBarAndBtnImport();
return;
}
this.csvParsedByFormat = csvParsedByFormat;
this.symbolDetectedInCsv = symbol;
this.scaleIntervalDetectedInCsv = scaleInterval;
this.step4createBarsDisplayChart();
}
public SymbolScaleDistributionChannel GetDistributionChannelFor(string symbol, BarScaleInterval barScaleInterval) {
if (this.DistributionChannels.ContainsKey(symbol) == false) {
string msg = "NO_SYMBOL_SUBSCRIBER DataDistributor[" + this + "].DistributionChannels.ContainsKey(" + symbol + ")=false";
Assembler.PopupException(msg);
throw new Exception(msg);
}
Dictionary<BarScaleInterval, SymbolScaleDistributionChannel> distributionChannels = this.DistributionChannels[symbol];
if (distributionChannels.ContainsKey(barScaleInterval) == false) {
string msg = "NO_SCALEINTERVAL_SUBSCRIBER DataDistributor[" + this
+ "].DistributionChannels[" + symbol + "].ContainsKey(" + barScaleInterval + ")=false";
Assembler.PopupException(msg);
//this.StreamingProvider.StatusReporter.PopupException(new Exception(msg));
throw new Exception(msg);
}
return distributionChannels[barScaleInterval];
}
public static BarScaleInterval FromTimeSpan(TimeSpan ts)
{
BarScaleInterval ret = new BarScaleInterval(BarScale.Unknown, 0);
if (ts.Days >= 365)
{
ret.Scale = BarScale.Yearly;
ret.Interval = 1 + ((int)ts.Days / 365);
return(ret);
}
if (ts.Days >= 28)
{
ret.Scale = BarScale.Monthly;
ret.Interval = 1 + ((int)ts.Days / 28);
return(ret);
}
ret.Scale = BarScale.Weekly;
if (ts.Days >= 7)
{
ret.Interval = 1 + ((int)ts.Days / 7);
return(ret);
}
ret.Scale = BarScale.Daily;
if (ts.Days >= 1)
{
ret.Interval = ts.Days;
return(ret);
}
ret.Scale = BarScale.Hour;
if (ts.Hours >= 1)
{
ret.Interval = ts.Hours;
return(ret);
}
ret.Scale = BarScale.Minute;
if (ts.Minutes >= 30)
{
ret.Interval = 30 * ((int)ts.Minutes / 30);
return(ret);
}
if (ts.Minutes >= 20)
{
ret.Interval = 20 * ((int)ts.Minutes / 20);
return(ret);
}
if (ts.Minutes >= 15)
{
ret.Interval = 15 * ((int)ts.Minutes / 15);
return(ret);
}
if (ts.Minutes >= 10)
{
ret.Interval = 10 * ((int)ts.Minutes / 10);
return(ret);
}
if (ts.Minutes >= 5)
{
ret.Interval = 5 * ((int)ts.Minutes / 5);
return(ret);
}
if (ts.Minutes >= 1)
{
ret.Interval = 1 * ((int)ts.Minutes / 1);
return(ret);
}
ret.Scale = BarScale.Tick;
return(ret);
}
public void CancelStrategyOrders(string account, Strategy strategy, string symbol, BarScaleInterval dataScale) {
try {
Exception e = new Exception("just for call stack trace");
throw e;
} catch (Exception ex) {
string msg = "I won't cancel any orders; reconsider application architecture";
Assembler.PopupException(msg, ex);
}
}
public virtual void ConsumerBarUnRegister(string symbol, BarScaleInterval scaleInterval, IStreamingConsumer consumer) {
this.DataDistributor.ConsumerBarUnRegister(symbol, scaleInterval, consumer);
}
public virtual void ConsumerQuoteUnRegister(string symbol, BarScaleInterval scaleInterval, IStreamingConsumer streamingConsumer) {
this.DataDistributor.ConsumerQuoteUnRegister(symbol, scaleInterval, streamingConsumer);
this.StreamingDataSnapshot.LastQuotePutNull(symbol);
}
public virtual bool ConsumerQuoteIsRegistered(string symbol, BarScaleInterval scaleInterval, IStreamingConsumer consumer) {
return this.DataDistributor.ConsumerQuoteIsRegistered(symbol, scaleInterval, consumer);
}
void step4createBarsDisplayChart() {
string status = " Symbol[" + this.symbolDetectedInCsv + "]";
BarScaleInterval csvScaleInterval = this.scaleIntervalDetectedInCsv;
if (csvScaleInterval == null) {
this.scaleIntervalMinimalScanned = this.findMinimalInterval(this.csvParsedByFormat);
status += " ScaleIntervalMinFound[" + csvScaleInterval + "]";
} else {
status += " ScaleIntervalFromColumn[" + csvScaleInterval + "]";
}
string statusOld = this.grpPreviewParsedByFormat.Text;
int posToAppend = statusOld.IndexOf('|');
//if (posToAppend < 0) posToAppend = 0;
string prefix = statusOld.Substring(0, posToAppend+1); // no exception thrown even if posToAppend=-1 (not found)
this.grpPreviewParsedByFormat.Text = prefix + status;
this.BarsParsed = new Bars(this.symbolDetectedInCsv, csvScaleInterval, this.dataSnapshot.FileSelectedAbsname);
//BarsUnscaled barsParsed = new BarsUnscaled(symbol, this.dataSnapshot.FileSelectedAbsname);
foreach (CsvBar csvBar in this.csvParsedByFormat) {
this.BarsParsed.BarCreateAppendBindStatic(csvBar.DateTime, csvBar.Open, csvBar.High, csvBar.Low, csvBar.Close, csvBar.Volume);
}
//status += " BarsParsed.Count[" + this.BarsParsed.Count + "]";
status += " Bars[" + this.BarsParsed.Count + "]";
this.grpPreviewParsedByFormat.Text = prefix + status;
this.rangeBarDateTime1.Enabled = true;
this.rangeBarDateTime1.Initialize(this.BarsParsed);
this.syncImportButton();
}
public NotOnChartBarsKey(BarScaleInterval notOnChartBarScaleInterval, string notOnChartSymbol, string notOnChartDataSourceName) {
this.DataSourceName = notOnChartDataSourceName;
this.Symbol = notOnChartSymbol;
this.BarScaleInterval = notOnChartBarScaleInterval;
}
// overridable proxy methods routed by default to DataDistributor
public virtual void ConsumerBarRegister(string symbol, BarScaleInterval scaleInterval, IStreamingConsumer consumer, Bar PartialBarInsteadOfEmpty) {
this.ConsumerBarRegister(symbol, scaleInterval, consumer);
SymbolScaleDistributionChannel channel = this.DataDistributor.GetDistributionChannelFor(symbol, scaleInterval);
channel.StreamingBarFactoryUnattached.InitWithStreamingBarInsteadOfEmpty(PartialBarInsteadOfEmpty);
}
private Bars(string symbol, string reasonToExist = "NOREASON") : base(symbol, reasonToExist)
{
ScaleInterval = new BarScaleInterval(BarScale.Unknown, 0);
SymbolHumanReadable = "";
InstanceAbsno++;
}
public BarScaleIntervalEventArgs(BarScaleInterval barScaleInterval) {
this.BarScaleInterval = barScaleInterval.Clone();
}
public Alert() { // called by Json.Deserialize()
PlacedBarIndex = -1;
FilledBarIndex = -1;
//TimeCreatedServerBar = DateTime.MinValue;
this.QuoteCreatedThisAlertServerTime = DateTime.MinValue;
Symbol = "UNKNOWN_JUST_DESERIALIZED";
//SymbolClass = ""; //QUIK
//AccountNumber = "";
PriceScript = 0;
PriceDeposited = -1; // for a Future, we pay less that it's quoted (GUARANTEE DEPOSIT)
Qty = 0;
MarketLimitStop = MarketLimitStop.Unknown;
MarketOrderAs = MarketOrderAs.Unknown;
Direction = Direction.Unknown;
SignalName = "";
StrategyID = Guid.Empty;
StrategyName = "NO_STRATEGY";
BarsScaleInterval = new BarScaleInterval(BarScale.Unknown, 0);
OrderFollowed = null;
MreOrderFollowedIsNotNull = new ManualResetEvent(false);
}
public static BarScaleInterval FromTimeSpan(TimeSpan ts) {
BarScaleInterval ret = new BarScaleInterval(BarScale.Unknown, 0);
if (ts.Days >= 365) {
ret.Scale = BarScale.Yearly;
ret.Interval = 1 + ((int) ts.Days / 365);
return ret;
}
if (ts.Days >= 28) {
ret.Scale = BarScale.Monthly;
ret.Interval = 1 + ((int) ts.Days / 28);
return ret;
}
ret.Scale = BarScale.Weekly;
if (ts.Days >= 7) {
ret.Interval = 1 + ((int) ts.Days / 7);
return ret;
}
ret.Scale = BarScale.Daily;
if (ts.Days >= 1) {
ret.Interval = ts.Days;
return ret;
}
ret.Scale = BarScale.Hour;
if (ts.Hours >= 1) {
ret.Interval = ts.Hours;
return ret;
}
ret.Scale = BarScale.Minute;
if (ts.Minutes >= 30) {
ret.Interval = 30 * ((int) ts.Minutes / 30);
return ret;
}
if (ts.Minutes >= 20) {
ret.Interval = 20 * ((int) ts.Minutes / 20);
return ret;
}
if (ts.Minutes >= 15) {
ret.Interval = 15 * ((int) ts.Minutes / 15);
return ret;
}
if (ts.Minutes >= 10) {
ret.Interval = 10 * ((int) ts.Minutes / 10);
return ret;
}
if (ts.Minutes >= 5) {
ret.Interval = 5 * ((int) ts.Minutes / 5);
return ret;
}
if (ts.Minutes >= 1) {
ret.Interval = 1 * ((int) ts.Minutes / 1);
return ret;
}
ret.Scale = BarScale.Tick;
return ret;
}
public DateTime GetNextMarketServerTimeStamp(DateTime serverDateTime, BarScaleInterval scale,
out MarketClearingTimespan clearingTimespan)
{
if (serverDateTime == DateTime.MinValue)
{
throw new Exception("IRefuse: NextTimeStamp for DateTime.MinValue");
//serverDateTime = this.ConvertLocalTimeToServer(DateTime.Now);
}
DateTime ret = serverDateTime;
bool addNextRank = false;
int year = ret.Year;
int nextMonth = ret.Month + 1;
int intervalsCeiled = 0;
int valueCeiled = 0;
//MarketClearingTimespan
clearingTimespan = null;
switch (scale.Scale)
{
case BarScale.Tick:
throw new ArgumentException("Tick scale is not supported");
case BarScale.Second:
intervalsCeiled = (int)Math.Floor((double)(serverDateTime.Second / scale.Interval));
valueCeiled = (intervalsCeiled + 1) * scale.Interval;
if (valueCeiled >= 60)
{
addNextRank = true;
valueCeiled -= 60;
}
ret = new DateTime(serverDateTime.Year, serverDateTime.Month, serverDateTime.Day,
serverDateTime.Hour, serverDateTime.Minute, valueCeiled);
if (addNextRank)
{
ret = ret.AddMinutes(1);
}
clearingTimespan = getClearingTimespanIfMarketSuspended(ret);
if (clearingTimespan != null)
{
ret = this.AdvanceToWhenClearingResumes(ret, clearingTimespan);
//ret = ret.AddSeconds((double)scale.Interval);
}
if (this.isMarketAfterCloseServerTime(ret))
{
ret = this.AdvanceToNextDayOpen(ret);
//ret = ret.AddSeconds((double)scale.Interval);
}
break;
case BarScale.Minute:
intervalsCeiled = (int)Math.Floor((double)(serverDateTime.Minute / scale.Interval));
valueCeiled = (intervalsCeiled + 1) * scale.Interval;
if (valueCeiled >= 60)
{
addNextRank = true;
valueCeiled -= 60;
}
ret = new DateTime(serverDateTime.Year, serverDateTime.Month, serverDateTime.Day,
serverDateTime.Hour, valueCeiled, 0);
if (addNextRank)
{
ret = ret.AddHours(1);
}
clearingTimespan = getClearingTimespanIfMarketSuspended(ret);
if (clearingTimespan != null)
{
ret = this.AdvanceToWhenClearingResumes(ret, clearingTimespan);
//ret = ret.AddMinutes((double)scale.Interval);
}
bool afterClose = this.isMarketAfterCloseServerTime(ret);
bool beforeOpen = this.isMarketBeforeOpenServerTime(ret);
if (beforeOpen)
{
ret = this.AdvanceToThisDayOpen(ret);
}
else
{
if (afterClose)
{
ret = this.AdvanceToNextDayOpen(ret);
}
}
break;
case BarScale.Hour:
intervalsCeiled = (int)Math.Floor((double)(serverDateTime.Minute / scale.Interval));
valueCeiled = (intervalsCeiled + 1) * scale.Interval;
if (valueCeiled >= 24)
{
addNextRank = true;
valueCeiled -= 24;
}
ret = new DateTime(serverDateTime.Year, serverDateTime.Month, serverDateTime.Day,
serverDateTime.Hour, valueCeiled, 0);
if (addNextRank)
{
ret = ret.AddDays(1);
}
clearingTimespan = getClearingTimespanIfMarketSuspended(ret);
if (clearingTimespan != null)
{
ret = this.AdvanceToWhenClearingResumes(ret, clearingTimespan);
//ret = ret.AddHours((double)scale.Interval);
}
if (this.isMarketAfterCloseServerTime(ret))
{
ret = this.AdvanceToNextDayOpen(ret);
//ret = ret.AddHours((double)scale.Interval);
}
break;
case BarScale.Daily:
ret = this.AdvanceToNextDayOpen(ret);
break;
case BarScale.Weekly:
ret = this.AdvanceToNextDayOpen(ret);
while (ret.DayOfWeek != DayOfWeek.Friday)
{
ret = ret.AddDays(1.0);
}
if (this.IsTradeableDayServerTime(ret) == false)
{
if (ret.Day == serverDateTime.Day - 1)
{
ret = ret.AddDays(7.0);
if (!this.IsTradeableDayServerTime(ret))
{
ret = ret.AddDays(-1.0);
}
}
else
{
ret = ret.AddDays(-1.0);
}
}
break;
case BarScale.Monthly:
if (nextMonth == 13)
{
nextMonth = 1;
year++;
}
ret = new DateTime(year, nextMonth, 1, 0, 0, 0);
ret = this.AdvanceToNextDayOpen(ret);
ret = ret.AddDays(-1.0);
while (!this.IsTradeableDayServerTime(ret))
{
ret = ret.AddDays(-1.0);
}
break;
case BarScale.Quarterly:
if (nextMonth == 13)
{
year++;
nextMonth = 1;
}
else
{
nextMonth = ((int)Math.Floor((double)ret.Month / 3)) * 3;
}
ret = new DateTime(year, nextMonth, 28);
do
{
ret = ret.AddDays(1.0);
} while (ret.Month == nextMonth);
ret = ret.AddDays(-1.0);
ret = this.AdvanceToNextDayOpen(ret);
while (!this.IsTradeableDayServerTime(ret))
{
ret = ret.AddDays(-1.0);
}
break;
case BarScale.Yearly:
ret = new DateTime(ret.Year + 1, 12, 31);
ret = this.AdvanceToNextDayOpen(ret);
while (!this.IsTradeableDayServerTime(ret))
{
ret = ret.AddDays(-1.0);
}
break;
}
return(ret);
}
void mnitlbAll_UserTyped(object sender, LabeledTextBoxUserTypedArgs e) {
try {
string userTyped = e.StringUserTyped;
int userTypedInteger;
bool validInteger = Int32.TryParse(userTyped, out userTypedInteger);
if (validInteger == false) {
e.HighlightTextWithRed = true;
return;
}
if (userTypedInteger <= 0) {
e.HighlightTextWithRed = true;
return;
}
MenuItemLabeledTextBox mniTypedAsLTB = sender as MenuItemLabeledTextBox;
if (mniTypedAsLTB == null) {
string msg = "SENDER_MUSTBE_LabeledTextBoxControl_GOT " + mniTypedAsLTB.GetType();
Assembler.PopupException(msg);
return;
}
BarScale barScaleTyped;
switch (mniTypedAsLTB.Name) {
case "mnitlbMinutes": barScaleTyped = BarScale.Minute; break;
case "mnitlbHourly": barScaleTyped = BarScale.Hour; break;
case "mnitlbDaily": barScaleTyped = BarScale.Daily; break;
case "mnitlbWeekly": barScaleTyped = BarScale.Weekly; break;
case "mnitlbMonthly": barScaleTyped = BarScale.Monthly; break;
//case "mnitlbQuarterly": barScaleTyped = BarScale.Quarterly; break;
case "mnitlbYearly": barScaleTyped = BarScale.Yearly; break;
default:
string msg = "SENDER_UNEXPECTED_NAME " + mniTypedAsLTB.Name;
Assembler.PopupException(msg);
return;
}
this.selectOneDeselectResetOthers(this.DdbBars.DropDownItems, mniTypedAsLTB, this.GroupScaleLabeledTextboxes);
BarScaleInterval scaleIntervalUserEntered = new BarScaleInterval(barScaleTyped, userTypedInteger);
ContextChart context = this.ChartFormManager.ContextCurrentChartOrStrategy;
context.ScaleInterval = scaleIntervalUserEntered;
this.ChartFormManager.PopulateSelectorsFromCurrentChartOrScriptContextLoadBarsSaveBacktestIfStrategy("mniltbAll_UserTyped");
} catch (Exception ex) {
Assembler.PopupException("mniltbMinutes_UserTyped()", ex);
}
}
public Bars BarsLoadAndCompress(string symbolRq, BarScaleInterval scaleIntervalRq) {
Bars ret = this.RequestDataFromRepository(symbolRq);
ret.DataSource = this;
ret.MarketInfo = this.MarketInfo;
ret.SymbolInfo = Assembler.InstanceInitialized.RepositoryCustomSymbolInfo.FindSymbolInfoOrNew(ret.Symbol);
if (ret.Count == 0) return ret;
if (scaleIntervalRq == ret.ScaleInterval) return ret;
bool canConvert = ret.CanConvertTo(scaleIntervalRq);
if (canConvert == false) {
string msg = "CANNOT_COMPRESS_BARS " + symbolRq + "[" + ret.ScaleInterval + "]=>[" + scaleIntervalRq + "]";
Assembler.PopupException(msg);
return ret;
}
try {
ret = ret.ToLargerScaleInterval(scaleIntervalRq);
} catch (Exception e) {
Assembler.PopupException("BARS_COMPRESSION_FAILED (ret, scaleIntervalRq)", e);
throw e;
}
return ret;
}
public DateTime GetNextMarketServerTimeStamp(DateTime serverDateTime, BarScaleInterval scale,
out MarketClearingTimespan clearingTimespan) {
if (serverDateTime == DateTime.MinValue) {
throw new Exception("IRefuse: NextTimeStamp for DateTime.MinValue");
//serverDateTime = this.ConvertLocalTimeToServer(DateTime.Now);
}
DateTime ret = serverDateTime;
bool addNextRank = false;
int year = ret.Year;
int nextMonth = ret.Month + 1;
int intervalsCeiled = 0;
int valueCeiled = 0;
//MarketClearingTimespan
clearingTimespan = null;
switch (scale.Scale) {
case BarScale.Tick:
throw new ArgumentException("Tick scale is not supported");
case BarScale.Second:
intervalsCeiled = (int)Math.Floor((double)(serverDateTime.Second / scale.Interval));
valueCeiled = (intervalsCeiled + 1) * scale.Interval;
if (valueCeiled >= 60) {
addNextRank = true;
valueCeiled -= 60;
}
ret = new DateTime(serverDateTime.Year, serverDateTime.Month, serverDateTime.Day,
serverDateTime.Hour, serverDateTime.Minute, valueCeiled);
if (addNextRank) ret = ret.AddMinutes(1);
clearingTimespan = getClearingTimespanIfMarketSuspended(ret);
if (clearingTimespan != null) {
ret = this.AdvanceToWhenClearingResumes(ret, clearingTimespan);
//ret = ret.AddSeconds((double)scale.Interval);
}
if (this.isMarketAfterCloseServerTime(ret)) {
ret = this.AdvanceToNextDayOpen(ret);
//ret = ret.AddSeconds((double)scale.Interval);
}
break;
case BarScale.Minute:
intervalsCeiled = (int)Math.Floor((double)(serverDateTime.Minute / scale.Interval));
valueCeiled = (intervalsCeiled + 1) * scale.Interval;
if (valueCeiled >= 60) {
addNextRank = true;
valueCeiled -= 60;
}
ret = new DateTime(serverDateTime.Year, serverDateTime.Month, serverDateTime.Day,
serverDateTime.Hour, valueCeiled, 0);
if (addNextRank) ret = ret.AddHours(1);
clearingTimespan = getClearingTimespanIfMarketSuspended(ret);
if (clearingTimespan != null) {
ret = this.AdvanceToWhenClearingResumes(ret, clearingTimespan);
//ret = ret.AddMinutes((double)scale.Interval);
}
bool afterClose = this.isMarketAfterCloseServerTime(ret);
bool beforeOpen = this.isMarketBeforeOpenServerTime(ret);
if (beforeOpen) {
ret = this.AdvanceToThisDayOpen(ret);
} else {
if (afterClose) {
ret = this.AdvanceToNextDayOpen(ret);
}
}
break;
case BarScale.Hour:
intervalsCeiled = (int)Math.Floor((double)(serverDateTime.Minute / scale.Interval));
valueCeiled = (intervalsCeiled + 1) * scale.Interval;
if (valueCeiled >= 24) {
addNextRank = true;
valueCeiled -= 24;
}
ret = new DateTime(serverDateTime.Year, serverDateTime.Month, serverDateTime.Day,
serverDateTime.Hour, valueCeiled, 0);
if (addNextRank) ret = ret.AddDays(1);
clearingTimespan = getClearingTimespanIfMarketSuspended(ret);
if (clearingTimespan != null) {
ret = this.AdvanceToWhenClearingResumes(ret, clearingTimespan);
//ret = ret.AddHours((double)scale.Interval);
}
if (this.isMarketAfterCloseServerTime(ret)) {
ret = this.AdvanceToNextDayOpen(ret);
//ret = ret.AddHours((double)scale.Interval);
}
break;
case BarScale.Daily:
ret = this.AdvanceToNextDayOpen(ret);
break;
case BarScale.Weekly:
ret = this.AdvanceToNextDayOpen(ret);
while (ret.DayOfWeek != DayOfWeek.Friday) {
ret = ret.AddDays(1.0);
}
if (this.IsTradeableDayServerTime(ret) == false) {
if (ret.Day == serverDateTime.Day - 1) {
ret = ret.AddDays(7.0);
if (!this.IsTradeableDayServerTime(ret)) {
ret = ret.AddDays(-1.0);
}
} else {
ret = ret.AddDays(-1.0);
}
}
break;
case BarScale.Monthly:
if (nextMonth == 13) {
nextMonth = 1;
year++;
}
ret = new DateTime(year, nextMonth, 1, 0, 0, 0);
ret = this.AdvanceToNextDayOpen(ret);
ret = ret.AddDays(-1.0);
while (!this.IsTradeableDayServerTime(ret)) {
ret = ret.AddDays(-1.0);
}
break;
case BarScale.Quarterly:
if (nextMonth == 13) {
year++;
nextMonth = 1;
} else {
nextMonth = ((int)Math.Floor((double)ret.Month / 3)) * 3;
}
ret = new DateTime(year, nextMonth, 28);
do {
ret = ret.AddDays(1.0);
} while (ret.Month == nextMonth);
ret = ret.AddDays(-1.0);
ret = this.AdvanceToNextDayOpen(ret);
while (!this.IsTradeableDayServerTime(ret)) {
ret = ret.AddDays(-1.0);
}
break;
case BarScale.Yearly:
ret = new DateTime(ret.Year + 1, 12, 31);
ret = this.AdvanceToNextDayOpen(ret);
while (!this.IsTradeableDayServerTime(ret)) {
ret = ret.AddDays(-1.0);
}
break;
}
return ret;
}
public BarScaleIntervalEventArgs(BarScaleInterval barScaleInterval)
{
this.BarScaleInterval = barScaleInterval.Clone();
}
