static string BuildArgumentValues( IFunctionInstance function, NamedCollection <IArgumentDeclaration> arguments, INamedExpressionTuple expressions, ICppScope scope, string kind) { if (arguments.IsEmpty()) { return(string.Empty); } var name = scope.MakeLocalName(); var typeName = GetFunctionTypeName(function.Name, kind); scope.Runtime.AddLine($"{typeName} {name};"); var argN = 0; foreach (var expression in expressions.Tuple) { var argument = arguments[argN]; argN++; var value = Dynamic((dynamic)expression.Expression, scope); if (argument.IsAssignable) { scope.Runtime.AddLine($"{name}.{CppEscape(argument.Name)} = &{value};"); } else { scope.Runtime.AddLine($"{name}.{CppEscape(argument.Name)} = {value};"); } } return(name); }
private FunctionStartedMessage CreateStartedMessageWithoutArguments(IFunctionInstance instance) { FunctionStartedMessage message = new FunctionStartedMessage { HostInstanceId = _hostOutputMessage.HostInstanceId, HostDisplayName = _hostOutputMessage.HostDisplayName, SharedQueueName = _hostOutputMessage.SharedQueueName, InstanceQueueName = _hostOutputMessage.InstanceQueueName, Heartbeat = _hostOutputMessage.Heartbeat, WebJobRunIdentifier = _hostOutputMessage.WebJobRunIdentifier, FunctionInstanceId = instance.Id, Function = instance.FunctionDescriptor, ParentId = instance.ParentId, Reason = instance.Reason, StartTime = DateTimeOffset.UtcNow }; // It's important that the host formats the reason before sending the message. // This enables extensibility scenarios. For the built in types, the Host and Dashboard // share types so it's possible (in the case of triggered functions) for the formatting // to require a call to TriggerParameterDescriptor.GetTriggerReason and that can only // be done on the Host side in the case of extensions (since the dashboard doesn't // know about extension types). message.ReasonDetails = message.FormatReason(); return(message); }
public ApplicationInsightsLoggerTests() { _functionCategoryName = LogCategories.CreateFunctionUserCategory(_functionShortName); _endTime = _startTime.AddMilliseconds(_durationMs); _arguments = new Dictionary <string, string> { ["queueMessage"] = "my message", ["anotherParam"] = "some value" }; TelemetryConfiguration config = new TelemetryConfiguration { TelemetryChannel = _channel, InstrumentationKey = "some key" }; // Add the same initializers that we use in the product code DefaultTelemetryClientFactory.AddInitializers(config); _client = new TelemetryClient(config); var descriptor = new FunctionDescriptor { FullName = _functionFullName, ShortName = _functionShortName }; _functionInstance = new FunctionInstance(_invocationId, null, ExecutionReason.AutomaticTrigger, null, null, descriptor); }
public FunctionInstanceTraceWriter(IFunctionInstance instance, Guid hostInstanceId, TraceWriter innerWriter, TraceLevel level) : base(level) { _innerWriter = innerWriter; _instance = instance; _hostInstanceId = hostInstanceId; }
public ApplicationInsightsLoggerTests() { _functionCategoryName = LogCategories.CreateFunctionUserCategory(_functionShortName); _endTime = _startTime.AddMilliseconds(_durationMs); _arguments = new Dictionary <string, string> { ["queueMessage"] = "my message", ["anotherParam"] = "some value" }; _host = new HostBuilder() .ConfigureLogging(b => { b.SetMinimumLevel(LogLevel.Trace); b.AddApplicationInsights(o => { o.InstrumentationKey = "some key"; }); }).Build(); TelemetryConfiguration telemteryConfiguration = _host.Services.GetService <TelemetryConfiguration>(); telemteryConfiguration.TelemetryChannel = _channel; _client = _host.Services.GetService <TelemetryClient>(); var descriptor = new FunctionDescriptor { FullName = _functionFullName, ShortName = _functionShortName }; _functionInstance = new FunctionInstance(_invocationId, new Dictionary <string, string>(), null, ExecutionReason.AutomaticTrigger, null, null, descriptor); }
public async Task <IDelayedException> TryExecuteAsync(IFunctionInstance instance, CancellationToken cancellationToken) { FunctionStartedMessage startedMessage = CreateStartedMessageWithoutArguments(instance); IDictionary <string, ParameterLog> parameterLogCollector = new Dictionary <string, ParameterLog>(); FunctionCompletedMessage completedMessage = null; ExceptionDispatchInfo exceptionInfo = null; string startedMessageId = null; try { startedMessageId = await ExecuteWithLogMessageAsync(instance, startedMessage, parameterLogCollector, cancellationToken); completedMessage = CreateCompletedMessage(startedMessage); } catch (Exception exception) { if (completedMessage == null) { completedMessage = CreateCompletedMessage(startedMessage); } completedMessage.Failure = new FunctionFailure { Exception = exception, ExceptionType = exception.GetType().FullName, ExceptionDetails = exception.ToDetails(), }; exceptionInfo = ExceptionDispatchInfo.Capture(exception); } completedMessage.ParameterLogs = parameterLogCollector; completedMessage.EndTime = DateTimeOffset.UtcNow; bool loggedStartedEvent = startedMessageId != null; CancellationToken logCompletedCancellationToken; if (loggedStartedEvent) { // If function started was logged, don't cancel calls to log function completed. logCompletedCancellationToken = CancellationToken.None; } else { logCompletedCancellationToken = cancellationToken; } await _functionInstanceLogger.LogFunctionCompletedAsync(completedMessage, logCompletedCancellationToken); if (loggedStartedEvent) { await _functionInstanceLogger.DeleteLogFunctionStartedAsync(startedMessageId, cancellationToken); } return(exceptionInfo != null ? new ExceptionDispatchInfoDelayedException(exceptionInfo) : null); }
public ShapeRegularPolygonObject(IFunctionInstance name, int nbOfEdges, double sizeOfEdges, double alpha = 0.0d) : base(name) { this.NumberOfEdges = nbOfEdges; this.SizeOfEdges = sizeOfEdges; this.alpha = alpha; }
private async Task ExecuteWithOutputLogsAsync(IFunctionInstance instance, IReadOnlyDictionary <string, IValueProvider> parameters, TextWriter consoleOutput, IFunctionOutputDefinition outputDefinition, IDictionary <string, ParameterLog> parameterLogCollector, CancellationToken cancellationToken) { IFunctionInvoker invoker = instance.Invoker; IReadOnlyDictionary <string, IWatcher> watches = CreateWatches(parameters); IRecurrentCommand updateParameterLogCommand = outputDefinition.CreateParameterLogUpdateCommand(watches, consoleOutput); using (ITaskSeriesTimer updateParameterLogTimer = StartParameterLogTimer(updateParameterLogCommand, _backgroundExceptionDispatcher)) { try { await ExecuteWithWatchersAsync(invoker, parameters, cancellationToken); if (updateParameterLogTimer != null) { // Stop the watches after calling IValueBinder.SetValue (it may do things that should show up in // the watches). // Also, IValueBinder.SetValue could also take a long time (flushing large caches), and so it's // useful to have watches still running. await updateParameterLogTimer.StopAsync(cancellationToken); } } finally { ValueWatcher.AddLogs(watches, parameterLogCollector); } } }
public Task <IFunctionOutputDefinition> CreateAsync(IFunctionInstance instance, CancellationToken cancellationToken) { IFunctionOutputDefinition outputDefinition = new NullFunctionOutputDefinition(); return(Task.FromResult(outputDefinition)); }
public void TestCase() { Function teleport = new Function("teleport", 0x02); Function wall = new Function("wall", 0x03); Function l = new Function("l", 0x00); IFunctionInstance fiaa = (IFunctionInstance)teleport.CreateInstance(new FunctionIntegerInstance("3"), new FunctionIntegerInstance("3")); IFunctionInstance fiab = (IFunctionInstance)teleport.CreateInstance(new FunctionIntegerInstance("3"), new FunctionIntegerInstance("3")); Assert.IsTrue(fiaa.Equals(fiab)); Assert.IsTrue(fiab.Equals(fiaa)); Assert.AreEqual(fiaa.GetHashCode(), fiaa.GetHashCode()); Assert.AreEqual(fiaa.GetHashCode(), fiab.GetHashCode()); IFunctionInstance fiba = (IFunctionInstance)wall.CreateInstance(new FunctionIntegerInstance("3"), new FunctionIntegerInstance("3"), (IFunctionInstance)l.CreateInstance()); IFunctionInstance fibb = (IFunctionInstance)wall.CreateInstance(new FunctionIntegerInstance("3"), new FunctionIntegerInstance("3"), (IFunctionInstance)l.CreateInstance()); Assert.IsTrue(fiba.Equals(fibb)); Assert.IsTrue(fibb.Equals(fiba)); Assert.AreEqual(fiba.GetHashCode(), fiba.GetHashCode()); Assert.AreEqual(fiba.GetHashCode(), fibb.GetHashCode()); Assert.IsFalse(fiaa.Equals(fiba)); Assert.IsFalse(fiaa.Equals(fibb)); Assert.IsFalse(fiab.Equals(fiba)); Assert.IsFalse(fiab.Equals(fibb)); Assert.IsFalse(fiba.Equals(fiaa)); Assert.IsFalse(fiba.Equals(fiab)); Assert.IsFalse(fibb.Equals(fiaa)); Assert.IsFalse(fibb.Equals(fiab)); }
public async Task <FunctionResult> TryExecuteAsync(TriggeredFunctionData input, CancellationToken cancellationToken) { var context = new FunctionInstanceFactoryContext <TTriggerValue>() { TriggerValue = (TTriggerValue)input.TriggerValue, ParentId = input.ParentId, TriggerDetails = input.TriggerDetails }; if (input.InvokeHandler != null) { context.InvokeHandler = async next => { await input.InvokeHandler(next); // NOTE: The InvokeHandler code path currently does not support flowing the return // value back to the trigger. return(null); }; } IFunctionInstance instance = _instanceFactory.Create(context); IDelayedException exception = await _executor.TryExecuteAsync(instance, cancellationToken); FunctionResult result = exception != null ? new FunctionResult(exception.Exception) : new FunctionResult(true); return(result); }
public async Task <IDelayedException> TryExecuteAsync(IFunctionInstance instance, CancellationToken cancellationToken) { using (CancellationTokenSource callCancellationSource = CancellationTokenSource.CreateLinkedTokenSource( _shutdownToken, cancellationToken)) { return(await _innerExecutor.TryExecuteAsync(instance, callCancellationSource.Token)); } }
public async Task <bool> ExecuteAsync(BrokeredMessage value, CancellationToken cancellationToken) { Guid?parentId = ServiceBusCausalityHelper.GetOwner(value); IFunctionInstance instance = _instanceFactory.Create(value, parentId); IDelayedException exception = await _innerExecutor.TryExecuteAsync(instance, cancellationToken); return(exception == null); }
public async Task<IDelayedException> TryExecuteAsync(IFunctionInstance instance, CancellationToken cancellationToken) { using (CancellationTokenSource callCancellationSource = CancellationTokenSource.CreateLinkedTokenSource( _shutdownToken, cancellationToken)) { return await _innerExecutor.TryExecuteAsync(instance, callCancellationSource.Token); } }
public async Task <bool> ExecuteAsync(IStorageQueueMessage value, CancellationToken cancellationToken) { Guid?parentId = QueueCausalityManager.GetOwner(value); IFunctionInstance instance = _instanceFactory.Create(value, parentId); IDelayedException exception = await _innerExecutor.TryExecuteAsync(instance, cancellationToken); return(exception == null); }
public static IServiceProvider GetInstanceServices(this IFunctionInstance instance) { if (instance is IFunctionInstanceEx functionInstance) { return(functionInstance.InstanceServices); } return(null); }
internal static IDisposable BeginFunctionScope(this ILogger logger, IFunctionInstance functionInstance) { return(logger?.BeginScope( new Dictionary <string, object> { [ScopeKeys.FunctionInvocationId] = functionInstance?.Id, [ScopeKeys.FunctionName] = functionInstance?.FunctionDescriptor?.Method?.Name })); }
public override bool Equals(object obj) { if (obj is IFunctionInstance) { IFunctionInstance ifi = (IFunctionInstance)obj; return(Object.Equals(this.Function, ifi.Function) && this.Terms.AllDual(ifi.Terms, (x, y) => x.Equals(y))); } return(false); }
public async Task <IFunctionOutputDefinition> CreateAsync(IFunctionInstance instance, CancellationToken cancellationToken) { await _outputLogDirectory.Container.CreateIfNotExistsAsync(cancellationToken); string namePrefix = instance.Id.ToString("N"); LocalBlobDescriptor outputBlob = CreateDescriptor(_outputLogDirectory, namePrefix + ".txt"); LocalBlobDescriptor parameterLogBlob = CreateDescriptor(_outputLogDirectory, namePrefix + ".params.txt"); return(new BlobFunctionOutputDefinition(_outputLogDirectory.ServiceClient, outputBlob, parameterLogBlob)); }
internal static IDisposable BeginFunctionScope(this ILogger logger, IFunctionInstance functionInstance) { return(logger?.BeginScope( new Dictionary <string, object> { [ScopeKeys.FunctionInvocationId] = functionInstance?.Id.ToString(), [ScopeKeys.FunctionName] = functionInstance?.FunctionDescriptor?.LogName, [ScopeKeys.Event] = LogConstants.FunctionStartEvent })); }
public async Task<IFunctionOutputDefinition> CreateAsync(IFunctionInstance instance, CancellationToken cancellationToken) { await _outputLogDirectory.Container.CreateIfNotExistsAsync(cancellationToken); string namePrefix = instance.Id.ToString("N"); LocalBlobDescriptor outputBlob = CreateDescriptor(_outputLogDirectory, namePrefix + ".txt"); LocalBlobDescriptor parameterLogBlob = CreateDescriptor(_outputLogDirectory, namePrefix + ".params.txt"); return new BlobFunctionOutputDefinition(_outputLogDirectory.ServiceClient, outputBlob, parameterLogBlob); }
public async Task <FunctionResult> TryExecuteAsync(TriggeredFunctionData input, CancellationToken cancellationToken) { IFunctionInstance instance = _instanceFactory.Create((TTriggerValue)input.TriggerValue, input.ParentId); IDelayedException exception = await _executor.TryExecuteAsync(instance, cancellationToken); FunctionResult result = exception != null ? new FunctionResult(exception.Exception) : new FunctionResult(true); return(result); }
public ShapeIrregularPolygonObject(IFunctionInstance name, IEnumerable<IdpGie.Geometry.Point3> points) : base(name) { this.points = points.ToList (); double minx = double.PositiveInfinity, miny = double.PositiveInfinity, maxx = double.NegativeInfinity, maxy = double.NegativeInfinity; foreach (IdpGie.Geometry.Point3 p in this.points) { minx = Math.Min (minx, p.X); miny = Math.Min (miny, p.Y); maxx = Math.Max (maxx, p.X); maxy = Math.Max (maxy, p.Y); } this.TextOffset = new IdpGie.Geometry.Point3 (0.5d * (minx + maxx), 0.5d * (miny + maxy)); }
static string BuildResultValues(IFunctionInstance function, ICppScope scope, ref string name) { var argumentDeclarations = function.Declaration.Results; if (argumentDeclarations.IsEmpty()) { return(string.Empty); } name = scope.MakeLocalName(); var typeName = GetFunctionTypeName(function.Name, kind: "Result"); return($"{typeName} {name} = "); }
/// <summary> /// Generate an <see cref="IShape"/> hierarchy by stating that the <paramref name="parent"/> is the parent of the <paramref name="child"/>. /// </summary> /// <param name='parent'> /// The associated name of the <see cref="IShape"/> that will become a parent of the <paramref name="child"/>. /// </param> /// <param name='child'> /// The associated name of the <see cref="IShape"/> that will become a child of the <paramref name="parent"/>. /// </param> public void BuildHierarchy(IFunctionInstance parent, IFunctionInstance child) { IShapeHierarchical schild = this.GetShape <IShapeHierarchical> (child); if (schild != null) { IShapeHierarchical sparnt = this.GetShape <IShapeHierarchical> (parent); if (sparnt != null) { schild.Parent = sparnt; } } }
static IExpression ParseResolved( IFunctionInstance function, INamedExpressionTuple leftArguments, IEnumerator <TokenData> tokens, IContext context, ref bool done) { var pool = new List <IFunctionInstance> { function }; return(ParseFunctionOverloads(pool, leftArguments, tokens, context, ref done)); }
/// <summary> /// Gets the shape associated with the given name if the shape is of the type <typeparamref name="TShape"/>, otherwise the default value associated with <typeparamref name="TShape"/> is returned. /// </summary> /// <returns> /// The shape associated with the given name if the shape is of the type <typeparamref name="TShape"/>, otherwise the default value associated with <typeparamref name="TShape"/> is returned. /// </returns> /// <param name='key'> /// The name of the shape to look for. /// </param> /// <typeparam name='TShape'> /// The type of the shape to look for, needs to be a subtype of <see cref="IShape"/>. /// </typeparam> public TShape GetShape <TShape> (IFunctionInstance key) where TShape : IShape { IShape shp = this.objects [key]; if (shp is TShape) { return((TShape)shp); } else { return(default(TShape)); } }
internal static TraceLevel GetFunctionTraceLevel(IFunctionInstance functionInstance) { TraceLevel functionTraceLevel = TraceLevel.Verbose; // Determine the TraceLevel for this function (affecting both Console as well as Dashboard logging) TraceLevelAttribute attribute = TypeUtility.GetHierarchicalAttributeOrNull <TraceLevelAttribute>(functionInstance.FunctionDescriptor.Method); if (attribute != null) { functionTraceLevel = attribute.Level; } return(functionTraceLevel); }
public ShapeIrregularPolygonObject(IFunctionInstance name, IEnumerable <IdpGie.Geometry.Point3> points) : base(name) { this.points = points.ToList(); double minx = double.PositiveInfinity, miny = double.PositiveInfinity, maxx = double.NegativeInfinity, maxy = double.NegativeInfinity; foreach (IdpGie.Geometry.Point3 p in this.points) { minx = Math.Min(minx, p.X); miny = Math.Min(miny, p.Y); maxx = Math.Max(maxx, p.X); maxy = Math.Max(maxy, p.Y); } this.TextOffset = new IdpGie.Geometry.Point3(0.5d * (minx + maxx), 0.5d * (miny + maxy)); }
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(); } }
static IExpression CreateFunctionInvocation( IFunctionInstance function, TextFileRange range, INamedExpressionTuple leftArguments, INamedExpressionTuple rightArguments) { var invocation = new FunctionInvocation { Function = function, Range = range, Left = AssignArguments(function.LeftArguments, leftArguments), Right = AssignArguments(function.RightArguments, rightArguments) }; return(invocation); }
private async Task ProcessCallAndOverrideMessage(CallAndOverrideMessage message, CancellationToken cancellationToken) { IFunctionInstance instance = CreateFunctionInstance(message); if (instance != null) { await _innerExecutor.TryExecuteAsync(instance, cancellationToken); } else { // Log that the function failed. FunctionCompletedMessage failedMessage = CreateFailedMessage(message); await _functionInstanceLogger.LogFunctionCompletedAsync(failedMessage, cancellationToken); } }
internal static IFunctionInvokerEx GetFunctionInvoker(this IFunctionInstance instance) { if (instance.Invoker == null) { return(null); } if (instance.Invoker is IFunctionInvokerEx invoker) { return(invoker); } return(new FunctionInvokerWrapper(instance.Invoker)); }
public async Task<IDelayedException> TryExecuteAsync(IFunctionInstance instance, CancellationToken cancellationToken) { IDelayedException result; using (IListener listener = await _abortListenerFactory.CreateAsync(cancellationToken)) { await listener.StartAsync(cancellationToken); result = await _innerExecutor.TryExecuteAsync(instance, cancellationToken); await listener.StopAsync(cancellationToken); } return result; }
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(); } }
public async Task<IDelayedException> TryExecuteAsync(IFunctionInstance instance, CancellationToken cancellationToken) { IDelayedException result; using (ITaskSeriesTimer timer = CreateHeartbeatTimer(_backgroundExceptionDispatcher)) { await _heartbeatCommand.TryExecuteAsync(cancellationToken); timer.Start(); result = await _innerExecutor.TryExecuteAsync(instance, cancellationToken); await timer.StopAsync(cancellationToken); } return result; }
public static void Polygon(DrawTheory dt, IFunctionInstance name, int nbOfEdges, double sizeOfEdges) { dt.AddShape (new ShapeRegularPolygonObject (name, nbOfEdges, sizeOfEdges)); }
public static void Pos(DrawTheory dt, IFunctionInstance name, double xpos, double ypos, double zpos, double time = double.NaN) { Xpos (dt, name, xpos, time); Ypos (dt, name, ypos, time); Zpos (dt, name, zpos, time); }
public static void RotateZ(DrawTheory dt, IFunctionInstance name, double alpha, double time = double.NaN) { }
public static void Scale(DrawTheory dt, IFunctionInstance name, double xscale, double yscale, double zscale, double time = double.NaN) { Xscale (dt, name, xscale, time); Yscale (dt, name, yscale, time); Zscale (dt, name, zscale, time); }
public static void EdgeColor(DrawTheory dt, IFunctionInstance name, double r, double g, double b, double time = double.NaN) { dt.AddModifier (name, time, x => x.SetElement ("EdgeColor", new Color (r * MathExtra.Inv255, g * MathExtra.Inv255, b * MathExtra.Inv255))); }
public static void Node(DrawTheory dt, IFunctionInstance name, string graph, double time = double.NaN) { }
public static void Text(DrawTheory dt, IFunctionInstance name, string text, double time = double.NaN) { dt.AddModifier (name, time, x => x.SetElement ("Text", text)); }
public static void Zpos(DrawTheory dt, IFunctionInstance name, double zpos, double time = double.NaN) { dt.AddModifier (name, time, x => x.SetZPos (zpos)); }
public static void Zscale(DrawTheory dt, IFunctionInstance name, double zscale, double time = double.NaN) { }
public static void Zshift(DrawTheory dt, IFunctionInstance name, double zpos, double time = double.NaN) { }
public static void Color(DrawTheory dt, IFunctionInstance name, double r, double g, double b, double time = double.NaN) { InnerColor (dt, name, r, g, b, time); }
public static void Depth(DrawTheory dt, IFunctionInstance name, double index, double time = double.NaN) { dt.AddModifier (name, time, x => x.SetZPos (index)); }
public static void Polygon(DrawTheory dt, IFunctionInstance name, IEnhancedTermCollection points) { dt.AddShape (new ShapeIrregularPolygonObject (name, points.ValueEnumerable<IdpGie.Geometry.Point3> (TermType.Point))); }
Task<IFunctionOutputDefinition> IFunctionOutputLogger.CreateAsync(IFunctionInstance instance, CancellationToken cancellationToken) { IFunctionOutputDefinition x = new PerFunc(); return Task.FromResult(x); }
public Task<IDelayedException> TryExecuteAsync(IFunctionInstance instance, CancellationToken cancellationToken) { throw new NotImplementedException(); }
public static void Shift(DrawTheory dt, IFunctionInstance name, double xpos, double ypos, double zpos, double time = double.NaN) { Xshift (dt, name, xpos, time); Yshift (dt, name, ypos, time); Zshift (dt, name, zpos, time); }
public static void Ellipse(DrawTheory dt, IFunctionInstance name, double width, double height) { dt.AddShape (new ShapeEllipse (name, width, height)); }
public static void Image(DrawTheory dt, IFunctionInstance name, string filepath, double width, double height) { dt.AddShape (new ShapeImage (name, filepath, width, height)); }
public Task<IFunctionOutputDefinition> CreateAsync(IFunctionInstance instance, CancellationToken cancellationToken) { IFunctionOutputDefinition outputDefinition = new NullFunctionOutputDefinition(); return Task.FromResult(outputDefinition); }
public static void Graph(DrawTheory dt, IFunctionInstance name, double width, double height) { }
public static void Hide(DrawTheory dt, IFunctionInstance name, double time = double.NaN) { dt.AddModifier (name, time, x => x.SetElement ("Visible", false)); }
public NodeGraphModifier(double time, IFunctionInstance name) : base(time) { }