protected override string GetConstantValue(IArgument argument)
{
var expressionArgument = argument as IExpressionArgument;
if (expressionArgument != null && expressionArgument.Expression.IsConstantValue())
return expressionArgument.Expression.ConstantValue.Value as string;
return null;
}
public override void Initialize(IArgument[] properties)
{
SendEvent(new Event(EventType.Informative, this, "Started initialization.."));
Dictionary<string, string> arguments = new Dictionary<string, string>();
for (int i = 0; i < properties.Length; i++)
{
arguments.Add(properties[i].Key, properties[i].Value);
}
filename = arguments["Filename"];
outputFilename = arguments["OutputFilename"];
tsGroup = TimeSeriesGroupFactory.Create(filename);
foreach (BaseTimeSeries baseTimeSeries in tsGroup.Items)
{
HydroNumerics.OpenMI.Sdk.Backbone.Dimension dimention = new HydroNumerics.OpenMI.Sdk.Backbone.Dimension();
dimention.AmountOfSubstance = baseTimeSeries.Unit.Dimension.AmountOfSubstance;
dimention.Currency = baseTimeSeries.Unit.Dimension.Currency;
dimention.ElectricCurrent = baseTimeSeries.Unit.Dimension.ElectricCurrent;
dimention.Length = baseTimeSeries.Unit.Dimension.Length;
dimention.LuminousIntensity = baseTimeSeries.Unit.Dimension.LuminousIntensity;
dimention.Mass = baseTimeSeries.Unit.Dimension.Mass;
dimention.Time = baseTimeSeries.Unit.Dimension.Time;
HydroNumerics.OpenMI.Sdk.Backbone.Unit unit = new HydroNumerics.OpenMI.Sdk.Backbone.Unit();
unit.ID = baseTimeSeries.Unit.ID;
unit.Description = baseTimeSeries.Unit.Description;
unit.ConversionFactorToSI = baseTimeSeries.Unit.ConversionFactorToSI;
unit.OffSetToSI = baseTimeSeries.Unit.OffSetToSI;
TsQuantity quantity = new TsQuantity();
quantity.ID = baseTimeSeries.Name;
quantity.Description = baseTimeSeries.Description;
quantity.Dimension = dimention;
quantity.Unit = unit;
quantity.BaseTimeSeries = baseTimeSeries;
ElementSet elementSet = new ElementSet();
elementSet.ID = "IDBased";
elementSet.Description = "IDBased";
elementSet.ElementType = global::OpenMI.Standard.ElementType.IDBased;
elementSet.SpatialReference = new SpatialReference("Undefined");
Element element = new Element();
element.ID = "IDBased";
elementSet.AddElement(element);
OutputExchangeItem outputExchangeItem = new OutputExchangeItem();
outputExchangeItem.Quantity = quantity;
outputExchangeItem.ElementSet = elementSet;
this.AddOutputExchangeItem(outputExchangeItem);
InputExchangeItem inputExchangeItem = new InputExchangeItem();
inputExchangeItem.Quantity = quantity;
inputExchangeItem.ElementSet = elementSet;
this.AddInputExchangeItem(inputExchangeItem);
}
initializeWasInvoked = true;
SendEvent(new Event(EventType.Informative, this, "Completed initialization"));
}
public void Emit(OpCode opCode, IArgument a, IArgument b)
{
AssertNotFinished();
if (!opCode.IsBasic)
throw new ArgumentException("Non-basic OpCodes cannot have 2 arguments.", "opCode");
ushort? aNextWord;
ushort? bNextWord;
int nextWordPosition = CurrentBytePosition + 2;
ushort aValue = GetArgumentValue(a, nextWordPosition, out aNextWord);
if (aNextWord != null)
nextWordPosition += 2;
ushort bValue = GetArgumentValue(b, nextWordPosition, out bNextWord);
ushort instruction = (ushort)(opCode.Code | (aValue << 4) | (bValue << 10));
WriteWord(stream, instruction);
if (aNextWord != null)
WriteWord(stream, aNextWord.Value);
if (bNextWord != null)
WriteWord(stream, bNextWord.Value);
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="source">Source argument to copy</param>
public Argument(IArgument source)
{
Key = source.Key;
Value = source.Value;
ReadOnly = source.ReadOnly;
Description = source.Description;
}
// ----------------------------------------------------------------------
public void Add( IArgument item )
{
if ( item == null )
{
throw new ArgumentNullException( "item" );
}
InnerList.Add( item );
}
public ArgumentVariable(IElementOwner owner, IVplType type, IArgument argument)
: base(owner, type, argument.Id)
{
if (argument == null) throw new ArgumentNullException(nameof(argument));
_argument = argument;
argument.PropertyChanged += Argument_PropertyChanged;
}
/// <summary>
/// Initializes a new instance of the <see cref="ArgumentViolationException"/> class.
/// </summary>
/// <param name="violatedArgument">The violated argument.</param>
/// <param name="message">The message.</param>
/// <param name="innerException">The inner exception.</param>
public ArgumentViolationException(IArgument violatedArgument, string message, Exception innerException)
: base(message, innerException)
{
if (violatedArgument == null)
{
throw new ArgumentNullException("violatedArgument");
}
_violatedArgument = violatedArgument;
}
public ElementSetSelafinBase(ISpatialDefinition spatial, ElementType elementType, FileInfo selafinFileInfo = null)
: base(spatial, elementType)
{
Arguments = new IArgument[] {
new ArgumentFile(new Identity("Selafin file"), selafinFileInfo),
}.ToList();
Selafin = new Selafin(selafinFileInfo);
}
static IEnumerable<string> GetCommandLineArguments(string command, IArgument[] arguments)
{
var commandLineArguments = new List<string> {command};
commandLineArguments.AddRange(
arguments.SelectMany(
a => a.FormatCommandLine(DoubleDashArgumentPrefix, CommandLineArgumentStyle.SingleWithEqualsSignDelimiter)));
return commandLineArguments;
}
/// <summary>
/// Initializes a new instance of the <see cref="ArgumentViolationException"/> class.
/// </summary>
/// <param name="violatedArgument">The violated argument.</param>
public ArgumentViolationException(IArgument violatedArgument)
: base()
{
if (violatedArgument == null)
{
throw new ArgumentNullException("violatedArgument");
}
_violatedArgument = violatedArgument;
}
private static IArgument GetArgument(Parser.Args arguments, string key)
{
IArgument argument = arguments.CustomArguments.Where(x => x.Key != null).SingleOrDefault(x => x.Key.ToUpper() == key.ToUpper());
if (argument != null)
{
arguments.CustomArguments = arguments.CustomArguments.Except(new[] { argument });
}
return(argument);
}
private void PrintArgument(IArgument arg, bool subArg)
{
if (string.IsNullOrEmpty(arg.Description))
{
return;
}
Indent(subArg? 10 : 2);
_writer.Write(arg.Name);
_writer.Write(": ");
_writer.WriteLine(arg.Description);
}
public CliSpecification(
ICliConfig config = null,
IArgument dynamicArgument = null,
params IArgument[] args) : base(true, dynamicArgument, args)
{
Config = config ?? commons.config.Config.New <ICliConfig>( );
if (Config.AutoAddHelpOption)
{
Options.Add(HelpOption = new HelpOption(Config));
}
}
public void GetModelDescription()
{
Console.Write("Begin Get Model Description Test...");
DbWriter his = new DbWriter();
IArgument[] arguments = new IArgument[1];
arguments[0] = new Argument("DbPath", @"..\data\cuahsi-his\demo.db", true, "Database");
his.Initialize(arguments);
Console.WriteLine("model description: " + his.ModelDescription);
}
public override void VisitArgument(IArgument operation)
{
LogString($"{nameof(IArgument)} (");
LogSymbol(operation.Parameter, header: "Matching Parameter", logDisplayString: false);
LogString(")");
LogCommonPropertiesAndNewLine(operation);
Visit(operation.Value);
Visit(operation.InConversion, "InConversion");
Visit(operation.OutConversion, "OutConversion");
}
protected override void AddArguments()
{
_id = CommandArgumentValue.AddArgument("id", "identifier", new[] { "ID of identity provider, must be unique" }, true,
1);
_alias = CommandArgumentValue.AddArgument("a", "alias", new[] { "Alias of identity provider, must be unique" }, true,
1);
_enabled = CommandArgumentValue.AddArgument("e", "enabled", new[] { "True if identity provider should be enabled, otherwise false" }, true,
1);
_clientId = CommandArgumentValue.AddArgument("cid", "clientId", new[] { "ServiceClient ID, provided by provider" }, true, 1);
_clientSecret = CommandArgumentValue.AddArgument("cs", "clientSecret", new[] { "ServiceClient secret, provided by provider" }, true, 1);
}
public Flag(
char name,
bool optional = true,
IArgument dynamicArgument = null,
IEnumerable <IArgument> args = null) : this(
name,
optional,
dynamicArgument,
args?.ToArray( ))
{
}
public void MergeResult(ICommandParserResult result)
{
HasErrors |= result.HasErrors;
if (result.HelpRequested)
{
HelpRequestedFor = result.HelpRequestedFor;
}
commandParserResults.Add(result);
}
internal FailedArgumentConversionResult(
IArgument argument,
string errorMessage) : base(argument)
{
if (string.IsNullOrWhiteSpace(errorMessage))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(errorMessage));
}
ErrorMessage = errorMessage;
}
public void ThrowArgumentNullException_WhenArgumentIsNull()
{
// Arrange.
IArgument <int> argument = null;
// Act & Assert.
Ensure.ArgumentNullExceptionIsThrown(() =>
{
argument.AddValidationPredicate(new EqualValidationPredicate <int>(3));
}, "@argument");
}
private void AnalyzeArgsArgument([NotNull] IInvocationExpression invocation, [NotNull] INamedTypeSymbol systemEventArgs,
OperationAnalysisContext context)
{
IArgument argsArgument = GetArgsArgument(invocation, systemEventArgs);
if (argsArgument != null && IsNullConstant(argsArgument.Value))
{
context.ReportDiagnostic(Diagnostic.Create(ArgsRule, argsArgument.Syntax.GetLocation(),
argsArgument.Parameter.Name));
}
}
public static IArgument ArgumentFileInfoValueParse(IArgument iArg, string value)
{
Debug.Assert(iArg.ValueType == typeof(FileInfo));
IArgument arg = new ArgumentFileInfo(iArg)
{
Value = new FileInfo(value)
};
return(arg);
}
public override void Initialize(IArgument[] properties)
{
base.Initialize(properties);
foreach (IArgument argument in properties)
{
if (argument.Key == "FileName")
{
FileName = argument.Value;
}
}
}
public ElementSetGridRegularBase(ParametersGridRegular grid, ISpatialDefinition spatialDefinition, ElementType elementType)
: base(spatialDefinition, elementType)
{
GridParameters = grid.Clone() as ParametersGridRegular;
Arguments = new IArgument[] {
new ArgumentGridRegular(new Identity("Grid Parameters"), GridParameters),
}.ToList();
ElementType = ElementType;
}
public ElementSetGridRegularPoints()
: base(new SpatialDefinition(new Describes("Regular Grid Points", "Point set specified on a regular grid"), -1), ElementType.Point)
{
GridParameters = new ParametersGridRegular();
Arguments = new IArgument[] {
new ArgumentGridRegular(new Identity("Grid Parameters"), GridParameters),
}.ToList();
ElementType = ElementType.Point;
}
/// <summary>
/// Positional arguments cannot append values.
/// </summary>
/// <param name="prop"></param>
/// <param name="attr"></param>
/// <returns></returns>
private Exception PositionalArgumentsCannotAppendValues(
PropertyInfo prop, IArgument attr)
{
if (attr is PositionalArgumentAttribute &&
attr.Action == ParseAction.Append)
{
return(new ArgumentIntegrityException(
String.Format("Positional argument {0} cannot " +
@"""append"" values.", prop.Name)));
}
return(null);
}
/// <summary>
/// Arguments that take multiple values must be convertible to IEnumerable.
/// </summary>
/// <param name="prop"></param>
/// <param name="attr"></param>
/// <returns></returns>
private Exception VarArgsConvertibleToIEnumerableCheck(
PropertyInfo prop, IArgument attr)
{
if (attr.ConsumesMultipleArgs && !prop.IsValidIEnumerable())
{
return(new ArgumentIntegrityException(
"Arguments with a variable number of values or " +
"more than one required value must be attached " +
"to a parameter assignable to IEnumerable."));
}
return(null);
}
private static void PrintArg(IArgument argument, Indent indent, Action <string> writeln)
{
bool isObscured = argument.IsObscured();
var indent2 = indent.Increment();
var displayName = argument.TypeInfo.DisplayName.IsNullOrEmpty()
? (argument.Arity.AllowsNone() ? "Flag" : null)
: argument.TypeInfo.DisplayName;
writeln($"{indent}{argument.Name} <{displayName}>");
var valueString = argument.Value?.ValueToString(isObscured);
writeln(valueString == null ? $"{indent2}value:" : $"{indent2}value: {valueString}");
if (!argument.InputValues.IsNullOrEmpty())
{
var pwd = isObscured ? Password.ValueReplacement : null;
var values = argument.InputValues
.Select(iv => iv.Source == Constants.InputValueSources.Argument && argument.InputValues.Count == 1
? $"{ValuesToString(iv, pwd)}"
: iv.IsStream
? $"[{iv.Source} stream]"
: $"[{iv.Source}] {ValuesToString(iv, pwd)}")
.ToList();
if (values.Count == 1)
{
writeln($"{indent2}inputs: {values.Single()}");
}
else
{
writeln($"{indent2}inputs:");
values.ForEach(v => writeln($"{indent2.Increment()}{v}"));
}
}
else
{
writeln($"{indent2}inputs:");
}
if (argument.Default != null)
{
// don't include source when the default is defined as a parameter or property.
// only show externally defined sources
writeln(argument.Default.Source.StartsWith("app.")
? $"{indent2}default: {argument.Default.Value.ValueToString(isObscured)}"
: $"{indent2}default: source={argument.Default.Source} key={argument.Default.Key}: {argument.Default.Value.ValueToString(isObscured)}");
}
else
{
writeln($"{indent2}default:");
}
}
public ArgumentVariable(IElementOwner owner, IVplType type, IArgument argument)
: base(owner, type, argument.Id)
{
if (argument == null)
{
throw new ArgumentNullException(nameof(argument));
}
_argument = argument;
argument.PropertyChanged += Argument_PropertyChanged;
}
public InlineViewer Create(ICombinedSearchMetadataCollection combinedSearchMetadataCollection,
IObservable<ILineProvider> lineProvider,
IObservable<LineProxy> selectedChanged)
{
var args = new IArgument[]
{
new Argument<IObservable<ILineProvider>>(lineProvider),
new Argument<IObservable<LineProxy>>(selectedChanged),
new Argument<ICombinedSearchMetadataCollection>(combinedSearchMetadataCollection)
};
return _objectProvider.Get<InlineViewer>(args);
}
internal object GetValue(IArgument o, String propertyName)
{
var properties = TypeDescriptor.GetProperties(o.Value);
var property = GetPropertyCached(propertyName, properties, o.GetType());
if (property == null)
{
return(null);
}
return(property.GetValue(o.Value));
}
private static ArgumentDisplay GetArgumentsForDisplay(List <string> names, IArgument attr)
{
if (!names.Any())
{
names.Add(attr.Name);
}
return(new ArgumentDisplay
{
ArgumentNames = String.Join(", ", names.ToArray()),
Description = attr.Description ?? ""
});
}
public virtual IArgument Resolve(IArgument argument)
{
if (this._arguments.Contains(argument))
{
var destArgument = this._arguments.Get(argument);
destArgument.Raw = argument.Raw;
return(destArgument);
}
return(default);
/// <summary>
/// Positional arguments cannot store a count.
/// </summary>
/// <param name="prop"></param>
/// <param name="attr"></param>
/// <returns></returns>
private Exception PositionalArgumentsCannotStoreCount(
PropertyInfo prop, IArgument attr)
{
if (attr is PositionalArgumentAttribute &&
attr.Action == ParseAction.Count)
{
return(new ArgumentIntegrityException(
String.Format("Positional argument {0} cannot store " +
"a count.", prop.Name)));
}
return(null);
}
public void Then_Arguments_Are_Included_In_Field_Selections()
{
var customerSelectionSet = SelectionSetBuilder.For <Customer>()
.AddScalarField(customer => customer.Id)
.Build();
var versionArgs = new ArgumentCollection
{
ArgumentBuilder.Build("foo", "hello world"),
ArgumentBuilder.Build("bar", 10),
ArgumentBuilder.Build("baz")
};
var expectedVersionArgs = new IArgument[versionArgs.Count];
// copy the original arguments so our expectations aren't contaminated by the method under test
versionArgs.CopyTo(expectedVersionArgs, 0);
var customersArgs = new ArgumentCollection
{
ArgumentBuilder.Build("isActive", true),
ArgumentBuilder.Build("age", 50.2)
};
var expectedCustomersArgs = new IArgument[customersArgs.Count];
// copy the original arguments so our expectations aren't contaminated by the method under test
customersArgs.CopyTo(expectedCustomersArgs, 0);
var queryOperation = QueryOperationBuilder.ForSchema <SimpleSchema>(OperationTypeForFixture)
.AddScalarCollectionField(schema => schema.PastVersions, versionArgs)
.AddScalarCollectionField("versions", schema => schema.PastVersions, versionArgs)
.AddObjectCollectionField(schema => schema.Customers, customersArgs, customerSelectionSet)
.AddObjectCollectionField("foobar", schema => schema.Customers, customersArgs, customerSelectionSet)
.Build();
var expectedCustomerSelectionSet = new SelectionSet <Customer>(new List <ISelectionSetItem>
{
new ScalarFieldSelectionItem(null, nameof(Customer.Id))
});
var expectedSchemaSelections = new List <ISelectionSetItem>
{
new ScalarFieldSelectionItem(null, nameof(SimpleSchema.PastVersions), expectedVersionArgs),
new ScalarFieldSelectionItem("versions", nameof(SimpleSchema.PastVersions), expectedVersionArgs),
new ObjectFieldSelectionItem(null, nameof(SimpleSchema.Customers), expectedCustomersArgs,
expectedCustomerSelectionSet),
new ObjectFieldSelectionItem("foobar", nameof(SimpleSchema.Customers), expectedCustomersArgs,
expectedCustomerSelectionSet),
};
queryOperation.Should().NotBeNull();
queryOperation.SelectionSet.Selections.Should().BeEquivalentTo(expectedSchemaSelections,
options => options.RespectingRuntimeTypes());
}
private object GetValueForArgument(IArgument arg)
{
if (_pr.IsSet(arg))
{
return(arg.Parse(_pr.GetValue(arg), true));
}
// if( !arg.Optional )
// throw new Exception( $"non-optional argument {arg.Name} not set in parser result" );
return(null);
}
public void buildExchangeItemFromTheme()
{
Console.Write("Begin BuildExchangeItemFromTheme Test...");
//create the his component
DbReader his = new DbReader();
IArgument[] arguments = new IArgument[2];
arguments[0] = new Argument("DbPath", @"../../../../../Databases/MyDataRepository.sqlite", true, "Database");
arguments[1] = new Argument("Relaxation", "1", true, "Time interpolation factor, btwn 0(linear inter.) and 1(nearest neigbor)");
his.Initialize(arguments);
Console.Write("BuildExchangeItemFromTheme Finished Successfully.");
}
/// <summary>
/// NumArgs must not equal zero.
/// </summary>
/// <param name="attr"></param>
/// <returns></returns>
private static Exception NumArgsGreaterThanZeroCheck(IArgument attr)
{
if (attr.NumArgs == 0 && attr.Constraint != NumArgsConstraint.AtLeast)
{
return(new ArgumentIntegrityException(
"A NumArgs value of zero may only be the lower bound " +
"on the number of arguments (NumArgsConstraint.AtLeast). " +
"Any actions that do not require arguments will " +
"ignore this property regardless of its value."));
}
return(null);
}
public void ExecuteSqlRuntimeTask_InvalidID(DatabaseType dbType)
{
var dt = new DataTable();
dt.Columns.Add("Lawl");
dt.Rows.Add(new object[] { 2 });
var db = GetCleanedServer(dbType);
var tbl = db.CreateTable("Fish", dt);
Import(tbl, out var ti, out var cols);
string sql = @"UPDATE {T:0} Set {C:0} = 1";
IRuntimeTask task;
IProcessTask pt;
var dir = LoadDirectory.CreateDirectoryStructure(new DirectoryInfo(TestContext.CurrentContext.TestDirectory), "ExecuteSqlFileRuntimeTaskTests", true);
var sqlArg = new IArgument[] { Mock.Of <IArgument>(x =>
x.Name == "Sql" &&
x.Value == sql &&
x.GetValueAsSystemType() == sql) };
var args = new RuntimeArgumentCollection(sqlArg, new StageArgs(LoadStage.AdjustRaw, db, dir));
pt = Mock.Of <IProcessTask>(x =>
x.Path == typeof(ExecuteSqlMutilation).FullName &&
x.GetAllArguments() == sqlArg
);
task = new MutilateDataTablesRuntimeTask(pt, args, CatalogueRepository.MEF);
task.Check(new ThrowImmediatelyCheckNotifier());
HICDatabaseConfiguration configuration = new HICDatabaseConfiguration(db.Server);
var job = new ThrowImmediatelyDataLoadJob();
job.RegularTablesToLoad = new List <ITableInfo> {
ti
};
job.LookupTablesToLoad = new List <ITableInfo>();
job.Configuration = configuration;
var ex = Assert.Throws <Exception>(() => task.Run(job, new GracefulCancellationToken()));
StringAssert.Contains("Mutilate failed", ex.Message);
StringAssert.Contains("Failed to find a TableInfo in the load with ID 0", ex.InnerException.Message);
task.LoadCompletedSoDispose(Core.DataLoad.ExitCodeType.Success, new ThrowImmediatelyDataLoadEventListener());
}
private bool ReadArgument(PropertyInfo pi, Type type, out object value)
{
value = null;
ArgumentAttribute aa = pi.GetCustomAttribute <ArgumentAttribute>( );
if (aa == null)
{
return(false);
}
IOption opt = null;
if (!string.IsNullOrEmpty(aa.Of))
{
opt = GetOptionForName(aa.Of);
}
string argName = pi.Name;
if (opt != null)
{
argName = argName.Replace(
_specDeriverConfig.PropertyNamingStyle.ToString(opt.Name),
string.Empty);
}
IArgument arg = (opt?.Arguments ?? _spec.Arguments).FirstOrDefault(a => a.Name == argName)
?? (_spec.DynamicArgument != null && _spec.DynamicArgument.Name == argName
? _spec.DynamicArgument
: _spec.Options.FirstOrDefault(o => o.DynamicArgument != null && o.DynamicArgument.Name == argName)
?.DynamicArgument);
if (arg == null)
{
throw new Exception($"spec does not contain an {nameof( IArgument )} with name {argName}");
}
if (arg.IsDynamicArgument)
{
value = GetValueForDynamicArgument(arg);
}
else if (type.IsNullableType( ))
{
value = GetValueForNullableArgument(arg, type);
}
else
{
value = GetValueForArgument(arg);
}
return(true);
}
/// <summary>
/// For the given <see cref="argument"/>,
/// execute <see cref="operandFunc"/> when <see cref="Operand"/>
/// and <see cref="optionFunc"/> when <see cref="Option"/>
/// </summary>
public static TResult?SwitchFunc <TResult>(
this IArgument argument,
Func <Operand, TResult>?operandFunc = null,
Func <Option, TResult>?optionFunc = null)
where TResult : class
{
return(argument switch
{
null => throw new ArgumentNullException(nameof(argument)),
Operand operand => operandFunc?.Invoke(operand),
Option option => optionFunc?.Invoke(option),
_ => throw new ArgumentException(BuildExMessage(argument))
});
/// <summary>
/// Positional arguments cannot store const values.
/// </summary>
/// <param name="attr"></param>
/// <returns></returns>
private static Exception PositionalArgumentsCannotStoreConstValues(IArgument attr)
{
if (attr is PositionalArgumentAttribute &&
(attr.Action == ParseAction.StoreConst ||
attr.Action == ParseAction.AppendConst))
{
return(new ArgumentIntegrityException(
String.Format("Positional argument {0} cannot store " +
"const values because the argument will always " +
"be required.", attr.Name)));
}
return(null);
}
/// <summary>
/// Append and AppendConst actions must be convertible to IEnumerable{T}.
/// </summary>
/// <param name="attr"></param>
/// <returns></returns>
private static Exception AppendConvertibleToIEnumerable(IArgument attr)
{
if ((attr.Action == ParseAction.Append ||
attr.Action == ParseAction.AppendConst) &&
!attr.Store.Type.IsValidEnumerable())
{
return(new ArgumentIntegrityException(
"Arguments with a ParseAction of 'Append' " +
"or 'AppendConst' must be attached to a " +
"parameter assignable to IEnumerable<>."));
}
return(null);
}
/// <summary>
/// Const actions cannot have null value.
/// </summary>
/// <param name="attr"></param>
/// <returns></returns>
private static Exception ConstActionsCannotHaveNullValueCheck(IArgument attr)
{
if ((attr.Action == ParseAction.StoreConst ||
attr.Action == ParseAction.AppendConst) &&
attr.Const == attr.Store.Type.GetDefaultValue())
{
return(new ArgumentIntegrityException(
String.Format("Argument {0} with a const action " +
"must be provided with a non-null Const value.",
attr.Name)));
}
return(null);
}
public void Initialize(IArgument[] properties)
{
MsheOrg.Initialize(properties);
string mshefilename = System.IO.Path.Combine(properties.First(a => a.Key == "SetupPath").Value, properties.First(a => a.Key == "SetupFileName").Value);
Model mshe = new Model(mshefilename);
List<double> InnerXValues= new List<double>();
List<double> InnerYValues = new List<double>();
int k=0;
for(int j=0;j<mshe.GridInfo.NumberOfColumns;j++)
for (int i = 0; i < mshe.GridInfo.NumberOfRows; i++)
{
if (mshe.GridInfo.ModelDomainAndGrid.Data[i, j] == 1)
{
InnerXValues.Add(mshe.GridInfo.GetXCenter(j));
InnerYValues.Add(mshe.GridInfo.GetYCenter(i));
InnerIdeces.Add(k);
k++;
}
else if (mshe.GridInfo.ModelDomainAndGrid.Data[i, j] == 2)
k++;
}
DHI.OpenMI.MikeShe.BaseGridElementSet NewBaseGrid = new DHI.OpenMI.MikeShe.BaseGridElementSet(new DHI.MikeShe.Engine.BaseGrid(InnerXValues.Count, InnerXValues.ToArray(), InnerYValues.ToArray(), mshe.GridInfo.GridSize,0));
mshe.Dispose();
for (int i = 0; i < MsheOrg.OutputExchangeItemCount; i++)
{
var org = MsheOrg.GetOutputExchangeItem(i);
if (org.ElementSet.ID == "BaseGrid")
{
OutputExchangeItem onew = new OutputExchangeItem();
onew.Quantity = org.Quantity;
onew.ElementSet = NewBaseGrid;
for (int j = 0; j < org.DataOperationCount; j++)
{
onew.AddDataOperation(org.GetDataOperation(j));
}
OutputExchangeItems.Add(onew);
}
else
{
OutputExchangeItems.Add(org);
}
}
}
private TailViewModel CreateView(FileInfo fileInfo)
{
if (fileInfo == null) throw new ArgumentNullException(nameof(fileInfo));
var fileWatcher = _objectProvider.Get<IFileWatcher>(new IArgument[]
{
new Argument<FileInfo>(fileInfo),
new Argument<IScheduler>(_schedulerProvider.Background)
});
// var combined = _objectProvider.Get<ICombinedSearchMetadataCollection>();
var args = new IArgument[]
{
new Argument<IFileWatcher>(fileWatcher),
// new Argument<ICombinedSearchMetadataCollection>(combined)
};
return _objectProvider.Get<TailViewModel>(args);
}
/// <summary>
/// Gets the value for <paramref name="argument"/> and returns it as an <see cref="Object"/>.
/// </summary>
/// <param name="argument">The argument.</param>
/// <returns>The value for <paramref name="argument"/> as an <see cref="Object"/>.</returns>
/// <exception cref="InvalidOperationArgumentException">
/// May be thrown if the value for the argument cannot be converted to the appropriate type.
/// </exception>
public object GetValueAsObject(IArgument argument)
{
object value;
// TODO: Move this logic into a value provider superclass.
if (argument is FlagArgument)
{
value = GetValue((FlagArgument)argument);
}
else if (argument is IntegerArgument)
{
// Note: this can throw an InvalidOperationArgumentException.
value = GetValue((IntegerArgument)argument);
}
else if (argument is StringArgument)
{
value = GetValue((StringArgument)argument);
}
else
{
throw new Exception("This should not happen.");
}
return value;
}
public ElementSetGridRegularPoints(
ParametersGridRegular grid,
Located location,
bool fastN)
: base(new SpatialDefinition(new Describes("Regular Grid Points", "Point set specified on a regular grid"), -1), ElementType.Point)
{
GridParameters = grid.Clone() as ParametersGridRegular;
PointsLocated = location;
FastN = fastN;
ElementCount = PointsLocated == Located.CellCentre
? grid.CellCountX * grid.CellCountY
: (grid.CellCountX + 1) * (grid.CellCountY + 1);
Caption = string.Format("Regular Grid {0}x{1} ({2}, {3})",
GridParameters.CellCountX, GridParameters.CellCountY,
PointsLocated.ToString(), ElementCount.ToString());
Arguments = new IArgument[] {
new ArgumentGridRegular(new Identity("Grid Parameters"), GridParameters),
}.ToList();
ElementType = ElementType.Point;
}
protected virtual ValidArgumentMessage ValidArgumentValue(IArgument arg, out string message)
{
message = string.Empty;
return ValidArgumentMessage.OK;
}
private bool DeleteArgument(IArgument argument)
{
if (argument == null) throw new ArgumentNullException(nameof(argument));
//Delete the corresponding variable
var variable = Variables.FirstOrDefault(v => v.Id == argument.Id);
if (variable != null && variable.CanDelete())
{
if (variable.Delete())
{
Arguments.Remove(argument);
MarkDirty();
return true;
}
}
return false;
}
/// <summary>
/// Initializes a new instance of the <see cref="ArgumentExclusivityException"/> class.
/// </summary>
/// <param name="violatedArgument">The violated argument.</param>
public ArgumentExclusivityException(IArgument violatedArgument)
: base(violatedArgument)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ArgumentExclusivityException"/> class.
/// </summary>
/// <param name="violatedArgument">The violated argument.</param>
/// <param name="message">The message.</param>
public ArgumentExclusivityException(IArgument violatedArgument, string message)
: base(violatedArgument, message)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ArgumentExclusivityException"/> class.
/// </summary>
/// <param name="violatedArgument">The violated argument.</param>
/// <param name="message">The message.</param>
/// <param name="innerException">The inner exception.</param>
public ArgumentExclusivityException(IArgument violatedArgument, string message, Exception innerException)
: base(violatedArgument, message, innerException)
{
}
/// <summary>
/// A constructor for the argument exception.
/// </summary>
/// <param name="argument">The argument cauring the exception.</param>
/// <param name="message">A message describing the exception.</param>
/// <param name="innerException">An inner exception associated with this exception.</param>
public ArgumentException(IArgument argument, string message, Exception innerException)
: base(message, innerException)
{
Argument = argument;
}
/// <summary>
/// A constructor for the argument exception.
/// </summary>
/// <param name="argument">The argument cauring the exception.</param>
/// <param name="message">A message describing the exception.</param>
public ArgumentException(IArgument argument, string message)
: base(message)
{
Argument = argument;
}
/// <summary>
/// A constructor for the argument exception.
/// </summary>
/// <param name="argument">The argument cauring the exception.</param>
public ArgumentException(IArgument argument)
: base()
{
Argument = argument;
}
public void Initialize(IArgument[] properties)
{
// TODO: Add Trigger.Initialize implementation
}
public virtual void VisitArgument(IArgument operation)
{
DefaultVisit(operation);
}
public void SetUp()
{
_argument = MockRepository.GenerateMock<IArgument>();
_stringParser = MockRepository.GenerateStrictMock<IStringParser>();
}
// ----------------------------------------------------------------------
public void CopyTo( IArgument[] array, int index )
{
InnerList.CopyTo( array, index );
}
