public SeleniumChromeDriver(string args) : this()
{
foreach (var arg in args.Split(';'))
{
AdditionalArguments.Add(arg);
}
}
public string GetCommandLine()
{
List <string> guiDefinedArguments = new List <string>();
guiDefinedArguments.Add(DataPathArgument());
guiDefinedArguments.Add(ServerNameArgument());
guiDefinedArguments.Add(GalaxyNameArgument());
guiDefinedArguments.Add(SeedArgument());
guiDefinedArguments.Add(MaxPlayersArgument());
guiDefinedArguments.Add(ThreadsArgument());
guiDefinedArguments.Add(DifficultyArgument());
guiDefinedArguments.Add(CollisionDamageArgument());
guiDefinedArguments.Add(CreativeModeArgument());
guiDefinedArguments.Add(ShareHomesectorArgument());
guiDefinedArguments.Add(UserAuthenticationArgument());
guiDefinedArguments.Add(ListPublicArgument());
guiDefinedArguments.Add(SaveIntervalArgument());
guiDefinedArguments.Add(UseSteamNetworkingArgument());
guiDefinedArguments.Add(PortArgument());
StringBuilder commandLineStringBuilder = new StringBuilder();
foreach (string currentArgument in guiDefinedArguments)
{
if (AdditionalArguments != null && !AdditionalArguments.Contains(currentArgument.Split(' ')[0]))
{
commandLineStringBuilder.Append(currentArgument + " ");
}
}
commandLineStringBuilder.Append(" " + AdditionalArguments);
return(commandLineStringBuilder.ToString());
}
private IEnumerable <string> GetCastXmlArgs()
{
return(AdditionalArguments.Append("--castxml-gccxml")
.Append("-x c++")
.Append("-Wmacro-redefined")
.Append("-Wno-invalid-token-paste")
.Append("-Wno-ignored-attributes"));
}
/// <summary>
/// Adds the value to the <see cref="AdditionalArguments"/> collection property and
/// returns this instance.
/// </summary>
/// <param name="value">
/// The value to add to the <see cref="AdditionalArguments"/> collection property.
/// </param>
/// <returns>
/// This instance.
/// </returns>
/// <remarks>
/// This method is part of the fluent interface.
/// </remarks>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="value"/> is <c>null</c> or empty.</para>
/// </exception>
public T WithAdditionalArgument(string value)
{
if (StringEx.IsNullOrWhiteSpace(value))
{
throw new ArgumentNullException("value");
}
AdditionalArguments.Add(value);
return((T)this);
}
protected override void Execute(CodeActivityContext context)
{
console = context.GetExtension <ActivityConsole>();
if (console == null)
{
console = new ActivityConsole();
}
string backupArguments = string.Format("/p:BackupDatabaseBeforeChanges={0}", BackupBeforeDeploy.Get(context));
string alwaysCreateNewArguments = string.Format("/p:CreateNewDatabase={0}", AlwaysCreateNewDatabase.Get(context));
string sqlPackageArguments = "/a:Publish /tcs:\"{0}\" /sf:\"{1}\" {2} {3} {4}";
string output = string.Empty;
string sqlPackagePath = SqlPackagePath.Get(context);
if (string.IsNullOrEmpty(sqlPackagePath))
{
sqlPackagePath = @"C:\Program Files (x86)\Microsoft SQL Server\110\DAC\bin\SqlPackage.exe";
}
if (sqlPackagePath.EndsWith("SqlPackage.exe", StringComparison.OrdinalIgnoreCase))
{
sqlPackagePath = sqlPackagePath.Substring(0, sqlPackagePath.Length - "SqlPackage.exe".Length);
}
sqlPackagePath = Path.Combine(sqlPackagePath, "SqlPackage.exe");
if (!File.Exists(sqlPackagePath))
{
throw new ArgumentException(string.Format("SqlPackage missing : The file '{0}' could not be found.", sqlPackagePath));
}
sqlPackageArguments = string.Format(sqlPackageArguments,
ConnectionString.Get(context),
DacpacFilename.Get(context),
(BackupBeforeDeploy.Get(context) ? backupArguments : ""),
(AlwaysCreateNewDatabase.Get(context) ? alwaysCreateNewArguments : ""),
AdditionalArguments.Get(context));
console.WriteLine("Executing SqlPackage.exe..." + Environment.NewLine);
if (ShowCommandLine.Get(context))
{
console.WriteLine(string.Format("\"{0}\" {1}", sqlPackagePath, sqlPackageArguments));
}
CommandLine commandLineHelper = new CommandLine();
commandLineHelper.ReportProgress += new EventHandler <CommandLineProgressEventArgs>(commandLineHelper_ReportProgress);
int exitCode = commandLineHelper.Execute(sqlPackagePath, sqlPackageArguments, out output);
if (exitCode != 0)
{
throw new InvalidOperationException(string.Format("SqlPackage returned a exit code : '{0}'.", exitCode));
}
}
/// <summary>
/// Configure this instance with Windows and MSVC.
/// </summary>
/// <returns>This instance</returns>
public CppParserOptions ConfigureForWindowsMsvc(CppTargetCpu targetCpu = CppTargetCpu.X86, CppVisualStudioVersion vsVersion = CppVisualStudioVersion.VS2019)
{
// 1920
var highVersion = ((int)vsVersion) / 100; // => 19
var lowVersion = ((int)vsVersion) % 100; // => 20
var versionAsString = $"{highVersion}.{lowVersion}";
TargetCpu = targetCpu;
TargetCpuSub = string.Empty;
TargetVendor = "pc";
TargetSystem = "windows";
TargetAbi = $"msvc{versionAsString}";
// See https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros?view=vs-2019
Defines.Add($"_MSC_VER={(int)vsVersion}");
Defines.Add("_WIN32=1");
switch (targetCpu)
{
case CppTargetCpu.X86:
Defines.Add("_M_IX86=600");
break;
case CppTargetCpu.X86_64:
Defines.Add("_M_AMD64=100");
Defines.Add("_M_X64=100");
Defines.Add("_WIN64=1");
break;
case CppTargetCpu.ARM:
Defines.Add("_M_ARM=7");
break;
case CppTargetCpu.ARM64:
Defines.Add("_M_ARM64=1");
Defines.Add("_WIN64=1");
break;
default:
throw new ArgumentOutOfRangeException(nameof(targetCpu), targetCpu, null);
}
AdditionalArguments.Add("-fms-extensions");
AdditionalArguments.Add("-fms-compatibility");
AdditionalArguments.Add($"-fms-compatibility-version={versionAsString}");
return(this);
}
/// <summary>
/// Adds a configuration override specification to the <see cref="CommandBase{T}.AdditionalArguments"/>
/// collection in the form of <c>section.name=value</c>.
/// </summary>
/// <param name="sectionName">
/// The name of the section.
/// </param>
/// <param name="name">
/// The name of the value.
/// </param>
/// <param name="value">
/// The value.
/// </param>
/// <exception cref="System.ArgumentNullException">
/// <para><paramref name="sectionName"/> is <c>null</c> or empty.</para>
/// <para>- or -</para>
/// <para><paramref name="name"/> is <c>null</c> or empty.</para>
/// <para>- or -</para>
/// <para><paramref name="value"/> is <c>null</c>.</para>
/// </exception>
public void WithConfigurationOverride(string sectionName, string name, string value)
{
if (StringEx.IsNullOrWhiteSpace(sectionName))
{
throw new ArgumentNullException("sectionName");
}
if (StringEx.IsNullOrWhiteSpace(name))
{
throw new ArgumentNullException("name");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
AdditionalArguments.Add("--config");
AdditionalArguments.Add(string.Format(CultureInfo.InvariantCulture, "{0}.{1}=\"{2}\"", sectionName, name, value));
}
/// <summary>
/// Evaluates the settings and writes them to <paramref name="arguments"/>.
/// </summary>
/// <param name="arguments">The argument builder into which the settings should be written.</param>
public void Evaluate(ProcessArgumentBuilder arguments)
{
foreach (var package in Packages)
{
arguments.AppendSwitchQuoted("-p", package);
}
if (IgnoreExisting)
{
arguments.Append("--ignore-existing");
}
arguments.Append(Command);
if (!AdditionalArguments.IsNullOrEmpty())
{
arguments.Append(AdditionalArguments.Render());
}
}
public virtual RowSource GetRowSource(string name, RuntimeContext interCommunicator, params object[] parameters)
{
var sourceName = $"{name.ToLowerInvariant()}{_sourcePart}";
var methods = GetConstructors(sourceName).Select(c => c.ConstructorInfo).ToArray();
if (AdditionalArguments.ContainsKey(sourceName))
{
parameters = parameters.ExpandParameters(AdditionalArguments[sourceName]);
}
if (!TryMatchConstructorWithParams(methods, parameters, out var constructorInfo))
{
throw new NotSupportedException($"Unrecognized method {name}.");
}
if (constructorInfo.SupportsInterCommunicator)
{
parameters = parameters.ExpandParameters(interCommunicator);
}
return((RowSource)constructorInfo.OriginConstructor.Invoke(parameters));
}
