protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui)
{
base.SetupInitialize(myEngineHub, engineContainer, engineID, setupGui);
m_Hub = (Hub)myEngineHub;
this.m_Log = m_Hub.Log; // set up our logging
this.m_ExecutionContainer = (ExecutionContainer)engineContainer;
}
//
//
// ******************************************************
// **** Setup Initialize() ****
// ******************************************************
/// <summary>
/// Since we are a specialized gui manager, we override SetupInitialize()
/// and don't create a default popup gui.
/// </summary>
/// <param name="myEngineHub"></param>
/// <param name="engineContainer"></param>
/// <param name="engineID"></param>
/// <param name="isSetupGui"></param>
protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool isSetupGui)
{
base.SetupInitialize(myEngineHub, engineContainer, engineID, false);// call base class first.
m_Parent = (Strategy)engineContainer;
m_ParentEngineContainerID = engineContainer.EngineContainerID;
Log = m_Parent.StrategyHub.Log;
// Set the plotting hour offset.
m_StartTime = m_Parent.StrategyHub.GetLocalTime();
m_StartHour = m_StartTime.Hour + m_StartTime.Minute / 60.0 + m_StartTime.Second / 3600.0;
if (m_StartHour >= 16.0)
{
m_StartHour -= 24.0; // after 4pm, shift to negative numbers (new trading day).
}
//
// Add our custom ZGraphControl template
//
UV.Lib.FrontEnds.GuiTemplates.EngineGui engineGui = new Lib.FrontEnds.GuiTemplates.EngineGui();
engineGui.DisplayName = "Graph";
engineGui.EngineID = this.m_EngineID;
engineGui.EngineFullName = this.GetType().FullName;
engineGui.HeaderControlFullName = typeof(UV.Lib.FrontEnds.Graphs.ZGraphControl).FullName;
engineGui.ParameterList.AddRange(this.m_PInfo);
m_EngineGuis.Add(engineGui);
}//SetupInitialize()
//
// *****************************************
// **** Setup Begin() ****
// *****************************************
/// <summary>
/// This is called after all Engines have been created, and added to the master
/// list inside the Strategy (IEngineContainer).
/// As a convenience, the PricingEngine class locates useful Engines and keeps
/// pointers to them.
/// </summary>
/// <param name="myEngineHub"></param>
/// <param name="engineContainer"></param>
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
base.SetupBegin(myEngineHub, engineContainer);
// Locate engines we need.
m_MarketSubscribers = new List <IMarketSubscriber>();
foreach (IEngine iEngine in engineContainer.GetEngines())
{
if (iEngine is ZGraphEngine)
{
m_GraphEngine = (ZGraphEngine)iEngine; // PricingEngines also plot a lot.
}
else if (iEngine is IMarketSubscriber)
{
m_MarketSubscribers.Add((IMarketSubscriber)iEngine);
}
}
//
// Subscribe to Pricing instruments.
//
List <InstrumentName> instruments = new List <InstrumentName>();
foreach (PriceLeg leg in m_Legs) // Subscribe to each "PricingLeg" object.
{
instruments.Add(leg.InstrumentName);
}
this.ParentStrategy.StrategyHub.SubscribeToMarketInstruments(instruments, this.ParentStrategy);
}//SetupBegin()
//
//
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
if (ParentStrategy != null)
{
m_QuoteTickSize = ParentStrategy.m_OrderEngine.QuoteTickSize;
}
}
//
//
// **** Setup Begin() ****
//
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
base.SetupBegin(myEngineHub, engineContainer);
m_Name = base.EngineName;
m_Parent = (Strategy)engineContainer;
this.Log = ((StrategyHub)myEngineHub).Log;
}//SetupBegin()
//
//
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
base.SetupBegin(myEngineHub, engineContainer);
foreach (IEngine ieng in engineContainer.GetEngines())
{ // Find order Engine
if (ieng is IOrderEngine)
{
this.m_IOrderEngine = (IOrderEngine)ieng; // find our order engine
}
}
if (m_IOrderEngine is SingleLegExecutor)
{ // if this is a single leg order engine
m_SingleLegExecutor = (SingleLegExecutor)m_IOrderEngine;
this.m_Leg = m_SingleLegExecutor.m_PriceLeg;
m_MaxPossibleWorkingQuoteQtyPerLot += (int)(Math.Abs(m_Leg.Weight) * 2); // leg ratios * 2 (each side)
}
// If we subscribe to order book creation, we can be sure to get all the info for all fills and submissions
// this only works if create order books after setup beging.
m_IOrderEngine.GetExecutionListener().OrderBookCreated += new EventHandler(ExecutionListener_OrderBookCreated);
if (m_Hub is ExecutionHub)
{ // set up ITimer to work
((ExecutionHub)m_Hub).SubscribeToTimer((ITimerSubscriber)m_ExecutionContainer.m_ExecutionListener);
m_ExecutionContainer.m_ExecutionListener.SubscribeToTimer(this); // subscrie to updates
}
}
//
//
// **** SetupBegin() ****
//
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
base.SetupBegin(myEngineHub, engineContainer);
m_Parent = (Strategy)engineContainer;
Log = ((Hub)myEngineHub).Log;
// Get Engines of interest.
int modelCounter = 0;
foreach (IEngine ieng in m_Parent.GetEngines())
{
if (ieng is ZGraphEngine)
{
if (m_GraphEngine == null)
{
m_GraphEngine = (ZGraphEngine)ieng; // take first found graph engine to draw to.
}
}
else if (ieng is ModelEngine)
{
if (ieng == this)
{
m_ModelEngineID = modelCounter;
} // store the number of models in front of me (use as my id!)
modelCounter++;
}
}
}//SetupBegin()
protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui)
{
base.SetupInitialize(myEngineHub, engineContainer, engineID, setupGui);
m_StrategyHub = (StrategyHub)myEngineHub;
this.m_Log = m_StrategyHub.Log; // set up our logging
this.m_Market = m_StrategyHub.m_Market; // grab the market so we can have some instrument details
}
//
//
protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui)
{
base.SetupInitialize(myEngineHub, engineContainer, engineID, setupGui);
ExecutionContainer execContainer = (ExecutionContainer)engineContainer;
execContainer.TryAddEngine(m_Hedger); // add my sub engines to the container.
execContainer.TryAddEngine(m_HedgeRuleManager);
}
}//SetupInitialize()
//
//
// *************************************************
// **** SetupBegin() ****
// *************************************************
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
base.SetupBegin(myEngineHub, engineContainer);
// ParentStrategy.StrategyHub.SubscribeToTimer(ParentStrategy, this);
// ParentStrategy.m_OrderEngine.QuoteTickSize = m_QuoteTickSize; // set our quote tick size for proper rounding
}
//
// *****************************************
// **** Setup Initialize() ****
// *****************************************
protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui)
{
base.SetupInitialize(myEngineHub, engineContainer, engineID, setupGui);
//
// Keep pointers to important objects.
//
this.ParentStrategy = (Strategy)engineContainer;
this.Log = ((Hub)myEngineHub).Log; // Pricing engines tend to log a lot, so keep a pointer.
}
//
//
public void BroadcastParameter(IEngineHub hub, IEngineContainer parent, string parameterName)
{
int id = GetParameterId(parameterName);
if (id > -1)
{
BroadcastParameter(hub, parent, id);
}
}
//
//
//
// *****************************************************************
// **** Initialize MultiPanel() ****
// *****************************************************************
private void InitializeMultiPanel(IEngineContainer parentContainer, EngineContainerGui guiContainer)
{
m_EngineContainerID = parentContainer.EngineContainerID;
// Try to create any hudpanels discovered
List <HudPanel> newHudPanels = new List <HudPanel>();
foreach (EngineGui engineGui in guiContainer.m_Engines)
{
if (string.IsNullOrEmpty(engineGui.LowerHudFullName))
{
continue;
}
Control newControl = null;
Type guiType = typeof(EngineControl);
if (Stringifiable.TryGetType(engineGui.LowerHudFullName, out guiType)) // Check whether this control is known to us!
{
if (Utilities.GuiCreator.TryCreateControl(out newControl, guiType, engineGui))
{ // We have successfully created the desired control.
if (newControl is HudPanel)
{
newHudPanels.Add((HudPanel)newControl);
}
}
}
}
int maxX = 0;
int maxY = 0;
this.SuspendLayout();
foreach (HudPanel control in newHudPanels)
{
if (control != null) // each engine has entry here, even if its null. (but why?)
{
m_EngineControlList.Add(control.EngineId, control);
control.Size = control.SmallestSize; // force panel to be smallest size possible.
control.Location = new Point(m_NextPanelXLoc, m_NextPanelYLoc);
// update layout control parameters.
m_NextPanelXLoc += control.Size.Width;
maxX = Math.Max(maxX, control.Location.X + control.Width);
maxY = Math.Max(maxY, control.Location.Y + control.Height);
this.Controls.Add(control);
}
}//next engine
// Resize myself.
this.ClientSize = new Size(maxX, maxY); // make this as small as possible, Cluster will resize again.
if (m_EngineControlList.Count == 0)
{
this.Visible = false;
}
this.ResumeLayout(false);
}//InitializeMultiPanel()
}// GetParameterValue()
//
//
//
//
//
// **** Get Event For Parameter Values ****
//
/// <summary>
/// This method allows an outsider to ask the Engine to automatically create
/// the appropriate EngineEventArg that can be used to have it broadcast its
/// current parameter values.
/// This is useful when the Engine's parameters have been changed internally
/// by some method, orther than the usual EngineEventArg parameter Change request,
/// which will usually produce a response event automatically anyway.
/// For example, use this when an engine parameter spontaneously changes (from
/// a market event, or fill, or by the action of a model) to send the new parameter
/// values to all GUIs, even though no one requested one.
/// </summary>
public virtual EngineEventArgs GetEventForParameterValues(IEngineContainer parent)
{
EngineEventArgs newEvent = new EngineEventArgs();
newEvent.MsgType = EngineEventArgs.EventType.ParameterValue;
newEvent.Status = EngineEventArgs.EventStatus.Request;
newEvent.EngineContainerID = parent.EngineContainerID;
newEvent.EngineID = this.EngineID;
return(newEvent);
}// GetEventForParameterValues();
//
// *****************************************
// **** Setup Initialize() ****
// *****************************************
protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui)
{
base.SetupInitialize(myEngineHub, engineContainer, engineID, setupGui);
// Keep pointers to important objects.
this.ParentStrategy = (Strategy)engineContainer;
// TODO: Locate the Alarm service.
}
//
//
// ************************************************
// **** SetupInitialize() ****
// ************************************************
/// <summary>
/// This is called immediately after construction, when we add this engine to its strategy.
/// During this call the Parameter tables *must* be created, and all *Gui Templates* must be
/// created.
/// If an Engine wants to create additional Engines, it should be done here. Since *after*
/// this initialize call (that is, during the SetupBegin() call), Engines can assume that all
/// other Engines have been created and added to the EngineList of the WStrategy.
/// The short explanation:
/// Setup Initialize: Strategy, StrategyHub and other ApplicationServices exist.
/// Setup Begin: All Engines within my Strategy exist, and were SetupInitialize().
/// Setup Complete: All Engines in all Strategies exist and were SetUpBegin().
/// Note:
/// 1) At this point, the Strategy has been created, but possibly no others.
/// 2) The other engines in the Strategy may also not be created at this point.
/// * Therefore, Engines should not look for other Strategies of other Engines.
/// 3) Subclasses should call this base-class method FIRST (so engineID is set) before other implementations.
/// </summary>
public void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID)
{
if (engineID >= 0) // If engineID provide is positive, then
{
m_EngineID = engineID; // accept ID provided by my parent Strategy. Otherwise leave it alone.
}
// This is useful when its assigned at construction time already.
m_Parent = engineContainer;
SetupInitialize(myEngineHub, engineContainer, engineID, true); // default is to creaet the default Gui templates.
}// SetupInitialize()
//
//
//
//
protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui)
{
base.SetupInitialize(myEngineHub, engineContainer, engineID, setupGui);
// Request historic data for plots.
DateTime end = ParentStrategy.StrategyHub.GetLocalTime();
DateTime start = end.AddHours(-m_NHoursHistoricData); // TODO: allow this to passed in as istringifiable param?
base.RequestHistoricData(start, end);
m_IEngineHub = myEngineHub;
}
//
// *********************************************
// **** SetUp Initialize() ****
// *********************************************
/// <summary>
/// </summary>
protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui)
{
// Save information about local strategy hub.
m_EngineContainerId = engineContainer.EngineContainerID;
if (myEngineHub is IService)
{
m_LocalEngineHubName = ((IService)myEngineHub).ServiceName;
}
StrategyHub strategyHub = ((StrategyHub)myEngineHub);
this.Log = strategyHub.Log;
m_LocalEngineHub = myEngineHub;
// Locate our target remote hub/service.
IEngineHub remoteEngineHub = null;
EventHandler del = new EventHandler(ProcessRemoteEngineEvents);
if (strategyHub.SubscribeToRemoteEngineHub("ExecutionHub", m_EngineContainerId, m_EngineID, del, out remoteEngineHub))
{
m_RemoteEngineHub = remoteEngineHub;
}
else
{
throw new Exception("Failed to locate remote hub.");
}
// Create the parameter table.
Type remoteEngineType;
if (Stringifiable.TryGetType(m_RemoteEngineClassName, out remoteEngineType))
{
this.m_PInfo = CreateParameterInfo(myEngineHub, engineContainer.EngineContainerID, this.EngineID, remoteEngineType);
}
//
// Add sub-engines to the parent Strategy
//
// They will be automatically initialized outside in StrategyHub loop
// that called us, since we will add new engine to the end of the list we are looping thru now.
List <IStringifiable> subElements = m_Node.GetElements();
if (subElements != null)
{
foreach (IStringifiable iObject in subElements)
{ // Engines that are beneath non-engines will not be found here.
if (iObject is ExecutionController) // This remote engine will not need to broad its existance,
{
ExecutionController subEngine = (ExecutionController)iObject;
subEngine.m_IsSubEngine = true; // since it will be included in another engine (this one).
((Strategy)engineContainer).TryAddEngine(subEngine, myEngineHub);
}
}
}
}//SetupInitialize()
//
//
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
base.SetupBegin(myEngineHub, engineContainer);
if (myEngineHub is ExecutionHub)
{ // set up ITimer to work
ThreadContainer execContainer = (ThreadContainer)engineContainer;
((ExecutionHub)myEngineHub).SubscribeToTimer((ITimerSubscriber)execContainer.m_ExecutionListener);
execContainer.m_ExecutionListener.SubscribeToTimer(this); // subscribe to updates
}
}
//
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
base.SetupBegin(myEngineHub, engineContainer);
foreach (IEngine eng in engineContainer.GetEngines())
{
if (eng is IOrderEngine)
{ // find our orer engine and our execution listner
m_ExecutionListener = ((IOrderEngine)eng).GetExecutionListener();
continue;
}
}
}
//
// *****************************************
// **** Setup Initialize() ****
// *****************************************
protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui)
{
base.SetupInitialize(myEngineHub, engineContainer, engineID, false);
EngineGui engineGui = base.SetupGuiTemplates();
if (engineContainer is Strategy)
{
ParentStrategy = (Strategy)engineContainer;
Log = ParentStrategy.StrategyHub.Log;
}
m_Services = AppServices.GetInstance();
}
private Dictionary <int, int> m_OppositeOrderIDToIPrice = new Dictionary <int, int>(); // map order ids to IPrice we want to scratch
#endregion // members
#region Constructors
// *****************************************************************
// **** Constructors ****
// *****************************************************************
//
protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui)
{
this.m_EngineName = string.Format("Scratcher:{0}", m_PriceLeg.InstrumentName);
if (typeof(UV.Strategies.ExecutionHubs.ExecutionContainers.MultiThreadContainer).IsAssignableFrom(engineContainer.GetType()))
{ // this is the "first" set up call from the manager container.
base.SetupInitialize(myEngineHub, engineContainer, engineID, setupGui);
m_Log = ((ExecutionHubs.ExecutionHub)myEngineHub).Log; // keep pointer to log
}
else
{ // this is the second set up call from the correct container, add correct sub engine mappings
}
}
private OrderEventArgs m_OrderEventArg; // careful, but this is always recycled
#endregion // members
#region Constructors
// *****************************************************************
// **** Constructors ****
// *****************************************************************
//
//
protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui)
{
if (typeof(UV.Strategies.ExecutionHubs.ExecutionContainers.MultiThreadContainer).IsAssignableFrom(engineContainer.GetType()))
{ // this is the "first" set up call from the manager container.
base.SetupInitialize(myEngineHub, engineContainer, engineID, setupGui);
m_Log = ((ExecutionHubs.ExecutionHub)myEngineHub).Log;
}
else
{ // this is the second set up call from the correct container, add correct sub engine mappings
m_ExecutionContainer = (ThreadContainer)engineContainer;
}
}
//
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
base.SetupBegin(myEngineHub, engineContainer);
m_Log = ((ExecutionHub)myEngineHub).Log;
foreach (IEngine iEng in engineContainer.GetEngines())
{// find our needed engine pointers
if (iEng is ExecutionEngines.OrderEngines.Spreader)
{
m_Quoter = (ExecutionEngines.OrderEngines.Spreader)iEng;
}
}
}
}//SetupInitialize()
//
//
//
//
// ************************************************
// **** SetupBegin() ****
// ************************************************
/// <summary>
/// </summary>
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
//
// Master Remote-Engines must send requests to ExecutionHub now.
//
if (m_IsSubEngine == false)
{
// Count number of (master) remote engines found in this strategy.
// Master remote engines are those connected directly to the Strategy,
// without being held by another engine.
// Only masters broadcast their xml to the ExecutionHub, and other sub-engine
// engines are included as subelements of their master's broadcast.
// (If each remote engine broadcasted separately, the ExecHub would have to know how
// to put them all back together again... that is, who owned whom.)
int remoteMasterEngineCount = 0;
foreach (IEngine iEng in engineContainer.GetEngines())
{
if (iEng is ExecutionController && ((ExecutionController)iEng).m_IsSubEngine == false)
{
remoteMasterEngineCount++;
}
//if (iEng is RemoteEngine) // now count all remote engines
// remoteMasterEngineCount++;
}
//
// Create my engine creation request
//
Dictionary <Type, string[]> rules = new Dictionary <Type, string[]>();
rules.Add(this.GetType(), new string[] { "GetClassName", string.Empty, string.Empty });
string xmlString = Stringifiable.Stringify(this, rules);
EngineEventArgs e = new EngineEventArgs();
e.MsgType = EngineEventArgs.EventType.NewEngine;
e.Status = EngineEventArgs.EventStatus.Request;
e.EngineID = m_EngineID;
e.EngineContainerID = m_EngineContainerId;
e.DataObjectList = new List <object>();
e.DataObjectList.Add(xmlString); // 0 - engine specs
e.DataObjectList.Add(m_LocalEngineHubName); // 1 - engine hub name
e.DataObjectList.Add(remoteMasterEngineCount.ToString()); // 2 - number of engines remote hub should expect from this EngineContainer
// Send request to remote.
if (m_RemoteEngineHub != null && m_RemoteEngineHub.HubEventEnqueue(e))
{
Log.NewEntry(LogLevel.Minor, "SetupBegin: Remote-{0} sent creation request to remote.", m_RemoteEngineClassName);
}
else
{
Log.NewEntry(LogLevel.Minor, "SetupBegin: Remote-{0} failed to send creation request to remote.", m_RemoteEngineClassName);
}
} // master remote-engine sends request.
} //SetupBegin()
//
// *************************************************************
// **** Setup Initialize() ****
// *************************************************************
/// <summary>
/// Since I depend critically on an OrderBookHub, I will look for them now.
/// </summary>
/// <param name="myEngineHub"></param>
/// <param name="engineContainer"></param>
/// <param name="engineID"></param>
/// <param name="setupGui"></param>
protected override void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui)
{
base.SetupInitialize(myEngineHub, engineContainer, engineID, false);
EngineGui engineGui = base.SetupGuiTemplates();
engineGui.LowerHudFullName = typeof(OrderEngineHud).FullName;
// Collect services that I need.
m_Hub = (Hub)myEngineHub;
this.Log = m_Hub.Log;
m_ExecutionContainer = (ThreadContainer)engineContainer;
}// SetupInitialize()
}// SetupInitialize()
//
//
/// <summary>
/// This should be overridden if the user does NOT want the default Gui Template.
/// 1.) SetupGui = false will skip construction of the basic Engine Gui Template.
/// </summary>
protected virtual void SetupInitialize(IEngineHub myEngineHub, IEngineContainer engineContainer, int engineID, bool setupGui)
{
SetupParameterInfoTable(myEngineHub, engineContainer); // Create table for all parameters
if (setupGui)
{
SetupGuiTemplates();
}
if (myEngineHub is Hubs.Hub)
{ // this is a real hub, and should have a log, which we want to use
m_Log = ((Hubs.Hub)myEngineHub).Log;
}
}//SetupInitialize()
}// SetupInitialize()
//
//
// *************************************************
// **** SetupBegin() ****
// *************************************************
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
//EngineEventArgs e = EngineEventArgs.RequestAllParameters(m_ExecutionHubName, m_Strategy.EngineContainerID, -1);
//SyntheticOrder synth = new SyntheticOrder(e);
for (int i = 0; i < 2; i++)
{ // set up event args to reuse.
m_EngineEventArgsForOrders[i] = new EngineEventArgs();
m_EngineEventArgsForOrders[i].EngineHubName = m_ExecutionHubName;
m_EngineEventArgsForOrders[i].EngineContainerID = m_Strategy.EngineContainerID;
m_EngineEventArgsForOrders[i].MsgType = EngineEventArgs.EventType.SyntheticOrder;
m_EngineEventArgsForOrders[i].Status = EngineEventArgs.EventStatus.Request;
m_EngineEventArgsForOrders[i].DataObjectList = new List <object>();
}
}// SetupBegin()
} // GetEventForParameterValues();
//
//
/// <summary>
/// This method allows an engine to broadcast all of his own parameters even if not
/// requested by the user. This is useful when the engine changed its parameters automatically,
/// and now wants to ensure the user knows about it.
/// </summary>
/// <param name="hub"></param>
/// <param name="parent"></param>
public void BroadcastAllParameters(IEngineHub hub, IEngineContainer parent)
{
EngineEventArgs eArgs = new EngineEventArgs();
eArgs.MsgType = EngineEventArgs.EventType.ParameterValue;
eArgs.Status = EngineEventArgs.EventStatus.Confirm;
eArgs.EngineHubName = hub.ServiceName;
eArgs.EngineContainerID = parent.EngineContainerID;
eArgs.EngineID = this.EngineID;
if (GetParameterValue(ref eArgs.DataIntA, ref eArgs.DataObjectList))
{
m_EventQueue.Add(eArgs);
}
} // BroadcastParameters()
}// SetupInitialize()
//
// *************************************************************
// **** Setup Begin() ****
// *************************************************************
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
base.SetupBegin(myEngineHub, engineContainer);
foreach (IEngine iEng in engineContainer.GetEngines())
{
if (iEng is Risk.RiskManager)
{
m_RiskManager = (Risk.RiskManager)iEng;
}
}
if (m_RiskManager == null)
{
throw new NotImplementedException("All Strategies Must Have a Risk Manager, Please Add One To Your User Config");
}
}//SetupBegin().