public Lifetime.Definition Load(Scenes sceneName, Action <LevelComponent> onComplete) { var def = Lifetime.Define(GameContext.Lifetime); var async = SceneManager.LoadSceneAsync(sceneName.ToString(), LoadSceneMode.Additive); async.completed += operation => { var scene = SceneManager.GetSceneByName(sceneName.ToString()); SceneManager.SetActiveScene(scene); foreach (var gameObject in scene.GetRootGameObjects()) { var levelComponent = gameObject.GetComponent <LevelComponent>(); if (levelComponent != null) { onComplete(levelComponent); break; } } def.Lifetime.AddAction(() => { foreach (var gameObject in scene.GetRootGameObjects()) { GameObject.Destroy(gameObject); } SceneManager.UnloadSceneAsync(scene); }); }; return(def); }
public async Task PrepareForRun(IUnitTestRun run) { var lifetimeDef = Lifetime.Define(); run.PutData(ourLifetimeDefinitionKey, lifetimeDef); await myInnerHostController.PrepareForRun(run).ConfigureAwait(false); if (!myUnityController.IsUnityEditorUnitTestRunStrategy(run.RunStrategy)) { return; } lock (myStartUnitySync) { myStartUnityTask = myStartUnityTask.ContinueWith(_ => { var unityEditorProcessId = myUnityController.TryGetUnityProcessId(); return(unityEditorProcessId.HasValue ? Task.CompletedTask : myShellLocks.Tasks.StartNew(lifetimeDef.Lifetime, Scheduling.FreeThreaded, () => StartUnityIfNeed(lifetimeDef.Lifetime))); }, lifetimeDef.Lifetime, TaskContinuationOptions.None, myShellLocks.Tasks.GuardedMainThreadScheduler).Unwrap(); } await myStartUnityTask.ConfigureAwait(false); }
public void TestCurrentThread() { int x = 0; Action a = () => { x++; }; var ld = Lifetime.Define(); SingleThreadScheduler.RunInCurrentStackframe(ld.Lifetime, "s", s => { Task.Run(() => { s.Queue(a); s.Queue(a); s.Queue(() => { Assert.False(s.IsIdle); s.PumpAndWaitFor(ld.Lifetime, TimeSpan.FromSeconds(5), () => x == 3); }); s.Queue(a); s.PumpAndWaitFor(ld.Lifetime, TimeSpan.FromSeconds(5), () => x == 3); ld.Terminate(); }); }); }
public IFile ParseFile() { using (var def = Lifetime.Define()) { var builder = new PsiBuilder(_lexer, SpringFileNodeType.Instance, new TokenFactory(), def.Lifetime); var lexer = new ToylangLexer(new AntlrInputStream(_lexer.Buffer.GetText())); var parser = new ToylangParser(new CommonTokenStream(lexer)); parser.AddErrorListener(new SpringErrorListener(builder)); var visitor = new NodeVisitor(builder); // Begin Top level File var fileBeginMark = builder.Mark(); // Inner structure visitor.Visit(parser.file()); // End Top level File builder.ResetCurrentLexeme(visitor.MaxTokenIndexConsumed, visitor.MaxTokenIndexConsumed); builder.Done(fileBeginMark, SpringFileNodeType.Instance, null); var compositeElement = builder.BuildTree(); var file = (IFile)compositeElement; return(file); } }
public void CancellationTokenTest() { var def = Lifetime.Define(); var sw = new SpinWait(); var task = Task.Run(() => { while (true) { def.Lifetime.ThrowIfNotAlive(); sw.SpinOnce(); } }, def.Lifetime); Thread.Sleep(100); def.Terminate(); try { task.Wait(); } catch (AggregateException e) { Assert.True(task.IsCanceled); Assert.True(e.IsOperationCanceled()); return; } Assert.Fail("Unreachable"); }
static void Main() { using (var applf = Lifetime.Define("Root")) { var persons = new List <Person>(); var errReporting = new ErrorsReporting(applf); // Создаем 10 персон с выделением каждой своего отрезка жизни for (int i = 0; i < 10; i++) { var person = new Person(applf); person.Weigth.Changed.ReportTo(errReporting.Weights); person.Height.Changed.ReportTo(errReporting.Heigths); person.Salary.Changed.ReportTo(errReporting.Salaries); persons.Add(person); } Console.WriteLine("================="); PushChanges(persons); Console.WriteLine("Killing: 2th, 5th, 7th"); persons[2].Dispose(); persons[5].Dispose(); persons[7].Dispose(); Console.WriteLine("================="); PushChanges(persons); Console.ReadKey(); } }
public virtual void SetUp() { myDisposable = Log.UsingLogFactory(TestLogger.Factory); LifetimeDefinition = Lifetime.Define(Lifetime.Eternal); TestLifetime = LifetimeDefinition.Lifetime; }
public UnityEventCollector() { if (!PluginSettings.LogEventsCollectorEnabled) { return; } var eventInfo = typeof(Application).GetEvent("logMessageReceivedThreaded", BindingFlags.Static | BindingFlags.Public); // Unity 2017.x+ if (eventInfo == null) { eventInfo = typeof(Application).GetEvent("logMessageReceived", BindingFlags.Static | BindingFlags.Public); } var domainLifetime = Lifetime.Define(); if (eventInfo != null) { var handler = new Application.LogCallback(ApplicationOnLogMessageReceived); eventInfo.AddEventHandler(null, handler); AppDomain.CurrentDomain.DomainUnload += (EventHandler)((_, __) => { eventInfo.RemoveEventHandler(null, handler); domainLifetime.Terminate(); }); } else { #pragma warning disable 612, 618 Application.RegisterLogCallback(ApplicationOnLogMessageReceived); #pragma warning restore 612, 618 } }
private void AddFile([NotNull] IProjectFile projectFile, [NotNull] PsiModuleChangeBuilder changeBuilder) { ISolution solution = projectFile.GetSolution(); // creates a new T4PsiModule for the file var lifetimeDefinition = Lifetime.Define(_lifetime, T4FilePsiModule.Prefix + projectFile.Name); var psiModule = new T4FilePsiModule( lifetimeDefinition.Lifetime, projectFile, _changeManager, _shellLocks, _t4Environment, PrimaryTargetFrameworkId ); _modules[projectFile] = new ModuleWrapper(psiModule, lifetimeDefinition); psiModule.AddBaseReferences(); changeBuilder.AddModuleChange(psiModule, PsiModuleChange.ChangeType.Added); changeBuilder.AddFileChange(psiModule.SourceFile, PsiModuleChange.ChangeType.Added); // Invalidate files that had this specific files as an include, // and whose IPsiSourceFile was previously managed by T4OutsideSolutionSourceFileManager. // Those files will be reparsed with the new source file. var fileManager = solution.GetComponent <T4OutsideSolutionSourceFileManager>(); VirtualFileSystemPath location = projectFile.Location; if (fileManager.HasSourceFile(location)) { fileManager.DeleteSourceFile(location); } }
public IFile ParseFile() { using (var lifetimeDefinition = Lifetime.Define()) { var builder = new PsiBuilder(_lexer, GherkinNodeTypes.FILE, null, lifetimeDefinition.Lifetime); var fileMarker = builder.Mark(); while (!builder.Eof()) { var tokenType = builder.GetTokenType(); if (tokenType == GherkinTokenTypes.FEATURE_KEYWORD) { ParseFeature(builder); } else if (tokenType == GherkinTokenTypes.TAG) { ParseTags(builder); } else if (tokenType == GherkinTokenTypes.COMMENT) { ParseComments(builder); } else { builder.AdvanceLexer(); } } builder.Done(fileMarker, GherkinNodeTypes.FILE, new GherkinFile.FileMetadata(_sourceFile?.Name, _lang)); var resultTree = (GherkinFile)builder.BuildTree(); return(resultTree); } }
public void SpawnRequirement() { if (_requirements.Count == 0 && _factories.Count != 0) { for (int i = 0; i < 4; i++) { var index = UnityEngine.Random.Range(0, _factories.Count); var factory = _factories[index]; var spawn = factory.Pop(); spawn.GetComponent <Collider>().enabled = false; spawn.transform.position = _level.RunesPositions[i].position; spawn.transform.SetParent(_level.RuneTransform); var def = Lifetime.Define(_level.Lifetime); var activeReq = new ActiveRune(); activeReq.Spawn = spawn; activeReq.Lifetime = def; _requirements.Add(activeReq); def.Lifetime.AddAction(() => { factory.Push(spawn); _level.ToPool(spawn.transform); _requirements.Remove(activeReq); }); } } }
public static void View <T>(this IViewableSet <T> me, Lifetime lifetime, Action <Lifetime, T> handler) { var lifetimes = new Dictionary <T, LifetimeDefinition>(); me.Advise(lifetime, (kind, value) => { switch (kind) { case AddRemove.Add: var def = Lifetime.Define(lifetime); lifetimes[value] = def; handler(def.Lifetime, value); break; case AddRemove.Remove: def = lifetimes[value]; lifetimes.Remove(value); def.Terminate(); break; default: throw new ArgumentOutOfRangeException($"illegal enum value: {kind}"); } }); }
public static Lifetime.Definition DelayCall(float seconds, Action listener) { var def = Lifetime.Define(Lifetime.Eternal); DelayCall(def.Lifetime, seconds, listener); return(def); }
public static Lifetime.Definition StartCoroutine(IEnumerator enumerator) { var def = Lifetime.Define(_instance._lifetime); StartCoroutine(def.Lifetime, enumerator); return(def); }
public static void View <K, V>(this IViewableMap <K, V> me, Lifetime lifetime, Action <Lifetime, K, V> handler) { var lifetimes = new Dictionary <KeyValuePair <K, V>, LifetimeDefinition>(); me.AdviseAddRemove(lifetime, (kind, key, value) => { var entry = JetKeyValuePair.Of(key, value); switch (kind) { case AddRemove.Add: var def = Lifetime.Define(lifetime); lifetimes.Add(entry, def); handler(def.Lifetime, entry.Key, entry.Value); break; case AddRemove.Remove: def = lifetimes[entry]; lifetimes.Remove(entry); def.Terminate(); break; default: throw new ArgumentOutOfRangeException($"Illegal enum value: {kind}"); } }); }
public static Lifetime.Definition SubscribeOnUpdate(Action <float> listener) { var def = Lifetime.Define(Lifetime); SubscribeOnUpdate(def.Lifetime, listener); return(def); }
public static void View <V>(this IViewableList <V> me, Lifetime lifetime, Action <Lifetime, int, V> handler) { var lifetimes = new List <LifetimeDefinition>(); me.AdviseAddRemove(lifetime, (kind, index, value) => { switch (kind) { case AddRemove.Add: var def = Lifetime.Define(lifetime); lifetimes.Insert(index, def); handler(def.Lifetime, index, value); break; case AddRemove.Remove: def = lifetimes[index]; lifetimes.RemoveAt(index); def.Terminate(); break; default: throw new ArgumentOutOfRangeException($"Illegal enum value: {kind}"); } }); }
public IFile ParseFile() { using (var def = Lifetime.Define()) { var builder = new PsiBuilder(myLexer, SpringFileNodeType.Instance, new TokenFactory(), def.Lifetime); var fileMark = builder.Mark(); StringBuilder b = new StringBuilder(); foreach (var tok in myLexer.Tokens()) { b.Append(tok + " "); } b.ToString(); ParseDefines(builder); builder.Done(fileMark, SpringFileNodeType.Instance, null); var file = (IFile)builder.BuildTree(); SprintTreeScopeUtl.InitScopes(file); var sb = new StringBuilder(); DebugUtil.DumpPsi(new StringWriter(sb), file); sb.ToString(); return(file); } }
public void T020_DefineNestedOrder() { var entries = new List <int>(); int x = 0; Func <Action> FMakeAdder = () => { var a = x++; return(() => entries.Add(a)); }; // Fixes the X value at the moment of FMakeAdder call. bool flag = false; Lifetime.Using(lifetime => { lifetime.OnTermination(FMakeAdder()); lifetime.AddDispose(Disposable.CreateAction(FMakeAdder())); Lifetime.Define(lifetime, atomicAction: (lifeNested) => { lifeNested.OnTermination(FMakeAdder()); lifeNested.OnTermination(FMakeAdder()); lifeNested.OnTermination(FMakeAdder()); }); lifetime.AddDispose(Disposable.CreateAction(FMakeAdder())); Lifetime.Define(lifetime, atomicAction: (lifeNested) => { lifeNested.OnTermination(FMakeAdder()); lifeNested.OnTermination(FMakeAdder()); lifeNested.OnTermination(FMakeAdder()); }); lifetime.AddDispose(Disposable.CreateAction(FMakeAdder())); Lifetime.Define(lifetime, atomicAction: (lifeNested) => lifeNested.OnTermination(() => flag = true)).Terminate(); Assert.IsTrue(flag, "Nested closing FAIL."); flag = false; lifetime.AddDispose(Disposable.CreateAction(FMakeAdder())); }); Assert.IsFalse(flag, "Nested closed twice."); CollectionAssert.AreEqual(System.Linq.Enumerable.Range(0, entries.Count).Reverse().ToArray(), entries, "Order FAIL."); }
private void AddFile([NotNull] IProjectFile projectFile, [NotNull] PsiModuleChangeBuilder changeBuilder) { ISolution solution = projectFile.GetSolution(); // creates a new T4PsiModule for the file LifetimeDefinition lifetimeDefinition = Lifetime.Define(_lifetime, "[T4]" + projectFile.Name); var psiModule = new T4PsiModule( lifetimeDefinition.Lifetime, solution.GetComponent <IPsiModules>(), solution.GetComponent <DocumentManager>(), _changeManager, solution.GetComponent <IAssemblyFactory>(), _shellLocks, projectFile, solution.GetComponent <T4FileDataCache>(), _t4Environment, solution.GetComponent <OutputAssemblies>() ); _modules[projectFile] = new ModuleWrapper(psiModule, lifetimeDefinition); changeBuilder.AddModuleChange(psiModule, PsiModuleChange.ChangeType.Added); changeBuilder.AddFileChange(psiModule.SourceFile, PsiModuleChange.ChangeType.Added); // Invalidate files that had this specific files as an include, // and whose IPsiSourceFile was previously managed by T4OutsideSolutionSourceFileManager. // Those files will be reparsed with the new source file. var fileManager = solution.GetComponent <T4OutsideSolutionSourceFileManager>(); FileSystemPath location = projectFile.Location; if (fileManager.HasSourceFile(location)) { fileManager.DeleteSourceFile(location); InvalidateFilesHavingInclude(location, solution.GetPsiServices()); } }
private async Task RefreshInternal(Lifetime lifetime, RefreshType refreshType) { var lifetimeDef = Lifetime.Define(lifetime); myLogger.Verbose($"myPluginProtocolController.UnityModel.Value.Refresh.StartAsTask, force = {refreshType} Started"); mySolution.GetComponent <RiderBackgroundTaskHost>().AddNewTask(lifetimeDef.Lifetime, RiderBackgroundTaskBuilder.Create().WithHeader("Refreshing solution in Unity Editor...") .AsIndeterminate().AsNonCancelable()); try { try { var version = UnityVersion.Parse(myEditorProtocol.UnityModel.Value.UnityApplicationData.Value.ApplicationVersion); if (version != null && version.Major < 2018) { using (mySolution.GetComponent <VfsListener>().PauseChanges()) { await myEditorProtocol.UnityModel.Value.Refresh.Start(lifetimeDef.Lifetime, refreshType).AsTask(); } } else // it is a risk to pause vfs https://github.com/JetBrains/resharper-unity/issues/1601 { await myEditorProtocol.UnityModel.Value.Refresh.Start(lifetimeDef.Lifetime, refreshType).AsTask(); } } catch (Exception e) { myLogger.Warn("connection usually brakes during refresh.", e); } finally { try { myLogger.Verbose( $"myPluginProtocolController.UnityModel.Value.Refresh.StartAsTask, force = {refreshType} Finished"); var solution = mySolution.GetProtocolSolution(); var solFolder = mySolution.SolutionDirectory; var list = new List <string> { solFolder.FullPath }; myLogger.Verbose($"RefreshPaths.StartAsTask Finished."); await solution.GetFileSystemModel().RefreshPaths.Start(lifetimeDef.Lifetime, new RdRefreshRequest(list, true)).AsTask(); } finally { myLogger.Verbose($"RefreshPaths.StartAsTask Finished."); lifetimeDef.Terminate(); } } } catch (Exception e) { myLogger.LogException(e); } finally { lifetimeDef.Terminate(); } }
public static void Init() { if (ourInitialized) { return; } var projectDirectory = Directory.GetParent(Application.dataPath).FullName; var projectName = Path.GetFileName(projectDirectory); SlnFile = Path.GetFullPath($"{projectName}.sln"); InitializeEditorInstanceJson(); var lifetimeDefinition = Lifetime.Define(Lifetime.Eternal); Lifetime = lifetimeDefinition.Lifetime; AppDomain.CurrentDomain.DomainUnload += (EventHandler)((_, __) => { ourLogger.Verbose("lifetimeDefinition.Terminate"); lifetimeDefinition.Terminate(); }); #if !UNITY_4_7 && !UNITY_5_5 && !UNITY_5_6 EditorApplication.playModeStateChanged += state => { if (state == PlayModeStateChange.EnteredPlayMode) { var time = DateTime.UtcNow.Ticks.ToString(); SessionState.SetString("Rider_EnterPlayMode_DateTime", time); } }; #endif if (PluginSettings.SelectedLoggingLevel >= LoggingLevel.VERBOSE) { var executingAssembly = Assembly.GetExecutingAssembly(); var location = executingAssembly.Location; Debug.Log($"Rider plugin \"{executingAssembly.GetName().Name}\" initialized{(string.IsNullOrEmpty(location)? "" : " from: " + location )}. LoggingLevel: {PluginSettings.SelectedLoggingLevel}. Change it in Unity Preferences -> Rider. Logs path: {LogPath}."); } var protocolInstanceJsonPath = Path.GetFullPath("Library/ProtocolInstance.json"); InitializeProtocol(Lifetime, protocolInstanceJsonPath); OpenAssetHandler = new OnOpenAssetHandler(ourRiderPathProvider, ourPluginSettings, SlnFile); ourLogger.Verbose("Writing Library/ProtocolInstance.json"); AppDomain.CurrentDomain.DomainUnload += (sender, args) => { ourLogger.Verbose("Deleting Library/ProtocolInstance.json"); File.Delete(protocolInstanceJsonPath); }; PlayModeSavedState = GetPlayModeState(); ourInitialized = true; }
private Task Run(IUnitTestRun run) { if (myUnityProcessId.Value == null) { return(Task.FromException(new Exception("Unity Editor is not available."))); } var tcs = new TaskCompletionSource <bool>(); var taskLifetimeDef = Lifetime.Define(myLifetime); taskLifetimeDef.SynchronizeWith(tcs); myUnityProcessId.When(run.Lifetime, (int?)null, _ => { tcs.TrySetException(new Exception("Unity Editor has been closed.")); }); var hostId = run.HostController.HostId; switch (hostId) { case WellKnownHostProvidersIds.DebugProviderId: mySolution.Locks.ExecuteOrQueueEx(myLifetime, "AttachDebuggerToUnityEditor", () => { if (!run.Lifetime.IsAlive) { tcs.TrySetCanceled(); return; } var task = myUnityHost.GetValue(model => model.AttachDebuggerToUnityEditor.Start(Unit.Instance)); task.Result.AdviseNotNull(myLifetime, result => { if (!run.Lifetime.IsAlive) { tcs.TrySetCanceled(); } else if (!result.Result) { tcs.SetException(new Exception("Unable to attach debugger.")); } else { RefreshAndRunTask(run, tcs, taskLifetimeDef.Lifetime); } }); }); break; default: RefreshAndRunTask(run, tcs, taskLifetimeDef.Lifetime); break; } return(tcs.Task); }
private void SpawnObject() { var def = Lifetime.Define(_levelComponent.Lifetime); var point = _spawnPoints[_random.Next(_spawnPoints.Length)]; var spawn = GameObject.Instantiate(_settings.GoatSpawnComponent); spawn.transform.position = point; spawn.transform.SetParent(_levelComponent.ActiveSpawnTransform, true); _activeSpawns.Add(spawn); }
public SequentialScheduler(string id, Lifetime lifetime, TaskScheduler scheduler = null) { myLifetime = lifetime; mySyncContext = new SyncContext(this); myExecutionCount = new ThreadLocal <uint>(); var def = Lifetime.Define(); myActor = new Actor <Action>($"{id} Actor", def.Lifetime, action => action(), scheduler); lifetime.OnTermination(() => myActor.SendBlocking(() => def.Terminate())); }
static void Main(string[] args) { // Глобальная область using (var lfd = Lifetime.Define("Root")) { var dataLayer = new ObjectsLayer(lfd); // ... } Console.ReadKey(); }
private static void ExecuteRefactoring( [NotNull] ITextControl textControl, [NotNull] ICSharpExpression expression, [CanBeNull] Action executeAfter = null) { const string actionId = IntroVariableAction.ACTION_ID; var solution = expression.GetSolution(); var document = textControl.Document; var expressionRange = expression.GetDocumentRange() .TextRange; textControl.Selection.SetRange(expressionRange); var rules = DataRules .AddRule(actionId, ProjectModelDataConstants.SOLUTION, solution) .AddRule(actionId, DocumentModelDataConstants.DOCUMENT, document) .AddRule(actionId, TextControlDataConstants.TEXT_CONTROL, textControl); var settingsStore = expression.GetSettingsStoreWithEditorConfig(); var multipleOccurrences = settingsStore.GetValue(PostfixTemplatesSettingsAccessor.SearchVarOccurrences); // note: uber ugly code down here using (var definition = Lifetime.Define(Lifetime.Eternal, actionId)) { var dataContexts = solution.GetComponent <DataContexts>(); var dataContext = dataContexts.CreateWithDataRules(definition.Lifetime, rules); var workflow = new IntroduceVariableWorkflow(solution, actionId); RefactoringActionUtil.ExecuteRefactoring(dataContext, workflow); var finishedAction = executeAfter; if (finishedAction != null) { var currentSession = HotspotSessionExecutor.Instance.CurrentSession; if (currentSession != null) // ugly hack { currentSession.HotspotSession.Closed.Advise(Lifetime.Eternal, (e) => { if (e.TerminationType == TerminationType.Finished) { finishedAction(); } }); } else { finishedAction(); } } } }
public Lifetime RegisterCommand(Func <Lifetime, ICommand> factory, bool oneTime = false) { var lifetime = Lifetime.Define(_lifetime); var commandFactory = new CommandFactory(factory, oneTime, lifetime); _commands.Add(commandFactory); lifetime.Lifetime.AddAction(() => { _commands.Remove(commandFactory); }); return(lifetime.Lifetime); }
public void EventHandlerShouldTerminateInRightWay() { using (var applf = Lifetime.Define("Root")) { var dataSource = new DataSource(applf.Lifetime); dataSource.IntegerComes += x => { }; dataSource.TriggerItPlease(12); dataSource.Dispose(); Assert.AreEqual(false, applf.Lifetime.IsTerminated, $"Is {applf.Name} lifetime terminated"); } }
public IFile ParseFile() { using (var def = Lifetime.Define()) { var builder = new PsiBuilder(myLexer, SpringFileNodeType.Instance, new TokenFactory(), def.Lifetime); var fileMark = builder.Mark(); ParseBlock(builder); builder.Done(fileMark, SpringFileNodeType.Instance, null); var file = (IFile)builder.BuildTree(); return(file); } }