/// <summary> /// Initializes a new instance of the <see cref = "MatrixType" /> class. /// </summary> public MatrixType() : base("matrix", 3) { ParameterTypes.Add(typeof(TypeBase)); ParameterTypes.Add(typeof(Literal)); ParameterTypes.Add(typeof(Literal)); }
private ConfigParam AddParam(string key, string description, ParameterTypes type, string section, string defalt, object value, params string[] values) { bool commandLine = commandLineKeys.ContainsKey(section) && commandLineKeys[section].Contains(key); string shortKey = commandLine && commandLineShortKeys.ContainsKey(section) ? commandLineShortKeys[section][key] : null; if (!mParameters.ContainsKey(section)) { mParameters.Add(section, new Dictionary <string, ConfigParam>()); } if (!mParameters[section].ContainsKey(key)) { ConfigParam param = new ConfigParam(key, description, type, section, Group, defalt, commandLine, shortKey, value != null ? value.ToString() : "null", mFile, values); mParameters[section].Add(key, param); return(param); } else { ConfigParam param = mParameters[section][key]; param.AddGroup(Group); if (!param.CommandLine && commandLine) { param.CommandLine = true; } if (param.ShortKey == null && shortKey != null) { param.ShortKey = shortKey; } return(param); } }
protected Parameter GetValidParameter(ParameterTypes parameterTypes = ParameterTypes.String, string key = "myparameter") { var parameter = new Parameter() { Name = "parameter", Key = key, Id = "abc123", ParameterType = EntityHeader <ParameterTypes> .Create(parameterTypes), }; if (parameterTypes == ParameterTypes.State) { parameter.StateSet = new EntityHeader <StateSet>() { Id = "abc123", Text = "dontcare" }; } else if (parameterTypes == ParameterTypes.ValueWithUnit) { parameter.UnitSet = new EntityHeader <UnitSet>() { Id = "abc123", Text = "dontcare" }; } return(parameter); }
public override string GetClepsTypeString() { return(String.Format("fn {0} ({1})", ReturnType.GetClepsTypeString(), String.Join(",", ParameterTypes.Select(p => p.GetClepsTypeString())) )); }
public bool IsCompatibleWith(BasicSignature other) { return(CallingConvention == other.CallingConvention && ((ParameterTypes == null && other.ParameterTypes == null) || ParameterTypes.SequenceEqual(other.ParameterTypes)) && ReturnType.Equals(other.ReturnType)); }
public AllowableStorageContentTypeAttribute(ParameterTypes storageType, bool anyValueButThis = false, bool isRequired = true, string customMessage = "") { StorageType = storageType; IsRequired = isRequired; CustomMessage = customMessage; AnyValueButThis = anyValueButThis; }
public void ParameterTypesNegateTest() { Assert.AreEqual(false, ParameterTypes.NegateObject(true)); Assert.AreEqual("not ok", ParameterTypes.NegateObject("ok")); Assert.AreEqual(-1L, ParameterTypes.NegateObject(1)); Assert.AreEqual("anything but null", ParameterTypes.NegateObject(null)); }
public void Derived_Parameter_Matches(Type _, Func <Type, bool> criteria, int expectedCount) { // We do not care what the Type was, per se, but the Cases should furnish something. _.AssertNotNull(); bool TryReportParameterTypes(IEnumerable <Type> reportedTypes) { OutputHelper.WriteLine( $"Reporting {expectedCount} expected " // ReSharper disable once PossibleNullReferenceException + $"types: {Join(", ", reportedTypes.Select(x => $"'{x.FullName} : {x.BaseType.FullName}'"))}" ); return(true); } var parameterTypes = ParameterTypes.ToArray(); try { parameterTypes.Where(criteria.AssertNotNull()).AssertEqual(expectedCount, x => x.Count()) .AssertTrue(TryReportParameterTypes); } catch (Exception ex) { OutputHelper.WriteLine("Failed to verify derived Parameter matches."); parameterTypes.AssertTrue(TryReportParameterTypes); throw; } }
public string AsNativeName() { var paramTypes = ParameterTypes.Select((t) => t.AsNativeName()); var paramStr = string.Join(",", paramTypes); return($"({paramStr}) => {ReturnType.AsNativeName()}"); }
/// <summary> /// Adds the parameter. /// </summary> /// <param name="parameterType"> /// Type of the parameter. /// </param> /// <param name="value"> /// The value. /// </param> public void AddParameter(ParameterTypes parameterType, object value) { if (!this.Parameters.ContainsKey(parameterType)) { this.Parameters.Add(parameterType, value); } }
public MethodDeclarationSyntax Output() { TypeSyntax retType; if (ReturnType == null) { retType = PredefinedType(Token(SyntaxKind.VoidKeyword)); } else { retType = ReturnType.GenReferenceTo(); } ParameterListSyntax parameters = ParameterList( SeparatedList( ParameterTypes.Select( (pt, i) => Parameter(Identifier($"arg{i}")).WithType(pt.GenReferenceTo())))); return (MethodDeclaration(retType, Name) .WithModifiers(TokenList(Token(SyntaxKind.StaticKeyword))) .WithParameterList(parameters) .WithBody(Body)); }
private ParameterTypesRating GetParameterTypesRating(List <SignatureType> searchParameterTypes) { var parameterRating = new ParameterTypesRating(); if (ParameterTypes.Count == 0 && searchParameterTypes.Count == 0) { parameterRating.AddExactMatch(); } if (ParameterTypes.Count < searchParameterTypes.Count) { return(parameterRating.SetFailed()); } parameterRating.SetGenericParameterCount(ParameterTypes.Count(p => p.IsGeneric)); for (var i = 0; i < ParameterTypes.Count; i++) { var thisType = this.ParameterTypes[i]; if (searchParameterTypes.Count > i) { var otherType = searchParameterTypes[i]; if (otherType.FoundMatchingType == thisType.FoundMatchingType || otherType.FoundMatchingType == typeof(NullObject)) { parameterRating.AddExactMatch(); continue; } if (thisType.FoundMatchingType.IsInterface && TypeHelpers.ImplementsInterface(otherType.FoundMatchingType, thisType.FoundMatchingType)) { parameterRating.AddCastableMatch(); continue; } if (TypeHelpers.IsImplicitCastableTo(otherType.FoundMatchingType, thisType.FoundMatchingType)) { parameterRating.AddCastableMatch(); continue; } if (TypeHelpers.InheritFromClass(otherType.FoundMatchingType, thisType.FoundMatchingType, true, false)) { parameterRating.AddInheritanceLevel(TypeHelpers.InheritFromClassLevel(otherType.FoundMatchingType, thisType.FoundMatchingType)); continue; } return(parameterRating.SetFailed()); } if (!thisType.IsOptional) { return(parameterRating.SetFailed()); } } return(parameterRating); }
public Parameter(string key, string displayName, ParameterTypes type, object defaultValue) { Key = key; DisplayName = displayName; Type = type; DefaultValue = defaultValue; Value = defaultValue; }
public override AstExpression Clone() { return(CopyValuesTo(new AstFunctionTypeExpr( ParameterTypes.Select(p => p.Clone()).ToList(), ReturnType?.Clone(), IsFatFunction, Directives))); }
public override int GetHashCode() { unchecked { return(CallingConvention.GetHashCode() ^ (ParameterTypes != null? ParameterTypes.SequenceHashCode() : 0) ^ ReturnType.GetHashCode()); } }
public MetaFunctionType( IEnumerable <DataType> parameterTypes, DataType resultType) : base(Lifetime.Forever) { ParameterTypes = parameterTypes.ToFixedList(); ResultType = resultType; IsResolved = ParameterTypes.All(pt => pt.IsResolved) && ResultType.IsResolved; }
private BlockSyntax GenBlock(bool root) { _level++; ScopeFrame scope = new ScopeFrame(); _scope.Add(scope); if (root) { scope.Variables.AddRange(ParameterTypes.Select((p, i) => new VariableIdentifier(p, $"arg{i}"))); } BlockSyntax block = Block(GenStatements()); _scope.RemoveAt(_scope.Count - 1); _level--; return(block); IEnumerable <StatementSyntax> GenStatements() { int numStatements = Options.BlockStatementCountDist.Sample(Random.Rng); StatementSyntax retStmt = null; for (int i = 0; i < numStatements; i++) { StatementSyntax stmt = GenStatement(); if (stmt is ReturnStatementSyntax) { retStmt = stmt; break; } yield return(stmt); } if (root && retStmt == null) { retStmt = GenReturn(); } if (Options.EnableChecksumming) { foreach (StatementSyntax stmt in GenChecksumming(scope.Variables, _genChecksumSiteId)) { yield return(stmt); } } if (retStmt != null) { yield return(retStmt); } } }
public HumanTaskDefBuilder AddPresentationParameter(string name, ParameterTypes type, string expression) { _humanTaskDef.PresentationParameters.Add(new PresentationParameter { Expression = expression, Name = name, Type = type }); return(this); }
private ParameterTypes[] ConvertParameterTypes(string[] parameterTypes) { ParameterTypes[] ret = new ParameterTypes[parameterTypes.Length]; for (int i = 0; i < parameterTypes.Length; ++i) { ret[i] = (ParameterTypes)Enum.Parse(typeof(ParameterTypes), parameterTypes[i]); } return(ret); }
public NotificationDefBuilder AddPresentationParameter(string name, ParameterTypes type, string expression) { _notification.PresentationParameters.Add(new PresentationParameter { Expression = expression, Name = name, Type = type }); return(this); }
protected Parameter GetParameter(string name, string key, ParameterTypes parameterType = ParameterTypes.String, string parameterName = "String") { var parameter = new Parameter(); parameter.Name = name; parameter.Key = key; parameter.ParameterType = EntityHeader <ParameterTypes> .Create(parameterType); return(parameter); }
private void Open(object param) { try { if (_model != null) { var cancel = AskSaveCancel(); if (cancel) { return; } } var filePath = _dialogService.ChooseFileToOpen(_fileExtension, _fileFilter); if (filePath == null) { return; } _openFile = filePath; XmlSerializer serializer = new XmlSerializer(typeof(KNX)); using (var reader = new StreamReader(_openFile)) { _model = (KNX)serializer.Deserialize(reader); } _manufacturerData = _model.ManufacturerData.First(); _hardware = _manufacturerData.Hardware.First(); _product = _hardware.Products.First(); _catalogSection = _manufacturerData.Catalog.First(); _catalogItem = _catalogSection.CatalogItem.First(); _hardware2Program = _hardware.Hardware2Programs.First(); _applicationProgram = _manufacturerData.ApplicationPrograms.First(); _appProgRef = _hardware2Program.ApplicationProgramRef.First(); _codeSegment = _applicationProgram.Static.Code.RelativeSegment.First(); var parameterList = _applicationProgram.Static.Parameters.OfType <Parameter_t>(); foreach (var item in parameterList) { item.AllTypes = ParameterTypes; item.Type = ParameterTypes.First(t => t.Id == item.ParameterType); Parameters.Add(item); } RaiseChanged(); } catch (Exception ex) { ClearData(); _dialogService.ShowMessage(ex.ToString()); } }
/// <summary> /// Initializes a new instance of the <see cref="CastMethod" /> class. /// </summary> /// <param name="extendedType">Type of the extended.</param> /// <param name="info">The info.</param> /// <param name="isExplicit">if set to <see langword="true" /> [is explicit].</param> /// <remarks></remarks> internal CastMethod([NotNull] ExtendedType extendedType, [NotNull] MethodInfo info, bool isExplicit) : base(extendedType, info) { Debug.Assert(info.Name == "op_Explicit" || info.Name == "op_Implicit"); IsExplicit = isExplicit; // ReSharper disable once AssignNullToNotNullAttribute FromType = ParameterTypes.First(); Debug.Assert(FromType != null); ToType = ReturnType; Debug.Assert(FromType == extendedType.Type || ToType == extendedType.Type); }
public override bool NotNullObjectEquals(ClepsType obj) { if (obj.GetType() != typeof(FunctionClepsType)) { return(false); } FunctionClepsType objToCompare = obj as FunctionClepsType; return(ReturnType == objToCompare.ReturnType && ParameterTypes.SequenceEqual(objToCompare.ParameterTypes)); }
public NotificationDefBuilder AddInputOperationParameter(string name, ParameterTypes type, bool isRequired) { _notification.OperationParameters.Add(new Parameter { Name = name, Type = type, IsRequired = isRequired, Usage = ParameterUsages.INPUT }); return(this); }
protected WorkflowInput GetInput(string name = "in1", string key = "in1", ParameterTypes parameterType = ParameterTypes.String) { var input = new WorkflowInput(); input.Name = name; input.Key = key; SetAuditParams(input); input.InputType = EntityHeader <ParameterTypes> .Create(parameterType); return(input); }
/// <summary> /// Reads the parameter. /// </summary> /// <param name="parameterType"> /// Type of the parameter. /// </param> /// <returns> /// Return System Object. /// </returns> public object ReadParameter(ParameterTypes parameterType) { object value; if (this.Parameters.TryGetValue(parameterType, out value)) { return(value); } return(null); }
public HumanTaskDefBuilder AddOutputOperationParameter(string name, ParameterTypes type, bool isRequired) { _humanTaskDef.OperationParameters.Add(new Parameter { Name = name, Type = type, IsRequired = isRequired, Usage = ParameterUsages.OUTPUT }); return(this); }
/// <summary> /// Deep clone. /// </summary> public virtual Function Clone() { var result = (Function)MemberwiseClone(); result.ResultType = ResultType.Clone(); result.ParameterTypes = ParameterTypes.Select(p => p.Clone()).ToArray(); if (InputType != null) { result.InputType = InputType.Clone(); } return(result); }
protected object DeserializeReplyInternal(Message message, object[] parameters) { var retParamInfo = ParameterTypes.FirstOrDefault(x => x.ParamType == ParamType.Return); if (retParamInfo == null) { return(null); } var store = ObjectBuilder.GetModelStore(); var serializer = ObjectBuilder.GetSerializer(); var reader = message.GetReaderAtBodyContents(); reader.Read(); var model = store.GetModel(retParamInfo.Type, ModeType.Wcf); if (model == null) { throw new InvalidOperationException("The model cannot be null, meta data fetch failed. Type: " + retParamInfo.Type.FullName); } reader.Read(); var val = reader.Value; var data = BinaryConverter.FromString(val); var compressionType = GetMessageCompressionTypeOptions(message); if (compressionType != CompressionTypeOptions.None) { var compressionProvider = new CompressionProvider(); data = compressionProvider.DeCompress(data, compressionType); } object retVal; try { retVal = serializer.Deserialize(data, model.MetaData, retParamInfo.Type, ModeType.Wcf); } catch (SerializationException) { store.RemoveModel(retParamInfo.Type, ModeType.Wcf); throw; } return(retVal); }