private static string GenerateRoxygenBlock(string functionName, IFunctionDefinition fd, string lineBreak) { var sb = new StringBuilder(); IFunctionInfo fi = fd.MakeFunctionInfo(functionName); if (fi != null && fi.Signatures.Count > 0) { sb.Append(Invariant($"#' Title{lineBreak}")); sb.Append(Invariant($"#'{lineBreak}")); int length = sb.Length; foreach (var p in fi.Signatures[0].Arguments) { if (!string.IsNullOrEmpty(p.Name)) { sb.Append(Invariant($"#' @param {p.Name}{lineBreak}")); } } if (sb.Length > length) { sb.Append(Invariant($"#'{lineBreak}")); } sb.Append(Invariant($"#' @return{lineBreak}")); sb.Append(Invariant($"#' @export{lineBreak}")); sb.Append(Invariant($"#'{lineBreak}")); sb.Append("#' @examples"); } return sb.ToString(); }
public FunctionDocumentation(string libName, ResourceKeyStack messagePath, IFunctionDefinition func) { _libName = libName; _name = func.Name; _arguments = func.Arguments; _returnType = func.ReturnType; _messagePath = messagePath.BranchFor(func); _description=_messagePath.Description; _category = CategoryHelper.GetCategory(func.GetType()); }
private static IFunctionInstance CreateFunctionInstance(IFunctionDefinition func, IDictionary <string, object> parameters) { var context = new FunctionInstanceFactoryContext { Id = Guid.NewGuid(), ParentId = null, ExecutionReason = ExecutionReason.HostCall, Parameters = parameters }; return(func.InstanceFactory.Create(context)); }
public static IFunctionInfo MakeFunctionInfo(this IFunctionDefinition fd, string functionName, bool isInternal) { if (fd != null) { var fi = new FunctionInfo(functionName, isInternal) { Signatures = new [] { fd.MakeSignature(functionName) } }; return(fi); } return(null); }
public static FunctionEvaluationException WrongParameter(IFunctionDefinition function, int paramterIndex, object parameter) { string msg = String.Format("Can't evaluate function {0} expected {1} but found {2} on argument {3}({4})", function.Name, function.Arguments[paramterIndex].Type.Name, parameter.GetType().Name, function.Arguments[paramterIndex].Name, paramterIndex ); return new FunctionEvaluationException(msg); }
private static IFunctionDefinition ResolveFunctionDefinition(MethodInfo method, IFunctionIndexLookup functionLookup) { IFunctionDefinition function = functionLookup.Lookup(method); if (function == null) { string msg = String.Format(CultureInfo.CurrentCulture, "'{0}' can't be invoked from Azure WebJobs SDK. Is it missing Azure WebJobs SDK attributes?", method); throw new InvalidOperationException(msg); } return(function); }
protected override string InputParameterType(int i, Invocation invocation, GrGenType ownerType) { if (invocation is RuleInvocation) { RuleInvocation ruleInvocation = (RuleInvocation)invocation; IAction action = SequenceBase.GetAction(ruleInvocation); return(TypesHelper.DotNetTypeToXgrsType(action.RulePattern.Inputs[i])); } else if (invocation is SequenceInvocation) { SequenceSequenceCallInterpreted seqInvocation = (SequenceSequenceCallInterpreted)invocation; if (seqInvocation.SequenceDef is SequenceDefinitionInterpreted) { SequenceDefinitionInterpreted seqDef = (SequenceDefinitionInterpreted)seqInvocation.SequenceDef; return(seqDef.InputVariables[i].Type); } else { SequenceDefinitionCompiled seqDef = (SequenceDefinitionCompiled)seqInvocation.SequenceDef; return(TypesHelper.DotNetTypeToXgrsType(seqDef.SeqInfo.ParameterTypes[i])); } } else if (invocation is ProcedureInvocation) { ProcedureInvocation procInvocation = (ProcedureInvocation)invocation; if (ownerType != null) { IProcedureDefinition procDef = ownerType.GetProcedureMethod(procInvocation.Name); return(TypesHelper.DotNetTypeToXgrsType(procDef.Inputs[i])); } else { SequenceComputationProcedureCallInterpreted procInvocationInterpreted = (SequenceComputationProcedureCallInterpreted)procInvocation; return(TypesHelper.DotNetTypeToXgrsType(procInvocationInterpreted.ProcedureDef.Inputs[i])); } } else if (invocation is FunctionInvocation) { FunctionInvocation funcInvocation = (FunctionInvocation)invocation; if (ownerType != null) { IFunctionDefinition funcDef = ownerType.GetFunctionMethod(funcInvocation.Name); return(TypesHelper.DotNetTypeToXgrsType(funcDef.Inputs[i])); } else { SequenceExpressionFunctionCallInterpreted funcInvocationInterpreted = (SequenceExpressionFunctionCallInterpreted)funcInvocation; return(TypesHelper.DotNetTypeToXgrsType(funcInvocationInterpreted.FunctionDef.Inputs[i])); } } throw new Exception("Internal error"); }
protected override int NumInputParameters(Invocation invocation, InheritanceType ownerType) { if (invocation is RuleInvocation) { RuleInvocation ruleInvocation = (RuleInvocation)invocation; IAction action = SequenceBase.GetAction(ruleInvocation); return(action.RulePattern.Inputs.Length); } else if (invocation is SequenceInvocation) { SequenceSequenceCallInterpreted seqInvocation = (SequenceSequenceCallInterpreted)invocation; if (seqInvocation.SequenceDef is SequenceDefinitionInterpreted) { SequenceDefinitionInterpreted seqDef = (SequenceDefinitionInterpreted)seqInvocation.SequenceDef; return(seqDef.InputVariables.Length); } else { SequenceDefinitionCompiled seqDef = (SequenceDefinitionCompiled)seqInvocation.SequenceDef; return(seqDef.SeqInfo.ParameterTypes.Length); } } else if (invocation is ProcedureInvocation) { ProcedureInvocation procInvocation = (ProcedureInvocation)invocation; if (ownerType != null) { IProcedureDefinition procDef = ownerType.GetProcedureMethod(procInvocation.Name); return(procDef.Inputs.Length); } else { SequenceComputationProcedureCallInterpreted procInvocationInterpreted = (SequenceComputationProcedureCallInterpreted)procInvocation; return(procInvocationInterpreted.ProcedureDef.Inputs.Length); } } else if (invocation is FunctionInvocation) { FunctionInvocation funcInvocation = (FunctionInvocation)invocation; if (ownerType != null) { IFunctionDefinition funcDef = ownerType.GetFunctionMethod(funcInvocation.Name); return(funcDef.Inputs.Length); } else { SequenceExpressionFunctionCallInterpreted funcInvocationInterpreted = (SequenceExpressionFunctionCallInterpreted)funcInvocation; return(funcInvocationInterpreted.FunctionDef.Inputs.Length); } } throw new Exception("Internal error"); }
public override SequenceExpressionFunctionCall CreateSequenceExpressionFunctionCallUserFunction(String functionName, String packagePrefix, List <SequenceExpression> argExprs) { String packagePrefixedFunctionName = !PackageIsNullOrGlobal(packagePrefix) ? packagePrefix + "::" + functionName : functionName; IFunctionDefinition functionDef = actions.GetFunctionDefinition(packagePrefixedFunctionName); if (functionDef == null) { throw new SequenceParserException(packagePrefixedFunctionName, DefinitionType.Function, SequenceParserError.UnknownFunction); } return(new SequenceExpressionFunctionCallInterpreted(functionDef, argExprs)); }
public static FunctionEvaluationException WrongParameter(IFunctionDefinition function, int paramterIndex, object parameter) { string msg = String.Format("Can't evaluate function {0} expected {1} but found {2} on argument {3}({4})", function.Name, function.Arguments[paramterIndex].Type.Name, parameter.GetType().Name, function.Arguments[paramterIndex].Name, paramterIndex ); return(new FunctionEvaluationException(msg)); }
/// <summary> /// Instantiates a new FunctionInvocationParameterBindings object /// </summary> /// <param name="functionDef">The defined function to be used</param> /// <param name="argExprs">An array of expressions used to compute the arguments</param> /// <param name="arguments">An array of arguments.</param> public FunctionInvocationParameterBindings(IFunctionDefinition functionDef, SequenceExpression[] argExprs, object[] arguments) : base(argExprs, arguments) { FunctionDef = functionDef; if (functionDef != null) { Name = functionDef.Name; PrePackage = functionDef.Package; Package = PrePackage; PackagePrefixedName = Package != null ? Package + "::" + Name : Name; } }
public static IFunctionSignature GetFunctionSignature(this IFunctionDefinition fd) { TypeRegistry.DefaultRegistry.TryGetTypeByName(fd.Typename, out var returnType); List <TypeId> paramTypes = new List <TypeId>(); foreach (var paramTypeName in fd.ParameterDeclarations.ParameterDeclarations.Select(item => item.TypeName)) { if (TypeRegistry.DefaultRegistry.TryGetTypeByName(paramTypeName, out var paramTid)) { paramTypes.Add(paramTid.TypeId); } } return(new FunctionSignature(fd.Name, returnType?.TypeId, paramTypes.ToArray())); }
public void Add(IFunctionDefinition function, FunctionDescriptor descriptor, MethodInfo method) { string id = descriptor.Id; if (_functionsById.ContainsKey(id)) { throw new InvalidOperationException("Method overloads are not supported. " + "There are multiple methods with the name '" + id + "'."); } _functionsById.Add(id, function); _functionsByMethod.Add(method, function); _functionDescriptors.Add(descriptor); }
public void Add(IFunctionDefinition function, FunctionDescriptor descriptor, MethodInfo method) { string id = descriptor.Id; if (_functionsById.ContainsKey(id)) { throw new InvalidOperationException("Method overloads are not supported. " + "There are multiple methods with the name '" + id + "'."); } _functionsById.Add(id, function); _functionsByMethod.Add(method, function); _functionDescriptors.Add(descriptor); }
private async Task CallAsyncCore(MethodInfo method, IDictionary <string, object> arguments, CancellationToken cancellationToken) { await EnsureHostStartedAsync(cancellationToken); IFunctionDefinition function = ResolveFunctionDefinition(method, _context.FunctionLookup); IFunctionInstance instance = CreateFunctionInstance(function, arguments); IDelayedException exception = await _context.Executor.TryExecuteAsync(instance, cancellationToken); if (exception != null) { exception.Throw(); } }
/// <summary>Calls a job method.</summary> /// <param name="name">The name of the function to call.</param> /// <param name="arguments">The argument names and values to bind to parameters in the job method. In addition to parameter values, these may also include binding data values. </param> /// <param name="cancellationToken">The token to monitor for cancellation requests.</param> /// <returns>A <see cref="Task"/> that will call the job method.</returns> public async Task CallAsync(string name, IDictionary <string, object> arguments = null, CancellationToken cancellationToken = default(CancellationToken)) { if (name == null) { throw new ArgumentNullException(nameof(name)); } ThrowIfDisposed(); await EnsureHostInitializedAsync(cancellationToken); IFunctionDefinition function = _context.FunctionLookup.LookupByName(name); await CallAsyncCore(function, name, arguments, cancellationToken); }
private async Task CallAsyncCore(IFunctionDefinition function, object functionKey, IDictionary <string, object> arguments, CancellationToken cancellationToken) { Validate(function, functionKey); IFunctionInstance instance = CreateFunctionInstance(function, arguments); IDelayedException exception = null; exception = await _context.Executor.TryExecuteAsync(instance, cancellationToken); if (exception != null) { exception.Throw(); } }
private void GuardParams(IFunctionDefinition function) { var functionArguments = function.Arguments; if (functionArguments.Length == 0) { return; } for (var i = 0; i < functionArguments.Length - 1; i++) { if (functionArguments[i].Params) { throw new ArgumentException($"Only last argument of a function can be a params argument. Argument {functionArguments[i].Name} of {function.Name} is in violation."); } } }
private static bool DetermineFunction(AstRoot ast, int position, out IFunctionDefinition fd, out IVariable v, out FunctionCall fc) { fd = ast.FindFunctionDefinition(position, out v); fc = null; if (fd == null) { fc = ast.GetNodeOfTypeFromPosition <FunctionCall>(position); var name = fc.GetFunctionName(); if (string.IsNullOrEmpty(name) || !_s4FunctionNames.Contains(name)) { fc = null; } } return(fd != null || fc != null); }
public void TestNoAutoTrigger1() { var entry = IndexMethod("NoAutoTrigger1"); Assert.NotNull(entry); IFunctionDefinition definiton = entry.Item2; Assert.NotNull(definiton); Assert.Null(definiton.ListenerFactory); FunctionDescriptor descriptor = entry.Item1; Assert.NotNull(descriptor); var parameters = descriptor.Parameters; Assert.Single(parameters); Assert.IsType <BlobParameterDescriptor>(parameters.First()); }
public void TestNoAutoTrigger2() { var entry = IndexMethod("NoAutoTrigger2"); Assert.NotNull(entry); IFunctionDefinition definiton = entry.Item2; Assert.NotNull(definiton); Assert.Null(definiton.ListenerFactory); FunctionDescriptor descriptor = entry.Item1; Assert.NotNull(descriptor); var parameters = descriptor.Parameters; Assert.Equal(2, parameters.Count()); Assert.IsType <CallerSuppliedParameterDescriptor>(parameters.ElementAt(0)); Assert.IsType <CallerSuppliedParameterDescriptor>(parameters.ElementAt(1)); }
private IFunctionInstance CreateFunctionInstance(CallAndOverrideMessage message) { IFunctionDefinition function = _functionLookup.Lookup(message.FunctionId); if (function == null) { return(null); } IDictionary <string, object> objectParameters = new Dictionary <string, object>(); if (message.Arguments != null) { foreach (KeyValuePair <string, string> item in message.Arguments) { objectParameters.Add(item.Key, item.Value); } } return(function.InstanceFactory.Create(message.Id, message.ParentId, message.Reason, objectParameters)); }
protected override int NumInputParameters(Invocation invocation, GrGenType ownerType) { if (invocation is RuleInvocation) { RuleInvocation ruleInvocation = (RuleInvocation)invocation; return(actionsTypeInformation.rulesToInputTypes[ruleInvocation.PackagePrefixedName].Count); } else if (invocation is SequenceInvocation) { SequenceInvocation seqInvocation = (SequenceInvocation)invocation; return(actionsTypeInformation.sequencesToInputTypes[seqInvocation.PackagePrefixedName].Count); } else if (invocation is ProcedureInvocation) { ProcedureInvocation procInvocation = (ProcedureInvocation)invocation; if (ownerType != null) { IProcedureDefinition procDef = ownerType.GetProcedureMethod(procInvocation.Name); return(procDef.Inputs.Length); } else { return(actionsTypeInformation.proceduresToInputTypes[procInvocation.PackagePrefixedName].Count); } } else if (invocation is FunctionInvocation) { FunctionInvocation funcInvocation = (FunctionInvocation)invocation; if (ownerType != null) { IFunctionDefinition funcDef = ownerType.GetFunctionMethod(funcInvocation.Name); return(funcDef.Inputs.Length); } else { return(actionsTypeInformation.functionsToInputTypes[funcInvocation.PackagePrefixedName].Count); } } throw new Exception("Internal error"); }
protected override string InputParameterType(int i, Invocation invocation, GrGenType ownerType) { if (invocation is RuleInvocation) { RuleInvocation ruleInvocation = (RuleInvocation)invocation; return(actionsTypeInformation.rulesToInputTypes[ruleInvocation.PackagePrefixedName][i]); } else if (invocation is SequenceInvocation) { SequenceInvocation seqInvocation = (SequenceInvocation)invocation; return(actionsTypeInformation.sequencesToInputTypes[seqInvocation.PackagePrefixedName][i]); } else if (invocation is ProcedureInvocation) { ProcedureInvocation procInvocation = (ProcedureInvocation)invocation; if (ownerType != null) { IProcedureDefinition procDef = ownerType.GetProcedureMethod(procInvocation.Name); return(TypesHelper.DotNetTypeToXgrsType(procDef.Inputs[i])); } else { return(actionsTypeInformation.proceduresToInputTypes[procInvocation.PackagePrefixedName][i]); } } else if (invocation is FunctionInvocation) { FunctionInvocation funcInvocation = (FunctionInvocation)invocation; if (ownerType != null) { IFunctionDefinition funcDef = ownerType.GetFunctionMethod(funcInvocation.Name); return(TypesHelper.DotNetTypeToXgrsType(funcDef.Inputs[i])); } else { return(actionsTypeInformation.functionsToInputTypes[funcInvocation.PackagePrefixedName][i]); } } throw new Exception("Internal error"); }
/// <summary>Calls a job method.</summary> /// <param name="name">The name of the function to call.</param> /// <param name="arguments">The argument names and values to bind to parameters in the job method. In addition to parameter values, these may also include binding data values. </param> /// <param name="cancellationToken">The token to monitor for cancellation requests.</param> /// <returns>A <see cref="Task"/> that will call the job method.</returns> public async Task CallAsync(string name, IDictionary <string, object> arguments = null, CancellationToken cancellationToken = default(CancellationToken)) { if (name == null) { throw new ArgumentNullException(nameof(name)); } ThrowIfDisposed(); await EnsureHostInitializedAsync(cancellationToken); IFunctionDefinition function = _context.FunctionLookup.LookupByName(name); Validate(function, name); IFunctionInstance instance = CreateFunctionInstance(function, arguments); IDelayedException exception = await _context.Executor.TryExecuteAsync(instance, cancellationToken); if (exception != null) { exception.Throw(); } }
public VFunction(IFunctionDefinition funDef) : this(funDef.name) { foreach (var arg in funDef.arguments) { AddArgument(arg.varName); } foreach (var v in funDef.variables) { AddVariable(v.varName); } foreach (var statement in funDef.statements) { var velement = VElementBuilder.Create(statement); AddExpression(velement); } var sourceVariables = vvariables.Concat(varguments).ToList(); foreach (var @ref in refs) { var variable = sourceVariables.FirstOrDefault(x => x.varName == @ref.markInitVarName); variable.AttachVarRef(@ref); } }
public void RemoveFunction(IFunctionDefinition fd) => Functions.Remove(fd);
internal Function(IFunctionDefinition function) { _function = function; }
private String BuildParameters(InvocationParameterBindings paramBindings, IFunctionDefinition functionMethod) { String parameters = ""; for(int i = 0; i < paramBindings.ArgumentExpressions.Length; i++) { if(paramBindings.ArgumentExpressions[i] != null) { String typeName = TypesHelper.DotNetTypeToXgrsType(functionMethod.Inputs[i]); String cast = "(" + TypesHelper.XgrsTypeToCSharpType(typeName, model) + ")"; parameters += ", " + cast + GetSequenceExpression(paramBindings.ArgumentExpressions[i], null); } else { // the sequence parser always emits all argument expressions, for interpreted and compiled throw new Exception("Internal error: missing argument expressions"); } } return parameters; }
public void AddFunction(IFunctionDefinition fd) => Functions.Add(fd);
public MathFunctionParser(IFunctionDefinition func) { _func = func; }
/// <summary> /// Instantiates a new FunctionInvocationParameterBindings object /// </summary> /// <param name="functionDef">The defined function to be used</param> /// <param name="argExprs">An array of expressions used to compute the arguments</param> /// <param name="arguments">An array of arguments.</param> public FunctionInvocationParameterBindings(IFunctionDefinition functionDef, SequenceExpression[] argExprs, object[] arguments) : base(argExprs, arguments) { FunctionDef = functionDef; if(functionDef != null) { Name = functionDef.Name; PrePackage = functionDef.Package; Package = PrePackage; PackagePrefixedName = Package != null ? Package + "::" + Name : Name; } }
public static IFunctionDefinition CreateFunction(object instance, MethodInfo method) { var parameters = method.GetParameters(); var parameterTypes = method.GetParameters().Convert(p => p.ParameterType); int outParameterCount = parameters.Count(p => p.IsOut); Type functionType; if (method.ReturnType == typeof(void)) { switch (parameterTypes.Length) { default: case 0: functionType = typeof(FunctionDefinition); break; case 1: functionType = typeof(FunctionInDefinition <>).MakeGenericType(parameterTypes); break; case 2: if (outParameterCount == 2) { functionType = typeof(FunctionOutDefinition <,>).MakeGenericType(parameterTypes); } else { functionType = typeof(FunctionInDefinition <,>).MakeGenericType(parameterTypes); } break; case 3: if (outParameterCount == 3) { functionType = typeof(FunctionOutDefinition <, ,>).MakeGenericType(parameterTypes); } else { functionType = typeof(FunctionInDefinition <, ,>).MakeGenericType(parameterTypes); } break; case 4: functionType = typeof(FunctionInDefinition <, , ,>).MakeGenericType(parameterTypes); break; case 5: functionType = typeof(FunctionInDefinition <, , ,>).MakeGenericType(parameterTypes); break; } } else { switch (parameterTypes.Length) { default: case 0: functionType = typeof(FunctionOutDefinition <>).MakeGenericType(method.ReturnType); break; case 1: functionType = typeof(FunctionInOutDefinition <,>).MakeGenericType(parameterTypes.Joined(method.ReturnType)); break; case 2: functionType = typeof(FunctionInOutDefinition <, ,>).MakeGenericType(parameterTypes.Joined(method.ReturnType)); break; case 3: functionType = typeof(FunctionInOutDefinition <, , ,>).MakeGenericType(parameterTypes.Joined(method.ReturnType)); break; case 4: functionType = typeof(FunctionInOutDefinition <, , , ,>).MakeGenericType(parameterTypes.Joined(method.ReturnType)); break; case 5: functionType = typeof(FunctionInOutDefinition <, , , , ,>).MakeGenericType(parameterTypes.Joined(method.ReturnType)); break; } } IFunctionDefinition function = null; try { if (method.IsStatic) { function = (IFunctionDefinition)Activator.CreateInstance(functionType, null, method); } else { function = (IFunctionDefinition)Activator.CreateInstance(functionType, instance, method); } } catch { } return(function); }
private void SubstituteFunctionDefinitions(IFunctionCollection classDefinition, List <IFunctionDefinition> fdg, IFunctionDefinition combinedFunction) { foreach (var fd in fdg) { classDefinition.RemoveFunction(fd); } classDefinition.AddFunction(combinedFunction); }
public ResourceKeyStack BranchFor(IFunctionDefinition function) { var branch = (ResourceKeyStack)MemberwiseClone(); branch._function = function; return branch; }
internal Function(IFunctionDefinition function) { _function = function; }
private static IFunctionInstance CreateFunctionInstance(IFunctionDefinition func, IDictionary <string, object> parameters) { return(func.InstanceFactory.Create(Guid.NewGuid(), null, ExecutionReason.HostCall, parameters)); }
private static IFunctionInstance CreateFunctionInstance(IFunctionDefinition func, IDictionary<string, object> parameters) { return func.InstanceFactory.Create(Guid.NewGuid(), null, ExecutionReason.HostCall, parameters); }
public void Add(IFunctionDefinition function, FunctionDescriptor descriptor, MethodInfo method) { Functions.Add(descriptor); }
public String BuildParameters(Invocation invocation, SequenceExpression[] ArgumentExpressions, IFunctionDefinition functionMethod, SourceBuilder source) { String parameters = ""; for (int i = 0; i < ArgumentExpressions.Length; i++) { if (ArgumentExpressions[i] != null) { String typeName = TypesHelper.DotNetTypeToXgrsType(functionMethod.Inputs[i]); String cast = "(" + TypesHelper.XgrsTypeToCSharpType(typeName, model) + ")"; parameters += ", " + cast + exprGen.GetSequenceExpression(ArgumentExpressions[i], source); } else { // the sequence parser always emits all argument expressions, for interpreted and compiled throw new Exception("Internal error: missing argument expressions"); } } return(parameters); }
protected void RegisterFunction(IFunctionDefinition function) { functions.Add(function.Name, function); }