private void ApplyProcessors(ICommandMapping mapping)
{
foreach (Processor processor in _processors)
{
processor(mapping);
}
}
private void HandleCommandExecuteResult(object result, object command, ICommandMapping CommandMapping)
{
if (_handleResult != null)
{
_handleResult.Invoke(result, command, CommandMapping);
}
}
private void ExecuteNextCommand()
{
if (_injector.HasMapping <Action <IAsyncCommand, bool> >(AsyncCommandExecutedCallbackName))
{
_injector.Unmap <Action <IAsyncCommand, bool> >(AsyncCommandExecutedCallbackName);
}
while (!IsAborted && _commandMappingQueue.Count > 0)
{
ICommandMapping mapping = _commandMappingQueue.Dequeue();
if (mapping != null)
{
_injector.Map <Action <IAsyncCommand, bool> >(AsyncCommandExecutedCallbackName).ToValue((Action <IAsyncCommand, bool>)CommandExecutedCallback);
_commandExecutor.ExecuteCommand(mapping, _payload);
return;
}
}
if (IsAborted)
{
_commandMappingQueue.Clear();
_commandsAbortedCallback?.Invoke();
}
else if (_commandMappingQueue.Count == 0)
{
_commandsExecutedCallback?.Invoke();
}
}
/*============================================================================*/
/* Constructor */
/*============================================================================*/
public DirectCommandMapper(ICommandExecutor executor, ICommandMappingList mappings, Type commandClass)
{
_executor = executor;
_mappings = mappings;
_mapping = new CommandMapping(commandClass);
_mapping.SetFireOnce(true);
_mappings.AddMapping(_mapping);
}
private void DeleteMapping(ICommandMapping mapping)
{
_mappingsByCommand.Remove(mapping.CommandClass);
_mappings.Remove(mapping);
if (_logger != null)
{
_logger.Debug("{0} unmapped from {1}", new object[] { _trigger, mapping });
}
}
private void resultReporter(object result, object command, ICommandMapping mapping)
{
Dictionary <string, object> dict = new Dictionary <string, object> ();
dict.Add("result", result);
dict.Add("command", command);
dict.Add("mapping", mapping);
reported.Add(dict);
}
/*============================================================================*/
/* Private Functions */
/*============================================================================*/
private void StoreMapping(ICommandMapping mapping)
{
_mappingsByCommand [mapping.CommandClass] = mapping;
_mappings.Add(mapping);
if (_logger != null)
{
_logger.Debug("{0} mapped to {1}", new object[] { _trigger, mapping });
}
}
public void before()
{
logger = new Mock<ILogger> ();
trigger = new Mock<ICommandTrigger> ();
processors = new List<CommandMappingList.Processor>();
subject = new CommandMappingList(trigger.Object, processors, logger.Object);
mapping1 = new CommandMapping(typeof(NullCommand));
mapping2 = new CommandMapping(typeof(NullCommand2));
mapping3 = new CommandMapping(typeof(NullCommand3));
}
public void uses_injector_mapped_command_instance()
{
injector.Map(typeof(Action <SelfReportingCallbackCommand>), "ExecuteCallback").ToValue((Action <SelfReportingCallbackCommand>)reportingFunction);
injector.Map <SelfReportingCallbackCommand>().AsSingleton();
object expected = injector.GetInstance <SelfReportingCallbackCommand>();
ICommandMapping mapping = addMapping(typeof(SelfReportingCallbackCommand));
subject.ExecuteCommand(mapping);
Assert.That(reported, Is.EqualTo(new object[] { expected }).AsCollection);
}
public void before()
{
logger = new Mock <ILogging> ();
trigger = new Mock <ICommandTrigger> ();
processors = new List <CommandMappingList.Processor>();
subject = new CommandMappingList(trigger.Object, processors, logger.Object);
mapping1 = new CommandMapping(typeof(NullCommand));
mapping2 = new CommandMapping(typeof(NullCommand2));
mapping3 = new CommandMapping(typeof(NullCommand3));
}
public void RemoveMapping(ICommandMapping mapping)
{
if (_mappingsByCommand.ContainsKey(mapping.CommandClass))
{
DeleteMapping(mapping);
if (_mappings.Count == 0)
{
_trigger.Deactivate();
}
}
}
public void oneShotMapping_is_removed()
{
subject = new CommandExecutor(injector, unMapper.Object.Unmap);
ICommandMapping mapping = addMapping <ClassReportingCallbackCommand>();
mapping.SetFireOnce(true);
subject.ExecuteCommands(mappings);
unMapper.Verify(unMapperObject => unMapperObject.Unmap(It.Is <ICommandMapping> (arg => arg == mapping)), Times.Once);
}
private void OverwriteMapping(ICommandMapping oldMapping, ICommandMapping newMapping)
{
if (_logger != null)
{
_logger.Warn("{0} already mapped to {1}\n" +
"If you have overridden this mapping intentionally you can use 'unmap()' " +
"prior to your replacement mapping in order to avoid seeing this message.\n",
new object[] { _trigger, oldMapping });
}
DeleteMapping(oldMapping);
StoreMapping(newMapping);
}
public void ExecuteCommand(ICommandMapping mapping, CommandPayload payload = null)
{
bool hasPayload = payload != null && payload.HasPayload();
bool injectionEnabled = hasPayload && mapping.PayloadInjectionEnabled;
object command = null;
if (injectionEnabled)
{
MapPayload(payload);
}
if (mapping.Guards.Count == 0 || Guards.Approve(_injector, mapping.Guards))
{
Type commandClass = mapping.CommandClass;
if (mapping.FireOnce && _removeMapping != null)
{
_removeMapping(mapping);
}
command = _injector.GetOrCreateNewInstance(commandClass);
if (mapping.Hooks.Count > 0)
{
_injector.Map(commandClass).ToValue(command);
Hooks.Apply(_injector, mapping.Hooks);
_injector.Unmap(commandClass);
}
}
if (injectionEnabled)
{
UnmapPayload(payload);
}
if (command != null && mapping.ExecuteMethod != null)
{
if (_onPreprocessCommandExecuting != null)
{
_onPreprocessCommandExecuting.Invoke(command, mapping);
}
MethodInfo executeMethod = command.GetType().GetMethod(mapping.ExecuteMethod);
object result = (hasPayload && executeMethod.GetParameters().Length > 0)
? executeMethod.Invoke(command, payload.Values.ToArray())
: executeMethod.Invoke(command, null);
if (_handleResult != null)
{
_handleResult.Invoke(result, command, mapping);
}
}
}
public void AddMapping (ICommandMapping mapping)
{
_sorted = false;
ApplyProcessors (mapping);
ICommandMapping oldMapping = null;
_mappingsByCommand.TryGetValue(mapping.CommandClass, out oldMapping);
if (oldMapping != null)
OverwriteMapping (oldMapping, mapping);
else
{
StoreMapping (mapping);
if (_mappings.Count == 1)
_trigger.Activate ();
}
}
public void AddMapping(ICommandMapping mapping)
{
_sorted = false;
ApplyProcessors(mapping);
ICommandMapping oldMapping = null;
_mappingsByCommand.TryGetValue(mapping.CommandClass, out oldMapping);
if (oldMapping != null)
{
OverwriteMapping(oldMapping, mapping);
}
else
{
StoreMapping(mapping);
if (_mappings.Count == 1)
{
_trigger.Activate();
}
}
}
public void ExecuteCommand(ICommandMapping mapping, CommandPayload payload = null)
{
bool hasPayload = payload !=null && payload.HasPayload();
bool injectionEnabled = hasPayload && mapping.PayloadInjectionEnabled;
object command = null;
if (injectionEnabled)
MapPayload(payload);
if (mapping.Guards.Count == 0 || Guards.Approve(_injector, mapping.Guards))
{
Type commandClass = mapping.CommandClass;
if (mapping.FireOnce && _removeMapping != null)
_removeMapping (mapping);
command = _injector.GetOrCreateNewInstance(commandClass);
if (mapping.Hooks.Count > 0)
{
_injector.Map(commandClass).ToValue(command);
Hooks.Apply(_injector, mapping.Hooks);
_injector.Unmap(commandClass);
}
}
if (injectionEnabled)
UnmapPayload(payload);
if (command != null && mapping.ExecuteMethod != null)
{
MethodInfo executeMethod = command.GetType().GetMethod (mapping.ExecuteMethod);
object result = (hasPayload && executeMethod.GetParameters ().Length > 0)
? executeMethod.Invoke (command, payload.Values.ToArray ())
: executeMethod.Invoke (command, null);
if (_handleResult != null)
_handleResult.Invoke (result, command, mapping);
}
}
private void OverwriteMapping(ICommandMapping oldMapping, ICommandMapping newMapping)
{
if (_logger != null)
_logger.Warn("{0} already mapped to {1}\n" +
"If you have overridden this mapping intentionally you can use 'unmap()' " +
"prior to your replacement mapping in order to avoid seeing this message.\n",
new object[]{_trigger, oldMapping});
DeleteMapping (oldMapping);
StoreMapping (newMapping);
}
public static CommandService MapCommands(this CommandService commandService, ICommandMapping commandMapping)
{
commandMapping.MapCommands(commandService);
return commandService;
}
public void RemoveMapping (ICommandMapping mapping)
{
if (_mappingsByCommand.ContainsKey (mapping.CommandClass))
{
DeleteMapping (mapping);
if (_mappings.Count == 0)
_trigger.Deactivate ();
}
}
public void after()
{
caughtMapping = null;
subject = null;
}
public void before()
{
mockExecutor = new Mock <ICommandExecutor> ();
mockMappingList = new Mock <ICommandMappingList> ();
mockMappingList.Setup(m => m.AddMapping(It.IsAny <ICommandMapping> ())).Callback <ICommandMapping>(r => caughtMapping = r);
}
/*============================================================================*/
/* Private Functions */
/*============================================================================*/
private void StoreMapping(ICommandMapping mapping)
{
_mappingsByCommand [mapping.CommandClass] = mapping;
_mappings.Add (mapping);
if (_logger != null)
_logger.Debug("{0} mapped to {1}", new object[]{_trigger, mapping});
}
private void PreprocessAsyncCommandExecuting(object command, ICommandMapping CommandMapping)
{
_currentAsyncCommand = command as IAsyncCommand;
_context.Detain(_currentAsyncCommand);
}
public ICommandConfigurator ToCommand(Type commandClass)
{
_mapping = new CommandMapping(commandClass);
_mappings.AddMapping(_mapping);
return(this);
}
/*============================================================================*/
/* Public Functions */
/*============================================================================*/
public virtual void Unmap(ICommandMapping mapping)
{
}
/*============================================================================*/
/* Public Functions */
/*============================================================================*/
public virtual void Unmap(ICommandMapping mapping)
{
}
private void ApplyProcessors(ICommandMapping mapping)
{
foreach (Processor processor in _processors)
{
processor(mapping);
}
}
private void DeleteMapping(ICommandMapping mapping)
{
_mappingsByCommand.Remove (mapping.CommandClass);
_mappings.Remove (mapping);
if (_logger != null)
_logger.Debug("{0} unmapped from {1}", new object[]{_trigger, mapping});
}
