public BareBonesBuilder(IServiceCollection services)
{
Services = services;
Services.AddHostedService <StartupTaskHostedService>();
Registry = new ModuleRegistry(services);
}
/// <inheritdoc />
public async Task <bool?> TryConvertModuleToEvaluationAsync(IModuleRegistry moduleRegistry, ParsedModule module, IWorkspace workspace)
{
if (!string.Equals(module.Descriptor.ResolverName, Name, StringComparison.Ordinal))
{
return(null);
}
var package = CreatePackage(module.Definition);
Contract.Assert(module.Specs.Count == 1, "This resolver generated the module, so we expect a single spec.");
var sourceKv = module.Specs.First();
// The in-memory generated spec is a regular DScript one, so run regular AST conversion
var result = await FrontEndUtilities.RunAstConversionAsync(m_frontEndHost, m_context, m_logger, m_frontEndStatistics, package, sourceKv.Key);
if (!result.Success)
{
return(false);
}
// Register the uninstantiated module
var moduleData = new UninstantiatedModuleInfo(
result.SourceFile,
result.Module,
result.QualifierSpaceId.IsValid ? result.QualifierSpaceId : m_context.QualifierTable.EmptyQualifierSpaceId);
m_frontEndHost.ModuleRegistry.AddUninstantiatedModuleInfo(moduleData);
return(true);
}
public CoreAdminService(string moduleName, IServiceProvider serviceProvider)
{
_adminSiteProvider = serviceProvider.GetService <IAdminSiteProvider>();
_logger = serviceProvider.GetService <ILogger <CoreAdminService> >();
_moduleRegistry = serviceProvider.GetService <IModuleRegistry>();
_serviceProvider = serviceProvider;
_serializer = new JsonSerializer();
_serializer.NullValueHandling = NullValueHandling.Ignore;
_serializer.Converters.Add(new Core.Common.Json.GuidConverter());
var adminConfiguratorType = _moduleRegistry.GetModuleMetaInfoByModuleName(moduleName)?.AdminConfiguratorTypeInfo;
if (adminConfiguratorType == null)
{
throw new ArgumentNullException(string.Format(Resources.AdminConfiguratorNotFound, moduleName));
}
_adminSite = _adminSiteProvider.GetAdminConfig(adminConfiguratorType.AsType());
if (_adminSite.AdminType == AdminType.Entity)
{
_adminRepository = new AdminRepository(_adminSite, _serviceProvider);
}
}
private void ConvertExportsFile(IModuleRegistry moduleRegistry, ParsedModule module, Package package)
{
var exportsFileModule = ModuleLiteral.CreateFileModule(
m_javaScriptWorkspaceResolver.ExportsFile,
moduleRegistry,
package,
module.Specs[m_javaScriptWorkspaceResolver.ExportsFile].LineMap);
// For each symbol defined in the resolver settings for exports, add all specified project outputs
int pos = 1;
foreach (var export in Exports)
{
FrontEndUtilities.AddEvaluationCallbackToFileModule(
exportsFileModule,
(context, moduleLiteral, evaluationStackFrame) =>
CollectProjectOutputsAsync(module.Definition.Specs, moduleLiteral.Qualifier.QualifierId, export, context.EvaluationScheduler),
export.FullSymbol,
pos);
pos += 2;
}
var moduleInfo = new UninstantiatedModuleInfo(
// We can register an empty one since we have the module populated properly
new Script.SourceFile(
m_javaScriptWorkspaceResolver.ExportsFile,
new Declaration[] { }),
exportsFileModule,
Context.QualifierTable.EmptyQualifierSpaceId);
moduleRegistry.AddUninstantiatedModuleInfo(moduleInfo);
}
internal ModuleRegistryElement(
IModuleRegistry <TKey, TService> moduleDictionary,
IDictionary <TKey, Func <IServiceProvider, TService> > dictionary,
TKey key)
{
this.registry = moduleDictionary;
this.dictionary = dictionary;
this.key = key;
}
/// <summary>
/// Constructs an uninstantiated file module denoted by a path.
/// </summary>
/// <remarks>
/// This factory should only be used during parsing.
/// </remarks>
public static FileModuleLiteral CreateFileModule(AbsolutePath path, IModuleRegistry moduleRegistry, Package package, LineMap lineMap)
{
Contract.Requires(path.IsValid);
Contract.Requires(moduleRegistry != null);
Contract.Requires(package != null);
Contract.Requires(lineMap != null);
return(CreateInstantiatedFileModule(path, QualifierValue.Unqualified, ((ModuleRegistry)moduleRegistry).GlobalLiteral, package, (ModuleRegistry)moduleRegistry, lineMap: lineMap));
}
/// <inheritdoc/>
public Task <bool?> TryConvertModuleToEvaluationAsync(IModuleRegistry moduleRegistry, ParsedModule module, IWorkspace workspace)
{
// This resolver owns only one module.
if (!module.Definition.Equals(ModuleDefinition))
{
return(Task.FromResult <bool?>(null));
}
return(Task.FromResult <bool?>(true));
}
public override void OnRegisterModules(IModuleRegistry registry)
{
if (registry is null)
{
throw new ArgumentNullException(nameof(registry));
}
base.OnRegisterModules(registry);
registry.Register <IUserManager, UserManager>();
}
public PokeEngine(Configuration.Configuration config) {
config.CheckNull("config");
Registry = new AutofacModuleRegistry();
factory = new GraphicResources(config, Content);
new GraphicsDeviceManager(this);
Window.AllowUserResizing = true;
Content.RootDirectory = "Content";
Registry.RegisterModule(new GameEngineModule(factory, this));
}
/// <inheritdoc/>
public async Task <bool?> TryConvertModuleToEvaluationAsync(IModuleRegistry moduleRegistry, ParsedModule module, IWorkspace workspace)
{
// This resolver owns only one module.
if (!module.Definition.Equals(ModuleDefinition))
{
return(null);
}
var package = FrontEndUtilities.CreatePackage(module.Definition, Context.StringTable);
ConvertExportsFile(moduleRegistry, module, package);
await ConvertImportsFileAsync(package);
return(true);
}
public MongoOutbox(IMongoDatabase database, IModuleRegistry moduleRegistry, OutboxOptions outboxOptions,
MessagingOptions messagingOptions, IModuleClient moduleClient, IAsyncMessageDispatcher asyncMessageDispatcher,
ILogger <MongoOutbox> logger)
{
_database = database;
_moduleClient = moduleClient;
_asyncMessageDispatcher = asyncMessageDispatcher;
_logger = logger;
Enabled = outboxOptions.Enabled;
_modules = moduleRegistry.Modules.ToArray();
_useBackgroundDispatcher = messagingOptions.UseBackgroundDispatcher;
_collectionName = string.IsNullOrWhiteSpace(outboxOptions.CollectionName)
? "outbox"
: outboxOptions.CollectionName;
}
/// <inheritdoc />
public async Task <bool?> TryConvertModuleToEvaluationAsync(IModuleRegistry moduleRegistry, ParsedModule module, IWorkspace workspace)
{
Contract.Requires(module != null);
Contract.Assert(m_resolverState == State.ResolverInitialized);
Contract.Assert(m_owningModules != null, "Owning modules should not be null if the instance is initialized.");
if (!m_owningModules.TryGetValue(module.Descriptor.Id, out Package package))
{
// Current resolver doesn't own a given module.
return(null);
}
var factory = CreateRuntimeModelFactory((Workspace)workspace);
var tasks = module.Specs.Select(spec => ConvertFileToEvaluationAsync(factory, spec.Key, spec.Value, package)).ToArray();
var allTasks = await Task.WhenAll(tasks);
return(allTasks.All(b => b));
}
public DeviserControllerFactory(ILogger <DeviserControllerFactory> logger,
IActionInvoker actionInvoker,
IActionDescriptorCollectionProvider actionDescriptorCollectionProvider,
IActionSelector actionSelector,
IScopeService scopeService,
IHtmlHelper htmlHelper,
IModuleRepository moduleRepository,
IModuleRegistry moduleRegistry)
{
_logger = logger;
_actionInvoker = actionInvoker;
_actionDescriptorCollectionProvider = actionDescriptorCollectionProvider;
//_actionConstraintCache = container.Resolve<ActionConstraintCache>();
_actionSelector = actionSelector;
_htmlHelper = htmlHelper;
_moduleRepository = moduleRepository;
_moduleRegistry = moduleRegistry;
_scopeService = scopeService;
}
/// <inheritdoc/>
public Task <bool?> TryConvertModuleToEvaluationAsync(IModuleRegistry moduleRegistry, ParsedModule module, IWorkspace workspace)
{
// This resolver owns only one module.
if (!module.Definition.Equals(ModuleDefinition))
{
return(Task.FromResult <bool?>(null));
}
var exportsFileModule = ModuleLiteral.CreateFileModule(
m_javaScriptWorkspaceResolver.ExportsFile,
moduleRegistry,
FrontEndUtilities.CreatePackage(module.Definition, Context.StringTable),
module.Specs[m_javaScriptWorkspaceResolver.ExportsFile].LineMap);
// For each symbol defined in the resolver settings for exports, add all specified project outputs
int pos = 1;
foreach (var export in Exports)
{
FrontEndUtilities.AddEvaluationCallbackToFileModule(
exportsFileModule,
(context, moduleLiteral, evaluationStackFrame) =>
CollectProjectOutputsAsync(module.Definition.Specs, moduleLiteral.Qualifier.QualifierId, export),
export.FullSymbol,
pos);
pos += 2;
}
var moduleInfo = new UninstantiatedModuleInfo(
// We can register an empty one since we have the module populated properly
new SourceFile(
m_javaScriptWorkspaceResolver.ExportsFile,
new Declaration[] {}),
exportsFileModule,
Context.QualifierTable.EmptyQualifierSpaceId);
moduleRegistry.AddUninstantiatedModuleInfo(moduleInfo);
return(Task.FromResult <bool?>(true));
}
/// <inheritdoc />
public Task <bool?> TryConvertModuleToEvaluationAsync(IModuleRegistry moduleRegistry, ParsedModule module, IWorkspace workspace)
{
if (!string.Equals(module.Descriptor.ResolverName, Name, StringComparison.Ordinal))
{
return(Task.FromResult <bool?>(null));
}
var downloadData = m_workspaceResolver.Downloads[module.Descriptor.Name];
var package = CreatePackage(module.Definition);
Contract.Assert(module.Specs.Count == 1, "This resolver generated the module, so we expect a single spec.");
var sourceKv = module.Specs.First();
var sourceFilePath = sourceKv.Key;
var sourceFile = sourceKv.Value;
var currentFileModule = ModuleLiteral.CreateFileModule(
sourceFilePath,
moduleRegistry,
package,
sourceFile.LineMap);
// Download
var downloadSymbol = FullSymbol.Create(m_context.SymbolTable, "download");
var downloadResolvedEntry = new ResolvedEntry(
downloadSymbol,
(Context context, ModuleLiteral env, EvaluationStackFrame args) => DownloadFile(downloadData),
// The following position is a contract right now iwtht he generated ast in the workspace resolver
// we have to find a nicer way to handle and register these.
TypeScript.Net.Utilities.LineInfo.FromLineAndPosition(0, 1)
);
currentFileModule.AddResolvedEntry(downloadSymbol, downloadResolvedEntry);
currentFileModule.AddResolvedEntry(new FilePosition(1, sourceFilePath), downloadResolvedEntry);
// Contents.All
var extractedSymbol = FullSymbol.Create(m_context.SymbolTable, "extracted");
var contentsResolvedEntry = new ResolvedEntry(
extractedSymbol,
(Context context, ModuleLiteral env, EvaluationStackFrame args) => ExtractFile(downloadData),
// The following position is a contract right now iwtht he generated ast in the workspace resolver
// we have to find a nicer way to handle and register these.
TypeScript.Net.Utilities.LineInfo.FromLineAndPosition(0, 3)
);
currentFileModule.AddResolvedEntry(extractedSymbol, contentsResolvedEntry);
currentFileModule.AddResolvedEntry(new FilePosition(3, sourceFilePath), contentsResolvedEntry);
var moduleInfo = new UninstantiatedModuleInfo(
// We can register an empty one since we have the module populated properly
new SourceFile(
sourceFilePath,
new Declaration[]
{
}),
currentFileModule,
m_context.QualifierTable.EmptyQualifierSpaceId);
moduleRegistry.AddUninstantiatedModuleInfo(moduleInfo);
return(Task.FromResult <bool?>(true));
}
public ModuleClient(IModuleRegistry moduleRegistry, IModuleSerializer serializer)
{
_moduleRegistry = moduleRegistry;
_serializer = serializer;
}
/// <summary>
/// Same as <see cref="Instantiate"/>, but the result is presented with a more specific type (FileModuleLiteral)
/// </summary>
public FileModuleLiteral InstantiateFileModuleLiteral(IModuleRegistry moduleRegistry, QualifierValue qualifier)
{
return((FileModuleLiteral)Instantiate((ModuleRegistry)moduleRegistry, qualifier));
}
public ModuleClient(IServiceProvider serviceProvider, IModuleRegistry moduleRegistry, ILogger <IModuleClient> logger)
{
_serviceProvider = serviceProvider;
_moduleRegistry = moduleRegistry;
_logger = logger;
}
public override void OnRegisterModules(IModuleRegistry registry)
{
base.OnRegisterModules(registry);
registry.Register <ICalculator, Calculator>();
}
public Task <bool?> TryConvertModuleToEvaluationAsync(IModuleRegistry moduleRegistry, ParsedModule module, IWorkspace workspace)
{
Contract.Requires(module != null);
Contract.Requires(workspace != null);
throw new System.NotImplementedException();
}
public ModuleSubscriber(IModuleRegistry moduleRegistry, IServiceProvider serviceProvider)
{
_moduleRegistry = moduleRegistry;
_serviceProvider = serviceProvider;
}
/// <inheritdoc/>
public Task <bool?> TryConvertModuleToEvaluationAsync(IModuleRegistry moduleRegistry, ParsedModule module, IWorkspace workspace)
{
// No conversion needed.
return(Task.FromResult <bool?>(true));
}
public ModuleSubscriber(IModuleRegistry registry) => _registry = registry;
public ModuleClient(IModuleRegistry moduleRegistry) => _moduleRegistry = moduleRegistry;
public ComponentTypeProvider(IModuleRegistry moduleRegistry)
{
_moduleRegistry = moduleRegistry;
}
