public async Task Get_All_Types_At_Or_Bellow_The_Requested()
{
// arrange
var eventHub = new EventHub();
eventHub.Broadcast(new A());
eventHub.Broadcast(new B());
eventHub.Broadcast(new C());
eventHub.Shutdown();
// act
var isGood = await eventHub.Get <B>().All(b => b is B);
// assert
isGood.Should().BeTrue();
}
/// <inheritdoc />
/// <summary>
/// Gets the context menu items.
/// </summary>
/// <param name="items">The items.</param>
/// <returns></returns>
public IEnumerable <FrameworkElement> GetContextMenuItems(IEnumerable <FileInfo> items)
{
var menuItem = new MenuItem();
var arr = items.ToArray();
menuItem.Header = $"Delete {arr.Length} Items";
menuItem.Click += (sender, args) =>
{
foreach (var fileInfo in arr)
{
try
{
File.Delete(fileInfo.FullName);
EventHub.Broadcast(new FileDeletedEvent(fileInfo.FullName));
}
catch (Exception e)
{
Log.Error($"Could not delete {fileInfo.FullName} - {e.Message}");
}
}
};
return(new[] { menuItem });
}
protected override void UpdateInternal(float unscaledDeltaTime)
{
while (m_DownloadResults.TryDequeue(out var result))
{
if (result.exception != null)
{
m_Hub.Broadcast(new StreamingErrorEvent(result.streamAsset.key, result.streamAsset.boundingBox, result.exception));
continue;
}
var streamInstance = new StreamInstance(result.streamAsset.key,
result.streamInstance, result.streamAsset.boundingBox);
var key = result.streamAsset.key;
if (m_Cache.TryGetValue(key, out var previousStreamInstance))
{
if (previousStreamInstance.instance.ObjectId != result.streamInstance.ObjectId)
{
m_InstanceDataOutput.SendStreamRemoved(new SyncedData <StreamInstance>(key, previousStreamInstance));
m_InstanceDataOutput.SendStreamAdded(new SyncedData <StreamInstance>(key, streamInstance));
}
else
{
if (m_DirtySyncObject.Contains(key))
{
m_DirtySyncObject.Remove(key);
m_InstanceDataOutput.SendStreamRemoved(new SyncedData <StreamInstance>(key, previousStreamInstance));
m_InstanceDataOutput.SendStreamAdded(new SyncedData <StreamInstance>(key, streamInstance));
}
else
{
m_InstanceDataOutput.SendStreamChanged(new SyncedData <StreamInstance>(key, streamInstance));
}
}
}
else
{
m_InstanceDataOutput.SendStreamAdded(new SyncedData <StreamInstance>(key, streamInstance));
}
m_Cache[key] = streamInstance;
var syncObjectKey = new StreamKey(streamInstance.key.source, PersistentKey.GetKey <SyncObject>(streamInstance.instance.ObjectId));
if (!m_Instances.TryGetValue(syncObjectKey, out var instances))
{
m_Instances[syncObjectKey] = instances = new HashSet <StreamAsset>();
}
instances.Add(result.streamAsset);
}
if (m_State == State.WaitingToFinish && m_DownloadRequests.IsEmpty)
{
m_InstanceDataOutput.SendEnd();
m_State = State.Idle;
}
}
/// <inheritdoc />
public async Task Process(CancellationToken cancellationToken)
{
EventHub.Broadcast(new DummyMessage
{
Amount = 5
});
Thread.Sleep(333);
await Task.Delay(333);
Thread.Sleep(333);
EventHub.Broadcast(new DummyMessage
{
Amount = 5
});
}
/// <summary>
/// Performs the analysis
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A Task that when complete will signal the completion of the setup procedure</returns>
/// <inheritdoc />
public Task Process(CancellationToken cancellationToken)
{
if (StackFrameResultsInternal.Any())
{
EventHub.Broadcast(new StackFrameBreakdownMessage
{
Records = StackFrameResultsInternal
});
}
if (UniqueStackFrameResultsInternal.Any())
{
EventHub.Broadcast(new UniqueStacksMessage
{
UniqueStackFrameRollupRecords = UniqueStackFrameResultsInternal
});
}
return(Task.CompletedTask);
}
/// <summary>
/// Performs the analysis
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A Task that when complete will signal the completion of the setup procedure</returns>
/// <inheritdoc />
// todo: breakup method
public async Task Process(CancellationToken cancellationToken)
{
if (ExcelAnalyzers == null || ExcelAnalyzers.Length == 0)
{
Log.Fatal("No analyzers were found!");
return;
}
Log.Information("Engine starting");
var analyzerSetupTasks = new Dictionary <Task, IExcelAnalyzer>();
foreach (var analyzer in ExcelAnalyzers)
{
var task = Task.Run(() => analyzer.Setup(cancellationToken), cancellationToken);
analyzerSetupTasks.Add(task, analyzer);
}
using (var stream = File.OpenRead("template.xlsx"))
{
var doc = new SLDocument(stream);
while (analyzerSetupTasks.Keys.Any())
{
var task = await Task.WhenAny(analyzerSetupTasks.Keys);
var analyzer = analyzerSetupTasks[task];
if (task.IsFaulted)
{
task.Exception?.Handle(exception =>
{
Log.Error(exception,
"ExcelAnalyzer {FullName} failed during setup: {FullName1} - {Message}",
analyzer.GetType().FullName, exception.GetType().FullName, exception.Message);
return(true);
});
}
else if (task.IsCanceled)
{
Log.Warning("ExcelAnalyzer {FullName} was cancelled during setup", analyzer.GetType().FullName);
}
else
{
Log.Information("ExcelAnalyzer {FullName} was successfully setup, starting contribution..",
analyzer.GetType().FullName);
analyzer.Contribute(doc);
}
analyzerSetupTasks.Remove(task);
}
var fileName = DateTime.Now.ToString("yyyy_MM_dd-hh_mm_ss") + ".xlsx";
try
{
doc.SelectWorksheet("Summary");
doc.SaveAs(fileName);
Log.Information("Successfully saved report: {FileName}", fileName);
}
catch (Exception e)
{
Log.Error(e, "Unable to save excel report: {FullName} - {Message}", e.GetType().FullName,
e.Message);
throw;
}
if (ExcelPostProcessors == null || ExcelPostProcessors.Length == 0)
{
Log.Information("There were no Excel Post Processors registered");
}
else
{
Log.Information("Starting excel post processing");
foreach (var postProcessor in ExcelPostProcessors)
{
try
{
var fileInfo = Path.GetFullPath(fileName);
postProcessor.PostProcess(new FileInfo(fileInfo));
}
catch (Exception e)
{
Log.Error(e, "Excel Post Processor failed: {FullName} - {Message}",
postProcessor.GetType().FullName, e.Message);
}
}
}
EventHub.Broadcast(new ExcelReportComplete
{
ReportFile = fileName
});
}
}
public void OnPipelineInitialized()
{
m_ObjectHandle = m_MemTracker.CreateCache <StreamKey, TObject>(GetDestructor());
m_Hub.Broadcast(new MemoryTrackerCacheCreatedEvent <TObject>(m_ObjectHandle));
}
protected override void UpdateInternal(float unscaledDeltaTime)
{
// Postponing instances if there are available models (in order to update model caches first)
while (m_DownloadedModels.Count == 0 && m_DownloadedInstances.TryDequeue(out var result))
{
if (result.exception != null)
{
m_Hub.Broadcast(new StreamingErrorEvent(result.instanceData.instance.key, result.instanceData.instance.boundingBox, result.exception));
continue;
}
Trace(">>>>>> SENDING " + result.instanceData.instance.instance.Name);
// TODO Have type dependencies inside the result
var meshes = result.downloadedMeshes;
var textures = result.downloadedTextures;
var materials = result.downloadedMaterials;
foreach (var asset in meshes)
{
m_AddedModels.Add(asset.key);
if (!m_MemTracker.ContainsKey(m_MeshesHandle, asset.key))
{
Trace(" >> Sending " + asset.GetType().Name + " " + asset.asset.Name);
m_SyncMeshOutput.SendStreamAdded(new SyncedData <SyncMesh>(asset.key, asset.asset));
}
}
foreach (var asset in textures)
{
if (m_AddedModels.Add(asset.key))
{
Trace(" >> Sending " + asset.GetType().Name + " " + asset.asset.Name);
m_SyncTextureOutput.SendStreamAdded(new SyncedData <SyncTexture>(asset.key, asset.asset));
}
}
foreach (var asset in materials)
{
if (m_AddedModels.Add(asset.key))
{
Trace(" >> Sending " + asset.GetType().Name + " " + asset.asset.Name);
m_SyncMaterialOutput.SendStreamAdded(new SyncedData <SyncMaterial>(asset.key, asset.asset));
}
}
var key = result.instanceData.instance.key;
if (m_InstanceCache.ContainsKey(key))
{
m_InstanceDataOutput.SendStreamChanged(new SyncedData <StreamInstanceData>(key, result.instanceData));
}
else
{
m_InstanceDataOutput.SendStreamAdded(new SyncedData <StreamInstanceData>(key, result.instanceData));
}
m_InstanceCache[key] = result.instanceData;
Trace(">> DONE " + result.instanceData.instance.instance.Name);
}
while (m_DownloadedModels.TryDequeue(out var result))
{
// Skip without broadcasting error. Errors are broadcasted for each SyncInstance, not for SyncObject or each sub-resource
if (result.exception != null)
{
continue;
}
TrySendAddedOrChanged(result.assetEntry, m_SyncTextureOutput);
TrySendAddedOrChanged(result.assetEntry, m_SyncMeshOutput);
TrySendAddedOrChanged(result.assetEntry, m_SyncMaterialOutput);
}
if (m_State == State.WaitingToFinish && m_DownloadRequests.IsEmpty && m_DownloadedModels.IsEmpty)
{
m_InstanceDataOutput.SendEnd();
m_State = State.Idle;
}
}
