public ExecutionContext(ISession session, IWorkingMemory workingMemory, IAgenda agenda, IEventAggregator eventAggregator)
{
Session = session;
WorkingMemory = workingMemory;
Agenda = agenda;
EventAggregator = eventAggregator;
}
public ExecutionContext(ISession session, IWorkingMemory workingMemory, IAgenda agenda, IEventAggregator eventAggregator)
{
Session = session;
WorkingMemory = workingMemory;
Agenda = agenda;
EventAggregator = eventAggregator;
}
/// <summary>
///
/// </summary>
/// <param name="commandContext"></param>
/// <param name="execution"></param>
public AbstractOperation(ICommandContext commandContext, IExecutionEntity execution, object signalData) : this()
{
this.commandContext = commandContext;
this.execution = execution;
this.agenda = commandContext.Agenda;
SignalData = signalData;
}
/**
* Adds an agenda to the container.
*
* @param string id
* The agenda's ID.
* @param Wem.Agenda.IAgenda agenda
* The agenda to be added.
*/
public void Add(string id, IAgenda agenda)
{
if (!container.ContainsKey(id))
{
container.Add(id, agenda);
}
}
internal Session(INetwork network, IAgenda agenda, IWorkingMemory workingMemory, IEventAggregator eventAggregator)
{
_network = network;
_workingMemory = workingMemory;
_agenda = agenda;
_eventAggregator = eventAggregator;
_executionContext = new ExecutionContext(this, _workingMemory, _agenda, _eventAggregator);
_network.Activate(_executionContext);
}
public static IRealTimeProbe CreateRealTimeProbe(IAgenda agenda,
IWire wire)
{
WindsorContainer container = GetWindsorContainerFromContext();
var factory = container.Resolve <IRealTimeProbeFactory>();
IRealTimeProbe probe = factory.Create(agenda,
wire);
return(probe);
}
/**
* Gets an activity from the container by string id.
*
* @param string id
* The activity's ID in the form agenda::activity.
*/
public IActivity GetActivity(string id)
{
string[] parts = id.Split(new[] { "::" }, StringSplitOptions.None);
string agenda_name = parts[0];
string activity_name = parts[1];
// Gets the activity.
IAgenda agenda = Get(agenda_name);
IActivity activity = agenda.GetActivity(activity_name);
return(activity);
}
public void GivenProbeOnWire([NotNull] string probeName,
[NotNull] string agendaName,
[NotNull] string wireName)
{
IAgenda agenda = GetAgendaFromContext(agendaName);
IWire wire = GetWireFromContext(wireName);
IRealTimeProbe probe = CreateRealTimeProbe(agenda,
wire);
ScenarioContext.Current [probeName] = probe;
}
protected BaseRealTimeLogicGate([NotNull] IDisposer disposer,
[NotNull] IAgenda agenda,
[NotNull] IEnumerable <IWire> wiresIn,
[NotNull] IEnumerable <IWire> wiresOut)
{
m_Disposer = disposer;
m_Agenda = agenda;
Inputs = wiresIn;
Outputs = wiresOut;
SignalChangedHandlersSubscribe();
m_Disposer.AddResource(SignalChangedHandlersUnsubscribe);
}
public static IRealTimeInverter CreateRealTimeInverter(IAgenda agenda,
IWire input,
IWire output)
{
WindsorContainer container = GetWindsorContainerFromContext();
var factory = container.Resolve <IRealTimeInverterFactory>();
IRealTimeInverter inverter = factory.Create(agenda,
input,
output);
return(inverter);
}
public static IRealTimeOr CreateRealTimeOr([NotNull] IAgenda agenda,
[NotNull] IWire inputOne,
[NotNull] IWire inputTwo,
[NotNull] IWire output)
{
WindsorContainer container = GetWindsorContainerFromContext();
var factory = container.Resolve <IRealTimeOrFactory>();
IRealTimeOr or = factory.Create(agenda,
inputOne,
inputTwo,
output);
return(or);
}
public void GivenInverterUsingAgendaWithInputAndIOutput([NotNull] string inverterName,
[NotNull] string agendaName,
[NotNull] string wireInputName,
[NotNull] string wireOutputName)
{
IAgenda agenda = GetAgendaFromContext(agendaName);
IWire input = GetWireFromContext(wireInputName);
IWire output = GetWireFromContext(wireOutputName);
IRealTimeInverter inverter = CreateRealTimeInverter(agenda,
input,
output);
ScenarioContext.Current [inverterName] = inverter;
}
public TestLogicGate([NotNull] IDisposer disposer,
[NotNull] IAgenda agenda,
[NotNull] IWire wireIn,
[NotNull] IWire wireOut)
: base(disposer,
agenda,
new[]
{
wireIn
},
new[]
{
wireOut
})
{
}
public RealTimeProbe([NotNull] IDisposer disposer,
[NotNull] IAgenda agenda,
[NotNull] IWire wire,
[NotNull] IProbeFactory factory)
: base(disposer,
agenda,
new[]
{
wire
},
new[]
{
wire
})
{
m_Probe = factory.Create(wire);
}
/**
* Initializes a list of agendas.
*
* @param List<string> files
* List of paths to YAML files.
*/
public void Initialize(List <string> files)
{
List <DeserializedAgenda> agendas = this.deserializer.Deserialize(files);
foreach (DeserializedAgenda agenda_data in agendas)
{
// Starts a new Agenda.
this.generator.Start(agenda_data.Id);
IAgenda agenda = this.initializeAgenda(agenda_data);
// Saves the generated agenda in the container.
this.container.Add(agenda_data.Id, agenda);
}
this.associateArea();
}
public void GivenOrUsingAgendaWithInputOneAndInputTwoAndOutput([NotNull] string orName,
[NotNull] string agendaName,
[NotNull] string wireInputOneName,
[NotNull] string wireInputTwoName,
[NotNull] string wireOutputName)
{
IAgenda agenda = GetAgendaFromContext(agendaName);
IWire inputOne = GetWireFromContext(wireInputOneName);
IWire inputTwo = GetWireFromContext(wireInputTwoName);
IWire output = GetWireFromContext(wireOutputName);
IRealTimeOr or = CreateRealTimeOr(agenda,
inputOne,
inputTwo,
output);
ScenarioContext.Current [orName] = or;
}
public RealTimeInverter([NotNull] IDisposer disposer,
[NotNull] IAgenda agenda,
[NotNull] IInverterFactory factory,
[NotNull] IWire wireIn,
[NotNull] IWire wireOut)
: base(disposer,
agenda,
new[]
{
wireIn
},
new[]
{
wireOut
})
{
m_Inverter = factory.Create(wireIn,
wireOut);
}
public RealTimeOr([NotNull] IDisposer disposer,
[NotNull] IAgenda agenda,
[NotNull] IOrFactory factory,
[NotNull] IWire wireInOne,
[NotNull] IWire wireInTwo,
[NotNull] IWire wireOut)
: base(disposer,
agenda,
new[]
{
wireInOne,
wireInTwo
},
new[]
{
wireOut
})
{
m_Or = factory.Create(wireInOne,
wireInTwo,
wireOut);
}
public static Company.IEmployee GetMeetingSecretary(IAgenda agenda)
{
return(agenda.Meeting == null ? null : agenda.Meeting.Secretary);
}
public void Add(IAgenda agenda)
{
_context.Add(agenda);
}
public ExecutionContext(IWorkingMemory workingMemory, IAgenda agenda, IEventAggregator eventAggregator)
{
WorkingMemory = workingMemory;
Agenda = agenda;
EventAggregator = eventAggregator;
}
public void WhenAgendaAgendaOneIsProcessed(string name)
{
IAgenda agenda = GetAgendaFromContext(name);
agenda.Run();
}
public void Add(IAgenda agenda)
{
throw new NotImplementedException();
}
public static string GetMeetingTime(IAgenda agenda)
{
return(agenda.Meeting == null ? null : Functions.Meeting.GetMeetingTimeAsString(agenda.Meeting));
}
public static DateTime?GetMeetingDate(IAgenda agenda)
{
return(agenda.Meeting == null ? null : agenda.Meeting.DateTime);
}
public static string GetMeetingMembersWithJobTitle(IAgenda agenda)
{
return(agenda.Meeting == null ? null : PublicFunctions.Meeting.Remote.GetMeetingMembersString(agenda.Meeting, true, true));
}
public static T ConvertTo <T>(this IAgenda agenda) where T : IAgenda, new()
=> new T
{
Descricao = agenda.Descricao,
Titulo = agenda.Titulo
};
public ExecutionContext(IWorkingMemory workingMemory, IAgenda agenda, IEventAggregator eventAggregator)
{
WorkingMemory = workingMemory;
Agenda = agenda;
EventAggregator = eventAggregator;
}
public static Company.IEmployee GetMeetingPresident(IAgenda agenda)
{
return(agenda.Meeting == null ? null : agenda.Meeting.President);
}
public static string GetMeetingLocation(IAgenda agenda)
{
return(agenda.Meeting == null ? null : agenda.Meeting.Location);
}
public static string GetMeetingName(IAgenda agenda)
{
return(agenda.Meeting == null ? null : agenda.Meeting.Name);
}
public AgendaController(IAgenda agenda, IEstudio estudio, ICliente cliente)
{
_agenda = agenda;
_estudio = estudio;
_cliente = cliente;
}
