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);
}
}
