/// <summary>
/// Registers the given information to make the command available for later execution.
/// </summary>
/// <typeparam name="TValue">The type of value expected to be handled by the execution action.</typeparam>
/// <param name="name">The name of the command to be registered.</param>
/// <param name="executionAction">The action to be executed when the command is triggered.</param>
/// <exception cref="ArgumentException">Thrown when the given command name is not a valid string.</exception>
/// <exception cref="ArgumentNullException">Thrown when the given execution action is null.</exception>
/// <remarks>
/// <para>
/// If a command registration already exists under the given name, that registration will be overwritten
/// by the given information.
/// </para>
/// </remarks>
public void Register <TValue>(string name, Action <TValue> executionAction)
{
VerificationProvider.VerifyValidString(name, "name");
VerificationProvider.VerifyNotNull(executionAction, "executionAction");
mCommandRegistrations[name] = new ExecutableCommandRegistration <TValue>(name, executionAction, mObjectConverterFactory);
}
private void HandleRegistration(string[] registrationParameters)
{
if (registrationParameters.Length != 2)
{
ConsoleHelper.WriteLine(ConsoleMessageType.Error,
"Invalid number of values specified for command registration. Please specify the name and program path.");
return;
}
// Extract the registration name and program path from the registration parameters
string registrationName = registrationParameters[0];
string programPath = registrationParameters[1];
VerificationProvider.VerifyValidString(registrationName, "registrationName");
VerificationProvider.VerifyValidString(programPath, "programPath");
// Check we haven't already made a registration with this name
if (ApplicationContext.ProgramRegistrations.ContainsKey(registrationName))
{
ConsoleHelper.WriteLine(ConsoleMessageType.Warning,
"A program has already been registered under the name '{0}' and will be overridden.",
registrationName);
}
// Store the registration, overriding any existing registrations
ApplicationContext.ProgramRegistrations[registrationName] = programPath;
ConsoleHelper.WriteLine(ConsoleMessageType.Information,
"A registration has been successfully made under '{0}' for the path '{1}'.",
registrationName, programPath);
}
/// <summary>
/// Initializes a new instance of the <see cref="RunCommandApplicationContext"/> class.
/// </summary>
/// <param name="filePath">The path to which the context information should be written to and read from.</param>
/// <exception cref="ArgumentException">Thrown when the given file path is not a valid string.</exception>
public RunCommandApplicationContext(string filePath)
{
VerificationProvider.VerifyValidString(filePath, "filePath");
mFilePath = filePath;
// Make sure the directory exists
Directory.CreateDirectory(Path.GetDirectoryName(filePath));
}
/// <summary>
/// Initializes a new instance of the <see cref="ExecutableCommandRegistration{TValue}"/> class.
/// </summary>
/// <typeparam name="TValue">The type of value expected to be handled by the execution action.</typeparam>
/// <param name="name">The name of the command to be registered.</param>
/// <param name="executionAction">The action to be invoked when the command is triggered.</param>
/// <param name="objectConverterFactory">A factory used to create requested object converters.</param>
/// <exception cref="ArgumentException">Thrown when the given name is an invalid string.</exception>
/// <exception cref="ArgumentNullException">Thrown when the given or execution action object converter factory is null.</exception>
internal ExecutableCommandRegistration(string name, Action <TValue> executionAction, ObjectConverterFactory objectConverterFactory)
{
VerificationProvider.VerifyValidString(name, "name");
VerificationProvider.VerifyNotNull(executionAction, "executionAction");
VerificationProvider.VerifyNotNull(objectConverterFactory, "objectConverterFactory");
mName = name;
mExecutionAction = executionAction;
mObjectConverterFactory = objectConverterFactory;
}
/// <summary>
/// Attempts to retrieve an executable command registered under the given name.
/// </summary>
/// <param name="name">The name of the command registration to find.</param>
/// <returns>The executable command registered under the given name if it exists; otherwise null.</returns>
/// <exception cref="ArgumentException">Thrown when the given command name is not a valid string.</exception>
public IExecutableCommandRegistration GetCommandRegistration(string name)
{
VerificationProvider.VerifyValidString(name, "name");
IExecutableCommandRegistration registration;
if (!mCommandRegistrations.TryGetValue(name, out registration))
{
return(null);
}
return(registration);
}
/// <summary>
/// Attempts to retrieve a value from the set of commands that is stored under the given key.
/// </summary>
/// <typeparam name="TValue">The type of the value to be retrieved.</typeparam>
/// <param name="key">The key of the command to retrieve.</param>
/// <param name="value">An output parameter that will be populated with the requested value.</param>
/// <returns>True if the given key matches a stored command; false otherwise.</returns>
/// <exception cref="ArgumentException">Thrown when the given key value is not a valid string.</exception>
public bool TryGetValue <TValue>(string key, out TValue value)
{
VerificationProvider.VerifyValidString(key, "key");
// Initialize the output parameter with a default value
value = default(TValue);
CommandResult command;
if (!mKeyedCommands.TryGetValue(key, out command))
{
// The command does not exist under the given key
return(false);
}
// We have the command, so get hold of the relevant converter for its type
var converter = mObjectConverterFactory.Create <TValue>();
value = converter.Convert(command.Value);
return(true);
}
