} //constructor
//
//
/*
* // defunct
* public Header(IEngineContainer container)
* {
* m_ParentCluster = container;
* InitializeComponent();
*
* // Initialize Header - unique in each Cluster, 1-to-1 with EngineContainer.
* this.txtName.Text = container.EngineContainerName;
* m_EngineContainerID = container.EngineContainerID;
*
* // Create controls (per engine) for this EngineContainer.
* this.SuspendLayout();
* List<IEngine> engineList = container.GetEngines();
* foreach (IEngine engine in engineList)
* {
* IEngineControl pControl = engine.GetControl(); // Get popup insert control for this engine.
* m_EngineControlList.Add((IEngine)pControl); // allow "null" if the engine lacks a control,
* if (pControl != null) // each engine has entry here, even if its null. (but why?)
* { // Create a popup control
* PopUp1 popup = new PopUps.PopUp1(this); // load any IPopUp object here!
* //popup.Title = string.Format("{0} {1}",container.EngineContainerName,engine.EngineName);
* popup.Title = string.Format("{0}", engine.EngineName);// Text on small, custom top blue bar.
* popup.Text = m_ParentCluster.EngineContainerName; // Text on the top of Window.
* popup.AddControl(pControl);
* int engineID = ((IEngine)pControl).EngineID;
* m_PopUpList.TryAdd(engineID,popup); // look up table for processing events.
* //Label button = CreateMenuButton(engine); // Create a button to get popup.
* }
* // new buttons
* comboBoxEngines.Items.Add(string.Format("{0}: {1}", engine.EngineID.ToString(), engine.EngineName));
* //comboBoxEngines.Items.Add(engine.EngineName);
*
* }//next engine
* this.ResumeLayout(false);
* }//constructor
*/
//
//
//
#endregion//Constructors
#region Public Methods
// *****************************************************************
// **** Public Methods ****
// *****************************************************************
//
//
// **** Process EngineEvent () ****
//
/// <summary>
/// Called from cluster to process engine events it received from StrategyHub.
/// </summary>
/// <param name="eArgs"></param>
public bool ProcessEngineEvent(EngineEventArgs eArgs)
{
bool regenerateNow = false;
List <string> popUpNames = null;
if (m_EngineIDToPopups.TryGetValue(eArgs.EngineID, out popUpNames))
{
foreach (string popUpName in popUpNames)
{
IPopUp popUp = m_PopupList[popUpName];
IEngine engineControl = (IEngine)popUp.CustomControl;
engineControl.ProcessEvent(eArgs);
//if (popUpName.Contains("Pricing"))
// regenerateNow = popUp.Visible || regenerateNow;
IsRegenerateRequired = IsRegenerateRequired || engineControl.IsUpdateRequired;
bool isEngineUpdateDesired = engineControl.IsUpdateRequired && popUp.Visible && (engineControl is FrontEnds.Graphs.ZGraphControl) == false;
//regenerateNow = engineControl.IsUpdateRequired || regenerateNow;
regenerateNow = isEngineUpdateDesired || regenerateNow;
//Form form = (Form)popUp;
//if (popUp.Visible && form.WindowState != FormWindowState.Minimized)
//{
// popUp.CustomControl.Regenerate(this, null);
//}
}
}
//IsRegenerateRequired = regenerateNow || IsRegenerateRequired;
return(regenerateNow);
}//ProcessEngineEvent()
public void OnBeginning(object sender, EngineEventArgs e)
{
//We don't start a transaction against the database here, since we may
//not always deal with commands working against the database. Thus we
//start our transactions lazily in the OnExecuting method whenever a
//create class command is found.
}
public void OnAborting(object sender, EngineEventArgs e)
{
IEngine engine = sender as IEngine;
ISchemaService schemaService = engine.GetService <ISchemaService>();
schemaService.Abort();
}
//
//
// **** Process Engine Event ****
//
/// <summary>
/// Implements IEngineContainer. This is called by my hub thread when it receives an
/// EngineEvent. The engine event will be passed to the correct engines.
/// </summary>
/// <param name="eventArgs"></param>
public bool ProcessEvent(EventArgs eventArgs)
{
bool regenerateNow = false;
if (eventArgs is EngineEventArgs)
{
EngineEventArgs eArgs = (EngineEventArgs)eventArgs;
EngineEventArgs.EventType eventType = eArgs.MsgType;
if (eventType == EngineEventArgs.EventType.ClusterUpdate)
{
RegenerateMemory(eArgs); // I intercept events for Cluster Updates!
}
else
{ // Other egine events, I will pass along to objects owned by this Cluster.
regenerateNow = m_Header.ProcessEngineEvent(eArgs) || regenerateNow; // Header holds all popup forms.
if (m_LowerControl != null) // Gui panels displayed below cluster.
{
regenerateNow = m_LowerControl.ProcessEngineEvent(eArgs) || regenerateNow;
}
}
}
return(regenerateNow);
}//ProcessEngineEvent
void OnType(object sender, EngineEventArgs e)
{
TypeDefinition type = (sender as TypeDefinition);
string nspace = type.Namespace;
// we keep track of namespaces per assemblies
AssemblyDefinition assembly = type.Module.Assembly;
HashSet <string> ns;
if (assemblies.TryGetValue(assembly, out ns))
{
ns.AddIfNew(nspace);
}
else
{
ns = new HashSet <string> ();
ns.Add(nspace);
assemblies.Add(assembly, ns);
}
// and types per namespaces
HashSet <TypeDefinition> td;
if (!namespaces.TryGetValue(nspace, out td))
{
td = new HashSet <TypeDefinition> ();
namespaces.Add(nspace, td);
}
td.Add(type);
}
//
//
//
#endregion//Public Methods
#region no Private Methods
// *****************************************************************
// **** Private Methods ****
// *****************************************************************
//
//
//
//
#endregion//Private Methods
#region Event Handlers
// *****************************************************************
// **** Event Handlers ****
// *****************************************************************
//
//
// **** textBox_KeyUp ****
//
/// <summary>
/// Handles when a user types into the textbox.
/// </summary>
private void textBox_KeyUp(object sender, KeyEventArgs e)
{
TextBox tb = (TextBox)sender; // sender of this event is text box
if (e.KeyCode == Keys.Enter)
{ // "enter key" was pressed!
// Generate a parameter change request for our associated engine.
string newValue = tb.Text;
//m_ParameterInfo.EngineHub.HubEventEnqueue(EngineEventArgs.RequestParameterChange(m_ParameterInfo, newValue));//, hubID));
m_RemoteEngineHub.HubEventEnqueue(EngineEventArgs.RequestParameterChange(m_ParameterInfo, newValue));//, hubID));
}
else if (e.KeyCode == Keys.Escape)
{ // "escape key"
tb.Text = m_Memory.ToString();
IsUserInputActive = false;
tb.ForeColor = TextColorDefault;
}
else
{ // the key pressed was NOT the enter key.
if (!IsUserInputActive)
{ // first time we started typing here.
// tb.Clear();
IsUserInputActive = true; // flag that user is typing.
tb.ForeColor = TextColorHiLite;
}
}
}//end textBox_KeyUp()
//
// *************************************************
// **** HubEventEnqueue ****
// *************************************************
/// <summary>
/// ClusterDisplay events are passed here by the FrontEndServer thread.
/// The calling thread can update the internal values of clusters, and popups,
/// but cannont directly update the Controls themselves.
/// </summary>
/// <param name="eventArgs"></param>
/// <returns></returns>
public bool HubEventEnqueue(EventArgs eventArgs)
{
bool regenerateNow = false;
if (eventArgs is EngineEventArgs)
{
EngineEventArgs e = (EngineEventArgs)eventArgs;
if (e.Status == EngineEventArgs.EventStatus.Confirm)
{ // I process only confirmed requests.
if (e.MsgType == EngineEventArgs.EventType.GetControls)
{ // TODO: new controls that appear spontaneously may be allowed later.
// Need to invoke the Control creator, then when we reeceive the call back,
// create a request to the FrontEndServer to add it to my list of Clusters
// in this display. Why so complicated? 1) The UI thread must create the form,
// add it to the diplay list of controls, and then the FrontEndServer thread must
// add the created control to our lists so it can receive event messages.
}
else
{ // Most Engine EventArgs are simply passed to the appropriate Cluster.
IEngineContainer cluster;
if (m_EngineContainerDict.TryGetValue(e.EngineContainerID, out cluster))
{
regenerateNow = cluster.ProcessEvent(eventArgs) || regenerateNow;
}
}
}
}
return(regenerateNow);
}
}//Filled()
#endregion//Private Methods
#region Event Handlers
// *****************************************************************
// **** Event Handlers ****
// *****************************************************************
//
//
//**************************************************
//***** Alarm Triggered ****
//**************************************************
/// <summary>
/// Called whenever our alarm is triggered on a specific time. Be careful with threading!
/// As long as we are only setting bool flags here this should be threadsafe
/// </summary>
/// <param name="eventArgs"></param>
public override void AlarmTriggered(EngineEventArgs engineEventArgs)
{
if (engineEventArgs.MsgType == EngineEventArgs.EventType.AlarmTriggered)
{
if (engineEventArgs.Status == EngineEventArgs.EventStatus.EconomicEventEnd)
{ // We are clear to trade
Log.NewEntry(LogLevel.Major, "AlarmTriggered: Economic event alarm message received to resume trading");
UpdateModelOrders();
BroadcastAllParameters(m_IEngineHub, ParentStrategy); // broadcast new state
}
else if (engineEventArgs.Status == EngineEventArgs.EventStatus.EconomicEventStart)
{ // We should stop trading for the number
Log.NewEntry(LogLevel.Major, "AlarmTriggered: Economic event alarm message received to stop trading");
foreach (object o in engineEventArgs.DataObjectList)
{
if (o.GetType() == typeof(EconomicDataItem))
{
EconomicDataItem economicData = (EconomicDataItem)o;
Log.NewEntry(LogLevel.Major, "EconomicEventName: {0} @ {1}", economicData.EventName, economicData.TimeStamp);
}
}
UpdateModelOrders();
BroadcastAllParameters(m_IEngineHub, ParentStrategy); // broadcast new state
}
else
{
Log.NewEntry(LogLevel.Major, "AlarmTriggered: Uknown Event Economic Event Type Received.");
}
}
}
//
//
// *********************************************************
// **** AddSpontaneousEngineEvents() ****
// *********************************************************
public override void AddSpontaneousEngineEvents(List <EngineEventArgs> eventList)
{
base.AddSpontaneousEngineEvents(eventList); // add any previously queued events to list.
// Add new x-y points to plot.
if (m_NewPoints.Count > 0)
{
EngineEventArgs eArgs = new EngineEventArgs();
eArgs.MsgType = EngineEventArgs.EventType.ParameterValue;
eArgs.Status = EngineEventArgs.EventStatus.Confirm;
eArgs.EngineHubName = m_Parent.StrategyHub.ServiceName; // name of my hub.
eArgs.EngineContainerID = m_ParentEngineContainerID; // this is my parent's Container ID.
eArgs.EngineID = this.EngineID; // this is my ID.
// load market data
if (eArgs.DataObjectList == null)
{
eArgs.DataObjectList = new List <object>();
}
// Add points to data list
if (m_NewPoints.Count > 0)
{
eArgs.DataObjectList.AddRange(m_NewPoints); // Load event
m_HistoricPoints.Points.AddRange(m_NewPoints); // update the historic list
m_NewPoints.Clear(); // clear the new points as processed.
}
// Exit
eventList.Add(eArgs);
}
// Add text
if (m_NewText.Count > 0)
{
EngineEventArgs eArgs = new EngineEventArgs();
eArgs.MsgType = EngineEventArgs.EventType.ParameterValue;
eArgs.Status = EngineEventArgs.EventStatus.Confirm;
eArgs.EngineHubName = m_Parent.StrategyHub.ServiceName; // name of my hub.
eArgs.EngineContainerID = m_ParentEngineContainerID; // this is my parent's Container ID.
eArgs.EngineID = this.EngineID; // this is my ID.
// load market data
if (eArgs.DataObjectList == null)
{
eArgs.DataObjectList = new List <object>();
}
// Add points to data list
if (m_NewText.Count > 0)
{
eArgs.DataObjectList.AddRange(m_NewText); // Load event
//m_HistoricText.Points.AddRange(m_NewText); // update the historic list
m_NewText.Clear(); // clear the new points as processed.
}
// Exit
eventList.Add(eArgs);
}
}//end AddSpontaneousEvents()
//
//
//
//
#endregion//Public Methods
#region Private Methods
// *****************************************************************
// **** Private Methods ****
// *****************************************************************
//
//
protected void ProcessRemoteEngineHubEvents(object sender, EventArgs eventArgs)
{
if (eventArgs is EngineEventArgs)
{
EngineEventArgs eventArg = (EngineEventArgs)eventArgs;
switch (eventArg.MsgType)
{
case EngineEventArgs.EventType.NewEngine:
ProcessNewEngine(eventArg);
break;
default:
if (eventArg.Status == EngineEventArgs.EventStatus.Confirm) // TODO: pass fails too?
{
EngineEventArgs outEventArg = new EngineEventArgs();
eventArg.CopyTo(outEventArg);
outEventArg.EngineHubName = m_LocalStrategyHub.HubName;
((StrategyHub)m_LocalStrategyHub).OnEngineChanged(outEventArg);
}
break;
}
}
else
{
m_LocalStrategyHub.Log.NewEntry(LogLevel.Error, "ProcessRemoteEvents: Unknown event {0}", eventArgs);
}
}//ProcessRemoteEngineHubEvents
} //ProcessConfirmMessage()
//
//
#endregion// Process Socket Events
#region Process Incoming Local Events
// *****************************************************************
// **** ProcessEngineEvent ****
// *****************************************************************
/// <summary>
/// These come from engine hub confirmations.
/// </summary>
/// <param name="eventArg"></param>
private void ProcessEngineEvent(EngineEventArgs eventArg)
{
EngineEventArgs.EventStatus eventStatus = eventArg.Status;
EngineEventArgs.EventType eventType = eventArg.MsgType;
string hubName = eventArg.EngineHubName;
// Process requests
if (eventStatus == EngineEventArgs.EventStatus.Request)
{ // Requests are targeting a specific engine hub.
foreach (KeyValuePair <int, ForeignServer> server in m_ServersConnected)
{
if (server.Value.Services.ContainsKey(hubName))
{
Message msg = GetMessage(MessageType.EngineEvent, MessageState.Confirmed, eventArg);
SendMessage(server.Key, msg);
}
}
}
else
{ // These are broadcasted
foreach (KeyValuePair <int, ForeignServer> server in m_ServersConnected)
{
// if the hubName is in hubs that this server is subscribed to, send along message.
Message msg = GetMessage(MessageType.EngineEvent, MessageState.Confirmed, eventArg);
SendMessage(server.Key, msg);
}
}
}//ProcessEngineEvent()
public void OnCommitting(object sender, EngineEventArgs e)
{
IEngine engine = sender as IEngine;
IDatabaseService databaseService = engine.GetService<IDatabaseService>();
databaseService.CommitEventualTransaction();
}
}// AddPoint
//
//
//
//
//
// **** AddSpontaneousEngineEvents() ****
//
public override void AddSpontaneousEngineEvents(List <EngineEventArgs> eventList)
{
base.AddSpontaneousEngineEvents(eventList); // add any previously queued events to list.
//
// Cluster Market update events.
//
if (m_NewPoints.Count > 0)
{
EngineEventArgs eArgs = new EngineEventArgs();
eArgs.MsgType = EngineEventArgs.EventType.ParameterValue;
eArgs.Status = EngineEventArgs.EventStatus.Confirm;
eArgs.EngineHubName = m_Parent.StrategyHub.ServiceName; // name of my hub.
eArgs.EngineContainerID = m_ParentEngineContainerID; // this is my parent's Container ID.
eArgs.EngineID = this.EngineID; // this is my ID.
// load market data
eArgs.DataObjectList = new List <object>();
foreach (object o in m_NewPoints)
{
eArgs.DataObjectList.Add(o);
}
m_HistoricPoints.AddRange(m_NewPoints); // update the historic list
m_NewPoints.Clear(); // clear the new points as processed.
// Exit
eventList.Add(eArgs);
}
}//end AddSpontaneousEvents()
private void InvokeEngineStateEvent(EngineEventArgs args)
{
if (this.EngineEvent != null)
{
this.EngineEvent(this, args);
}
}
// *****************************************************************
// **** Public Methods ****
// *****************************************************************
//
//
public override void ProcessEvent(EventArgs e)
{
base.ProcessEvent(e);
if (e is EngineEventArgs)
{
EngineEventArgs engineEventArg = (EngineEventArgs)e;
if (engineEventArg.MsgType == EngineEventArgs.EventType.SyntheticOrder)
{
SyntheticOrder syntheticOrder = (SyntheticOrder)engineEventArg.DataObjectList[0];
if (m_OpenSyntheticOrders[syntheticOrder.Side] == null)
{ // this is the first time we have seen this order
m_OpenSyntheticOrders[syntheticOrder.Side] = syntheticOrder;
Quote(syntheticOrder.Side, syntheticOrder.Price, syntheticOrder.Qty);
}
else
{ // we have seen this order before, check what do do...currently not implementing much
// todo: how to save, check what user is requesting to change, etc
m_OpenSyntheticOrders[syntheticOrder.Side].Qty = syntheticOrder.Qty;
m_OpenSyntheticOrders[syntheticOrder.Side].Price = syntheticOrder.Price;
m_OpenSyntheticOrders[syntheticOrder.Side].TradeReason = syntheticOrder.TradeReason;
Quote(syntheticOrder.Side, syntheticOrder.Price, syntheticOrder.Qty);
}
}
}
}
public void OnBeginning(object sender, EngineEventArgs e)
{
//We don't start a transaction against the database here, since we may
//not always deal with commands working against the database. Thus we
//start our transactions lazily in the OnExecuting method whenever a
//create class command is found.
}
public async void StartSimulator()
{
EngineEventArgs engineEventArgs = new EngineEventArgs("America!");
await new MessageDialog("made it inside the start method").ShowAsync();
carKey.StartTheEngine(engineEventArgs);
}
private void bParameter_Click(object sender, EventArgs e)
{
if (!IsBoolReadOnly)
{ // Assume that user wants to toggle the current result.
bool newValue = !(bool)m_Memory;
m_RemoteEngineHub.HubEventEnqueue(EngineEventArgs.RequestParameterChange(m_ParameterInfo, newValue));
}
}
//
//
#endregion//public methods
#region Public Methods
// *****************************************************************
// **** Public Methods ****
// *****************************************************************
//
//
private void checkBox_CheckedChanged(object sender, EventArgs e)
{
CheckBox tb = (CheckBox)sender;
bool newValue = !tb.Checked; // a user click is an attempt to toggle the state.
//
m_RemoteEngineHub.HubEventEnqueue(EngineEventArgs.RequestParameterChange(m_ParameterInfo, newValue));
}
public void OnAborting(object sender, EngineEventArgs e)
{
IEngine engine = sender as IEngine;
IObjectService objectService = engine.GetService<IObjectService>();
IDatabaseService databaseService = engine.GetService<IDatabaseService>();
objectService.Abort();
databaseService.AbortEventualTransaction();
}
}// ProcessTradeEventArg
//
//
// *****************************************************
// **** ProcessAlarmTriggered() ****
// *****************************************************
/// <summary>
/// Called by the strategy hub to keep alarms threadsafe before the engine
/// gets the call.
/// </summary>
/// <param name="engineEventArgs"></param>
public void ProcessAlarmTriggered(EngineEventArgs engineEventArgs)
{
foreach (PricingEngine pricingEngine in this.PricingEngines)
{
pricingEngine.AlarmTriggered(engineEventArgs);
}
UpdateQuotes();
}
}// TryAddEngine()
//
//
//
// *********************************************
// **** ConfirmStrategyLaunched() ****
// *********************************************
/// <summary>
/// Broadcast to RemoteEngineHub that this execution strategy is ready.
/// </summary>
public void ConfirmStrategyLaunched()
{
Log.NewEntry(LogLevel.Minor, "ExecutionContainer {1} #{0}. Confirming launch of {2} engines.", this.EngineContainerID, this.EngineContainerName, this.EngineList.Count);
foreach (Engine engine in this.EngineList.Values)
{
EngineEventArgs e = EngineEventArgs.ConfirmNewEngine(m_LocalEngineHub.ServiceName, this.EngineContainerID, engine);
this.RemoteEngineHub.HubEventEnqueue(e);
}
}
public void OnCommitting(object sender, EngineEventArgs e)
{
IEngine engine = sender as IEngine;
IObjectService objectService = engine.GetService <IObjectService>();
IDatabaseService databaseService = engine.GetService <IDatabaseService>();
objectService.Commit();
databaseService.CommitEventualTransaction();
}
void OnAssembly (object sender, EngineEventArgs e)
{
// we only need to check the custom attributes if [SuppressMessage] is referenced (note: won't work for mscorlib)
AssemblyDefinition assembly = (sender as AssemblyDefinition);
if (assembly.MainModule.HasTypeReference (SuppressMessage)) {
Controller.BuildingCustomAttributes += new EventHandler<EngineEventArgs> (OnCustomAttributes);
} else {
Controller.BuildingCustomAttributes -= new EventHandler<EngineEventArgs> (OnCustomAttributes);
}
}
void OnAssembly (object sender, EngineEventArgs e)
{
// we only need to check the custom attributes if [SuppressMessage] is referenced (note: won't work for mscorlib)
AssemblyDefinition assembly = (sender as AssemblyDefinition);
if (assembly.MainModule.AnyTypeReference ((TypeReference tr) => { return tr.IsNamed ("System.Diagnostics.CodeAnalysis", "SuppressMessageAttribute"); })) {
Controller.BuildingCustomAttributes += new EventHandler<EngineEventArgs> (OnCustomAttributes);
} else {
Controller.BuildingCustomAttributes -= new EventHandler<EngineEventArgs> (OnCustomAttributes);
}
}
}//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()
//
//
//
//
// **** Process EngineEvent () ****
//
/// <summary>
/// Called from cluster to process engine events.
/// </summary>
/// <param name="eArgs"></param>
public bool ProcessEngineEvent(EngineEventArgs eArgs)
{
bool regenerateNow = false;
HudPanel panel = null;
if (m_EngineControlList.TryGetValue(eArgs.EngineID, out panel))
{ // We have a panel for this EngineID!
regenerateNow = panel.ProcessEngineEvent(eArgs) || regenerateNow; // tell panel to examine event args.
//panel.Regenerate(this, null); // tell panel to repaint itself.
}
IsRegenerationRequired = regenerateNow;
return(regenerateNow);
}
}// TryGetParameter()
//
// *********************************************
// **** TrySetParameter() ****
// *********************************************
public bool TrySetParameter(string parameterName, object newValue)
{
int parameterId;
if (m_ParameterNameTable.TryGetValue(parameterName, out parameterId))
{
m_ParameterValueTable[parameterId] = newValue;
m_RemoteEngineHub.HubEventEnqueue(EngineEventArgs.RequestParameterChange(m_PInfo[parameterId], newValue));
return(true);
}
// Exit
return(false);
}// TryGetParameter()
void OnMethodBody (object sender, EngineEventArgs e)
{
MethodBody body = (sender as MethodBody);
MethodDefinition method = body.Method;
// some runners, like the wizard, can run this engine several times
// and, in this case, the result won't change
if (bitmasks.ContainsKey (method))
return;
OpCodeBitmask mask = new OpCodeBitmask ();
foreach (Instruction ins in body.Instructions) {
mask.Set (ins.OpCode.Code);
}
bitmasks.Add (method, mask);
}
void OnType (object sender, EngineEventArgs e)
{
TypeDefinition type = (sender as TypeDefinition);
string nspace = type.Namespace;
// we keep track of namespaces per assemblies
AssemblyDefinition assembly = type.Module.Assembly;
HashSet<string> ns;
if (assemblies.TryGetValue (assembly, out ns)) {
ns.AddIfNew (nspace);
} else {
ns = new HashSet<string> ();
ns.Add (nspace);
assemblies.Add (assembly, ns);
}
// and types per namespaces
HashSet<TypeDefinition> td;
if (!namespaces.TryGetValue (nspace, out td)) {
td = new HashSet<TypeDefinition> ();
namespaces.Add (nspace, td);
}
td.Add (type);
}
public void OnCommitting(object sender, EngineEventArgs e)
{
}
void OnCustomAttributes (object sender, EngineEventArgs e)
{
ICustomAttributeProvider cap = (sender as ICustomAttributeProvider);
if (!cap.HasCustomAttributes)
return;
Dictionary<string, HashSet<string>> targets = null;
// deal with Target only for global (asembly-level) attributes
bool global = (sender is AssemblyDefinition);
foreach (CustomAttribute ca in cap.CustomAttributes) {
if (ca.AttributeType.FullName != SuppressMessage)
continue;
var arguments = ca.ConstructorArguments;
string category = (string) arguments [0].Value;
string checkId = (string) arguments [1].Value;
if (String.IsNullOrEmpty (category) || String.IsNullOrEmpty (checkId))
continue;
IMetadataTokenProvider token = (sender as IMetadataTokenProvider);
string name = category + "." + checkId;
// map from FxCop - otherwise keep the Gendarme syntax
string mapped_name;
if (!mapper.TryGetValue (name, out mapped_name))
mapped_name = name;
// FIXME: Scope ? "member", "resource", "module", "type", "method", or "namespace"
string target = null;
if (global) {
CustomAttributeArgument targetArgument;
if (TryGetPropertyArgument (ca, "Target", out targetArgument))
target = (string) targetArgument.Value;
}
if (String.IsNullOrEmpty (target)) {
Controller.Runner.IgnoreList.Add (mapped_name, token);
// continue loop - [SuppressMessage] has AllowMultiple == true
continue;
}
// we do not want to look for each target individually since we do not know
// what they represent. Running the "big" loop one time is more than enough
HashSet<string> list = null;
if (targets == null)
targets = new Dictionary<string,HashSet<string>> ();
// inner types syntax fix
target = target.Replace ('+', '/');
// method/member syntax fix
target = target.Replace (".#", "::");
if (!targets.TryGetValue (target, out list)) {
list = new HashSet<string> ();
targets.Add (target, list);
}
list.AddIfNew (mapped_name);
}
if (targets != null)
Resolve (targets);
}
void OnCustomAttributes (object sender, EngineEventArgs e)
{
ICustomAttributeProvider cap = (sender as ICustomAttributeProvider);
if (!cap.HasCustomAttributes)
return;
// deal with Target only for global (asembly-level) attributes
bool global = (sender is AssemblyDefinition);
foreach (CustomAttribute ca in cap.CustomAttributes) {
if (!ca.HasConstructorArguments)
continue;
if (ca.AttributeType.FullName != SuppressMessage)
continue;
var arguments = ca.ConstructorArguments;
string category = (string) arguments [0].Value;
string checkId = (string) arguments [1].Value;
if (String.IsNullOrEmpty (category) || String.IsNullOrEmpty (checkId))
continue;
IMetadataTokenProvider token = (sender as IMetadataTokenProvider);
// map from FxCop - otherwise keep the Gendarme syntax
HashSet<string> mapped_names = null;
if (!mapper.TryGetValue (checkId, out mapped_names)) {
mapped_names = new HashSet<string> ();
mapped_names.Add (category + "." + checkId);
}
// FIXME: Scope ? "member", "resource", "module", "type", "method", or "namespace"
string target = global ? GetPropertyString (ca, "Target") : null;
if (String.IsNullOrEmpty (target)) {
IIgnoreList ignore = Controller.Runner.IgnoreList;
foreach (string name in mapped_names)
ignore.Add (name, token);
// continue loop - [SuppressMessage] has AllowMultiple == true
continue;
} else {
// we do not want to look for each target individually since we do not know
// what they represent. Running the "big" loop one time is more than enough
AddTargets (target, mapped_names);
}
}
ResolveTargets ();
}
public void OnCommitting(object sender, EngineEventArgs e)
{
IEngine engine = sender as IEngine;
ISchemaService schemaService = engine.GetService<ISchemaService>();
schemaService.Commit();
}
public void OnAborting(object sender, EngineEventArgs e)
{
}
public void OnBeginning(object sender, EngineEventArgs e)
{
}
