/// <summary>
/// Returns an instruction according to specified type name
/// </summary>
/// <param name="instructionType">Type of instruction to generate</param>
/// <returns>Corresponding instruction</returns>
public static PatchInstruction MakeInstruction(string instructionType)
{
PatchInstruction resultPI = null;
if (!string.IsNullOrEmpty(instructionType))
{
instructionType = String2.ToPascalCase(instructionType);
string fullClassName = string.Format(_FORMAT_INSTRUCTION_CLASS, instructionType);
// To solve culture issues ??
ObjectHandle dynamicObject = Activator.CreateInstance(null, fullClassName, false, BindingFlags.CreateInstance, null, null, CultureInfo.InvariantCulture, null, null);
if (dynamicObject != null)
{
resultPI = dynamicObject.Unwrap() as PatchInstruction;
if (resultPI != null)
{
resultPI._Type = (InstructionName)Enum.Parse(typeof(InstructionName), instructionType, true);
}
}
}
return(resultPI);
}
///<summary>
///
/// Creates a new object that is a copy of the current instance.
///
///</summary>
///
///<returns>
///
/// A new object that is a copy of this instance.
///
///</returns>
///<filterpriority>2</filterpriority>
public object Clone()
{
PatchInstruction clonePi = MakeInstruction(_Type.ToString());
clonePi._Enabled = _Enabled;
clonePi._FailOnError = _FailOnError;
clonePi._Order = _Order;
clonePi._Parameters = _CloneParameters();
clonePi._Comment = _Comment.Clone() as string;
clonePi._Group = _Group;
return(clonePi);
}
/// <summary>
/// Utility method allowing to return an instruction with different type, but keeping all compatible parameters
/// </summary>
/// <param name="instruction"></param>
/// <param name="newInstructionName"></param>
/// <returns></returns>
public static PatchInstruction ChangeInstruction(PatchInstruction instruction, InstructionName newInstructionName)
{
PatchInstruction changedInstruction = null;
if (instruction != null)
{
changedInstruction = MakeInstruction(newInstructionName.ToString());
changedInstruction._Order = instruction._Order;
changedInstruction._Parameters = instruction._CloneParameters();
changedInstruction._Comment = instruction._Comment;
changedInstruction._Group = instruction._Group;
changedInstruction.RemoveUnsupportedParameters();
}
return(changedInstruction);
}
/// <summary>
/// Copy properties from a patch instruction to another. References are copied, not values.
/// </summary>
/// <param name="piSource">Base instruction</param>
/// <param name="piDestination">Target instruction</param>
/// <param name="removeUnsupportedParameters">true to only keep parameters supported by target, false to keep all</param>
public static void CopyProperties(PatchInstruction piSource, PatchInstruction piDestination, bool removeUnsupportedParameters)
{
if (piSource != null && piDestination != null)
{
piDestination._Enabled = piSource._Enabled;
piDestination._FailOnError = piSource._FailOnError;
piDestination._Order = piSource._Order;
piDestination._Comment = piSource._Comment;
piDestination._Group = piSource._Group;
// Parameters: depending on boolean parameter
piDestination._Parameters = piSource._Parameters;
if (removeUnsupportedParameters)
{
piDestination.RemoveUnsupportedParameters();
}
}
}
