Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

more xmldoc

  • Loading branch information...
commit c9253f4ca56eab7421a1e9b07e1dca954b5a99b3 1 parent 86e90df
@adrianaisemberg adrianaisemberg authored
View
3  CLAP/FileSystemHelper.cs
@@ -2,6 +2,9 @@
namespace CLAP
{
+ /// <summary>
+ /// A helper for file reading to allow mocking for tests
+ /// </summary>
public static class FileSystemHelper
{
public static IFileSystem FileHandler { get; set; }
View
10 CLAP/IValidation.cs
@@ -1,8 +1,15 @@
namespace CLAP
{
+ /// <summary>
+ /// Validation of collections of parameters and values
+ /// </summary>
public interface ICollectionValidation
{
+ /// <summary>
+ /// Gets an instance of the collection validator
+ /// </summary>
+ /// <returns></returns>
ICollectionValidator GetValidator();
/// <summary>
@@ -11,6 +18,9 @@ public interface ICollectionValidation
string Description { get; }
}
+ /// <summary>
+ /// Validation of collections of parameters and values
+ /// </summary>
public interface ICollectionValidator
{
void Validate(ValueInfo[] properties);
View
6 CLAP/Method.cs
@@ -36,11 +36,7 @@ public sealed class Method
#region Constructors
- /// <summary>
- /// Constructor
- /// </summary>
- /// <param name="method">The <see cref="MethodInfo"/> to describe</param>
- public Method(MethodInfo method)
+ internal Method(MethodInfo method)
{
Debug.Assert(method != null);
View
3  CLAP/MethodInvoker.cs
@@ -3,6 +3,9 @@
namespace CLAP
{
+ /// <summary>
+ /// A helper for method invoking to allow mocking for tests
+ /// </summary>
public static class MethodInvoker
{
public static IMethodInvoker Invoker { get; set; }
View
145 CLAP/MultiParser.cs
@@ -5,6 +5,9 @@
namespace CLAP
{
+ /// <summary>
+ /// A parser of one or more classes
+ /// </summary>
public abstract class MultiParser
{
#region Fields
@@ -16,6 +19,9 @@ public abstract class MultiParser
#region Properties
+ /// <summary>
+ /// Parser registration
+ /// </summary>
public ParserRegistration Register { get; private set; }
#endregion Properties
@@ -38,7 +44,7 @@ protected MultiParser()
#endregion Constructors
- #region Methods
+ #region Private Methods
private void Init()
{
@@ -52,65 +58,6 @@ private void Init()
Register = new ParserRegistration(GetHelpString, ValuesFactory.GetValueForParameter);
}
- public void RunStatic(string[] args)
- {
- RunTargets(args, null);
- }
-
- public void RunTargets(string[] args, params object[] targets)
- {
- // no args
- //
- if (args.None() || args.All(a => string.IsNullOrEmpty(a)))
- {
- HandleEmptyArguments(targets);
-
- return;
- }
-
- ParserRunner parser;
-
- if (m_types.Length == 1)
- {
- parser = GetSingleTypeParser(args, targets, Register);
- }
- else
- {
- Debug.Assert(m_types.Length > 1);
-
- parser = GetMultiTypesParser(args, targets, Register);
- }
-
- Debug.Assert(parser != null);
-
- var index = m_types.ToList().IndexOf(parser.Type);
-
- Debug.Assert(index >= 0);
-
- var target = targets.None() ? null : targets[index];
-
- parser.Run(args, target);
- }
-
- public string GetHelpString()
- {
- var sb = new StringBuilder();
-
- foreach (var type in m_types)
- {
- var pr = new ParserRunner(type, Register);
-
- sb.AppendLine(type.Name);
- sb.AppendLine("".PadLeft(30, '-'));
-
- sb.AppendLine(pr.GetHelpString());
-
- sb.AppendLine();
- }
-
- return sb.ToString();
- }
-
private void HandleEmptyArguments(object[] targets)
{
if (Register.RegisteredEmptyHandler != null)
@@ -209,6 +156,82 @@ private ParserRunner GetSingleTypeParser(string[] args, object obj, ParserRegist
return parser;
}
- #endregion Methods
+ #endregion Private Methods
+
+ #region Public Methods
+
+ /// <summary>
+ /// Run a parser of static verbs
+ /// </summary>
+ /// <param name="args">The user arguments</param>
+ public void RunStatic(string[] args)
+ {
+ RunTargets(args, null);
+ }
+
+ /// <summary>
+ /// Run a parser of instance verbs against instances of the verb classes
+ /// </summary>
+ /// <param name="args">The user arguments</param>
+ /// <param name="targets">The instances of the verb classes</param>
+ public void RunTargets(string[] args, params object[] targets)
+ {
+ // no args
+ //
+ if (args.None() || args.All(a => string.IsNullOrEmpty(a)))
+ {
+ HandleEmptyArguments(targets);
+
+ return;
+ }
+
+ ParserRunner parser;
+
+ if (m_types.Length == 1)
+ {
+ parser = GetSingleTypeParser(args, targets, Register);
+ }
+ else
+ {
+ Debug.Assert(m_types.Length > 1);
+
+ parser = GetMultiTypesParser(args, targets, Register);
+ }
+
+ Debug.Assert(parser != null);
+
+ var index = m_types.ToList().IndexOf(parser.Type);
+
+ Debug.Assert(index >= 0);
+
+ var target = targets.None() ? null : targets[index];
+
+ parser.Run(args, target);
+ }
+
+ /// <summary>
+ /// Gets a help string that describes all the parser information for the user
+ /// </summary>
+ public string GetHelpString()
+ {
+#warning TODO: this is crap
+ var sb = new StringBuilder();
+
+ foreach (var type in m_types)
+ {
+ var pr = new ParserRunner(type, Register);
+
+ sb.AppendLine(type.Name);
+ sb.AppendLine("".PadLeft(30, '-'));
+
+ sb.AppendLine(pr.GetHelpString());
+
+ sb.AppendLine();
+ }
+
+ return sb.ToString();
+ }
+
+ #endregion Public Methods
}
}
View
6 CLAP/Parameter.cs
@@ -42,11 +42,7 @@ public sealed class Parameter
#region Constructors
- /// <summary>
- /// Constructor
- /// </summary>
- /// <param name="parameter">The <see cref="ParameterInfo"/> to describe</param>
- public Parameter(ParameterInfo parameter)
+ internal Parameter(ParameterInfo parameter)
{
Debug.Assert(parameter != null);
View
12 CLAP/ParametersExpressionValidator.cs
@@ -3,9 +3,19 @@
namespace CLAP
{
+ /// <summary>
+ /// Validates a collection of named parameters or properties against a boolean expression
+ /// </summary>
internal class ParametersExpressionValidator : ICollectionValidator
{
+ /// <summary>
+ /// The expression
+ /// </summary>
public string Expression { get; private set; }
+
+ /// <summary>
+ /// Whether the expression should be treated as case-sensitive
+ /// </summary>
public bool CaseSensitive { get; private set; }
internal ParametersExpressionValidator(string expression, bool caseSensitive)
@@ -47,4 +57,4 @@ public void Validate(ValueInfo[] parameters)
}
}
}
-}
+}
View
293 CLAP/Parser.cs
@@ -9,11 +9,20 @@ namespace CLAP
/// </summary>
public class Parser : MultiParser
{
+ /// <summary>
+ /// Creates a parser based on the specified types
+ /// </summary>
+ /// <param name="types"></param>
public Parser(params Type[] types)
: base(types)
{
}
+ /// <summary>
+ /// Executes a parser of instance-verbs based on the specified targets
+ /// </summary>
+ /// <param name="args">The user arguments</param>
+ /// <param name="targets">The instances of the verb classes</param>
public static void Run(string[] args, params object[] targets)
{
Debug.Assert(targets.Any());
@@ -24,76 +33,342 @@ public static void Run(string[] args, params object[] targets)
((MultiParser)p).RunTargets(args, targets);
}
+ /// <summary>
+ /// Executes a generic static parser of a specified type
+ /// </summary>
+ /// <typeparam name="T">The type of the parser</typeparam>
+ /// <param name="args">The user arguments</param>
public static void Run<T>(string[] args)
{ new Parser<T>().RunStatic(args); }
+
+ /// <summary>
+ /// Executes a generic parser of a specified type
+ /// </summary>
+ /// <typeparam name="T">The type of the parser</typeparam>
+ /// <param name="args">The user arguments</param>
+ /// <param name="t">An instance of the verb class</param>
public static void Run<T>(string[] args, T t)
{ new Parser<T>().RunTargets(args, t); }
+ /// <summary>
+ /// Executes a generic static parser of some specified types
+ /// </summary>
+ /// <param name="args">The user arguments</param>
public static void Run<T1, T2>(string[] args)
{ new Parser<T1, T2>().RunStatic(args); }
+
+ /// <summary>
+ /// Executes a generic parser of some specified types
+ /// </summary>
+ /// <typeparam name="T">The type of the parser</typeparam>
+ /// <param name="args">The user arguments</param>
+ /// <param name="t1">An instance of the verb class</param>
+ /// <param name="t2">An instance of the verb class</param>
public static void Run<T1, T2>(string[] args, T1 t1, T2 t2)
{ new Parser<T1, T2>().RunTargets(args, t1, t2); }
+ /// <summary>
+ /// Executes a generic static parser of some specified types
+ /// </summary>
+ /// <param name="args">The user arguments</param>
public static void Run<T1, T2, T3>(string[] args)
{ new Parser<T1, T2, T3>().RunStatic(args); }
+
+ /// <summary>
+ /// Executes a generic parser of some specified types
+ /// </summary>
+ /// <typeparam name="T">The type of the parser</typeparam>
+ /// <param name="args">The user arguments</param>
+ /// <param name="t1">An instance of the verb class</param>
+ /// <param name="t2">An instance of the verb class</param>
+ /// <param name="t3">An instance of the verb class</param>
public static void Run<T1, T2, T3>(string[] args, T1 t1, T2 t2, T3 t3)
{ new Parser<T1, T2, T3>().RunTargets(args, t1, t2, t3); }
+ /// <summary>
+ /// Executes a generic static parser of some specified types
+ /// </summary>
+ /// <param name="args">The user arguments</param>
public static void Run<T1, T2, T3, T4>(string[] args)
{ new Parser<T1, T2, T3, T4>().RunStatic(args); }
+
+ /// <summary>
+ /// Executes a generic parser of some specified types
+ /// </summary>
+ /// <typeparam name="T">The type of the parser</typeparam>
+ /// <param name="args">The user arguments</param>
+ /// <param name="t1">An instance of the verb class</param>
+ /// <param name="t2">An instance of the verb class</param>
+ /// <param name="t3">An instance of the verb class</param>
+ /// <param name="t4">An instance of the verb class</param>
public static void Run<T1, T2, T3, T4>(string[] args, T1 t1, T2 t2, T3 t3, T4 t4)
{ new Parser<T1, T2, T3, T4>().RunTargets(args, t1, t2, t3, t4); }
+ /// <summary>
+ /// Executes a generic static parser of some specified types
+ /// </summary>
+ /// <param name="args">The user arguments</param>
public static void Run<T1, T2, T3, T4, T5>(string[] args)
{ new Parser<T1, T2, T3, T4, T5>().RunStatic(args); }
+
+ /// <summary>
+ /// Executes a generic parser of some specified types
+ /// </summary>
+ /// <typeparam name="T">The type of the parser</typeparam>
+ /// <param name="args">The user arguments</param>
+ /// <param name="t1">An instance of the verb class</param>
+ /// <param name="t2">An instance of the verb class</param>
+ /// <param name="t3">An instance of the verb class</param>
+ /// <param name="t4">An instance of the verb class</param>
+ /// <param name="t5">An instance of the verb class</param>
public static void Run<T1, T2, T3, T4, T5>(string[] args, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
{ new Parser<T1, T2, T3, T4, T5>().RunTargets(args, t1, t2, t3, t4, t5); }
+ /// <summary>
+ /// Executes a generic static parser of some specified types
+ /// </summary>
+ /// <param name="args">The user arguments</param>
public static void Run<T1, T2, T3, T4, T5, T6>(string[] args)
{ new Parser<T1, T2, T3, T4, T5, T6>().RunStatic(args); }
+
+ /// <summary>
+ /// Executes a generic parser of some specified types
+ /// </summary>
+ /// <typeparam name="T">The type of the parser</typeparam>
+ /// <param name="args">The user arguments</param>
+ /// <param name="t1">An instance of the verb class</param>
+ /// <param name="t2">An instance of the verb class</param>
+ /// <param name="t3">An instance of the verb class</param>
+ /// <param name="t4">An instance of the verb class</param>
+ /// <param name="t5">An instance of the verb class</param>
+ /// <param name="t6">An instance of the verb class</param>
public static void Run<T1, T2, T3, T4, T5, T6>(string[] args, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
{ new Parser<T1, T2, T3, T4, T5, T6>().RunTargets(args, t1, t2, t3, t4, t5, t6); }
+ /// <summary>
+ /// Executes a generic static parser of some specified types
+ /// </summary>
+ /// <param name="args">The user arguments</param>
public static void Run<T1, T2, T3, T4, T5, T6, T7>(string[] args)
{ new Parser<T1, T2, T3, T4, T5, T6, T7>().RunStatic(args); }
+
+ /// <summary>
+ /// Executes a generic parser of some specified types
+ /// </summary>
+ /// <typeparam name="T">The type of the parser</typeparam>
+ /// <param name="args">The user arguments</param>
+ /// <param name="t1">An instance of the verb class</param>
+ /// <param name="t2">An instance of the verb class</param>
+ /// <param name="t3">An instance of the verb class</param>
+ /// <param name="t4">An instance of the verb class</param>
+ /// <param name="t5">An instance of the verb class</param>
+ /// <param name="t6">An instance of the verb class</param>
+ /// <param name="t7">An instance of the verb class</param>
public static void Run<T1, T2, T3, T4, T5, T6, T7>(string[] args, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)
{ new Parser<T1, T2, T3, T4, T5, T6, T7>().RunTargets(args, t1, t2, t3, t4, t5, t6, t7); }
+ /// <summary>
+ /// Executes a generic static parser of some specified types
+ /// </summary>
+ /// <param name="args">The user arguments</param>
public static void Run<T1, T2, T3, T4, T5, T6, T7, T8>(string[] args)
{ new Parser<T1, T2, T3, T4, T5, T6, T7, T8>().RunStatic(args); }
+
+ /// <summary>
+ /// Executes a generic parser of some specified types
+ /// </summary>
+ /// <typeparam name="T">The type of the parser</typeparam>
+ /// <param name="args">The user arguments</param>
+ /// <param name="t1">An instance of the verb class</param>
+ /// <param name="t2">An instance of the verb class</param>
+ /// <param name="t3">An instance of the verb class</param>
+ /// <param name="t4">An instance of the verb class</param>
+ /// <param name="t5">An instance of the verb class</param>
+ /// <param name="t6">An instance of the verb class</param>
+ /// <param name="t7">An instance of the verb class</param>
+ /// <param name="t8">An instance of the verb class</param>
public static void Run<T1, T2, T3, T4, T5, T6, T7, T8>(string[] args, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8)
{ new Parser<T1, T2, T3, T4, T5, T6, T7, T8>().RunTargets(args, t1, t2, t3, t4, t5, t6, t7, t8); }
+ /// <summary>
+ /// Executes a generic static parser of some specified types
+ /// </summary>
+ /// <param name="args">The user arguments</param>
public static void Run<T1, T2, T3, T4, T5, T6, T7, T8, T9>(string[] args)
{ new Parser<T1, T2, T3, T4, T5, T6, T7, T8, T9>().RunStatic(args); }
+
+ /// <summary>
+ /// Executes a generic parser of some specified types
+ /// </summary>
+ /// <typeparam name="T">The type of the parser</typeparam>
+ /// <param name="args">The user arguments</param>
+ /// <param name="t1">An instance of the verb class</param>
+ /// <param name="t2">An instance of the verb class</param>
+ /// <param name="t3">An instance of the verb class</param>
+ /// <param name="t4">An instance of the verb class</param>
+ /// <param name="t5">An instance of the verb class</param>
+ /// <param name="t6">An instance of the verb class</param>
+ /// <param name="t7">An instance of the verb class</param>
+ /// <param name="t8">An instance of the verb class</param>
+ /// <param name="t9">An instance of the verb class</param>
public static void Run<T1, T2, T3, T4, T5, T6, T7, T8, T9>(string[] args, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9)
{ new Parser<T1, T2, T3, T4, T5, T6, T7, T8, T9>().RunTargets(args, t1, t2, t3, t4, t5, t6, t7, t8, t9); }
}
+ /// <summary>
+ /// A command-line arguments parser of the specified type
+ /// </summary>
+ /// <typeparam name="T"></typeparam>
public class Parser<T> : MultiParser
- { public void Run(string[] args, T t) { base.RunTargets(args, t); } }
+ {
+ /// <summary>
+ /// Executes the parser based on the specified targets
+ /// </summary>
+ /// <param name="args">The user arguments</param>
+ /// <param name="t">An instance of the verb class</param>
+ public void Run(string[] args, T t)
+ {
+ base.RunTargets(args, t);
+ }
+ }
public class Parser<T1, T2> : MultiParser
- { public void Run(string[] args, T1 t1, T2 t2) { base.RunTargets(args, t1, t2); } }
+ {
+ /// <summary>
+ /// Executes the parser based on the specified targets
+ /// </summary>
+ /// <param name="args">The user arguments</param>
+ /// <param name="t1">An instance of the verb class</param>
+ /// <param name="t2">An instance of the verb class</param>
+ public void Run(string[] args, T1 t1, T2 t2)
+ {
+ base.RunTargets(args, t1, t2);
+ }
+ }
public class Parser<T1, T2, T3> : MultiParser
- { public void Run(string[] args, T1 t1, T2 t2, T3 t3) { base.RunTargets(args, t1, t2, t3); } }
+ {
+ /// <summary>
+ /// Executes the parser based on the specified targets
+ /// </summary>
+ /// <param name="args">The user arguments</param>
+ /// <param name="t1">An instance of the verb class</param>
+ /// <param name="t2">An instance of the verb class</param>
+ /// <param name="t3">An instance of the verb class</param>
+ public void Run(string[] args, T1 t1, T2 t2, T3 t3)
+ {
+ base.RunTargets(args, t1, t2, t3);
+ }
+ }
public class Parser<T1, T2, T3, T4> : MultiParser
- { public void Run(string[] args, T1 t1, T2 t2, T3 t3, T4 t4) { base.RunTargets(args, t1, t2, t3, t4); } }
+ {
+ /// <summary>
+ /// Executes the parser based on the specified targets
+ /// </summary>
+ /// <param name="args">The user arguments</param>
+ /// <param name="t1">An instance of the verb class</param>
+ /// <param name="t2">An instance of the verb class</param>
+ /// <param name="t3">An instance of the verb class</param>
+ /// <param name="t4">An instance of the verb class</param>
+ public void Run(string[] args, T1 t1, T2 t2, T3 t3, T4 t4)
+ {
+ base.RunTargets(args, t1, t2, t3, t4);
+ }
+ }
public class Parser<T1, T2, T3, T4, T5> : MultiParser
- { public void Run(string[] args, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) { base.RunTargets(args, t1, t2, t3, t4, t5); } }
+ {
+ /// <summary>
+ /// Executes the parser based on the specified targets
+ /// </summary>
+ /// <param name="args">The user arguments</param>
+ /// <param name="t1">An instance of the verb class</param>
+ /// <param name="t2">An instance of the verb class</param>
+ /// <param name="t3">An instance of the verb class</param>
+ /// <param name="t4">An instance of the verb class</param>
+ /// <param name="t5">An instance of the verb class</param>
+ public void Run(string[] args, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
+ {
+ base.RunTargets(args, t1, t2, t3, t4, t5);
+ }
+ }
public class Parser<T1, T2, T3, T4, T5, T6> : MultiParser
- { public void Run(string[] args, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) { base.RunTargets(args, t1, t2, t3, t4, t5, t6); } }
+ {
+ /// <summary>
+ /// Executes the parser based on the specified targets
+ /// </summary>
+ /// <param name="args">The user arguments</param>
+ /// <param name="t1">An instance of the verb class</param>
+ /// <param name="t2">An instance of the verb class</param>
+ /// <param name="t3">An instance of the verb class</param>
+ /// <param name="t4">An instance of the verb class</param>
+ /// <param name="t5">An instance of the verb class</param>
+ /// <param name="t6">An instance of the verb class</param>
+ public void Run(string[] args, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
+ {
+ base.RunTargets(args, t1, t2, t3, t4, t5, t6);
+ }
+ }
public class Parser<T1, T2, T3, T4, T5, T6, T7> : MultiParser
- { public void Run(string[] args, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7) { base.RunTargets(args, t1, t2, t3, t4, t5, t6, t7); } }
+ {
+ /// <summary>
+ /// Executes the parser based on the specified targets
+ /// </summary>
+ /// <param name="args">The user arguments</param>
+ /// <param name="t1">An instance of the verb class</param>
+ /// <param name="t2">An instance of the verb class</param>
+ /// <param name="t3">An instance of the verb class</param>
+ /// <param name="t4">An instance of the verb class</param>
+ /// <param name="t5">An instance of the verb class</param>
+ /// <param name="t6">An instance of the verb class</param>
+ /// <param name="t7">An instance of the verb class</param>
+ public void Run(string[] args, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)
+ {
+ base.RunTargets(args, t1, t2, t3, t4, t5, t6, t7);
+ }
+ }
public class Parser<T1, T2, T3, T4, T5, T6, T7, T8> : MultiParser
- { public void Run(string[] args, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8) { base.RunTargets(args, t1, t2, t3, t4, t5, t6, t7, t8); } }
+ {
+ /// <summary>
+ /// Executes the parser based on the specified targets
+ /// </summary>
+ /// <param name="args">The user arguments</param>
+ /// <param name="t1">An instance of the verb class</param>
+ /// <param name="t2">An instance of the verb class</param>
+ /// <param name="t3">An instance of the verb class</param>
+ /// <param name="t4">An instance of the verb class</param>
+ /// <param name="t5">An instance of the verb class</param>
+ /// <param name="t6">An instance of the verb class</param>
+ /// <param name="t7">An instance of the verb class</param>
+ /// <param name="t8">An instance of the verb class</param>
+ public void Run(string[] args, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8)
+ {
+ base.RunTargets(args, t1, t2, t3, t4, t5, t6, t7, t8);
+ }
+ }
public class Parser<T1, T2, T3, T4, T5, T6, T7, T8, T9> : MultiParser
- { public void Run(string[] args, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9) { base.RunTargets(args, t1, t2, t3, t4, t5, t6, t7, t8, t9); } }
+ {
+ /// <summary>
+ /// Executes the parser based on the specified targets
+ /// </summary>
+ /// <param name="args">The user arguments</param>
+ /// <param name="t1">An instance of the verb class</param>
+ /// <param name="t2">An instance of the verb class</param>
+ /// <param name="t3">An instance of the verb class</param>
+ /// <param name="t4">An instance of the verb class</param>
+ /// <param name="t5">An instance of the verb class</param>
+ /// <param name="t6">An instance of the verb class</param>
+ /// <param name="t7">An instance of the verb class</param>
+ /// <param name="t8">An instance of the verb class</param>
+ /// <param name="t9">An instance of the verb class</param>
+ public void Run(string[] args, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9)
+ {
+ base.RunTargets(args, t1, t2, t3, t4, t5, t6, t7, t8, t9);
+ }
+ }
}
Please sign in to comment.
Something went wrong with that request. Please try again.