private void ConfigureServices(IServiceCollection services)
{
// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.dependencyinjection?view=dotnet-plat-ext-3.1
services.AddSingleton <MainWindow>();
var serviceInterfacesAndBaseClasses = Assembly.GetEntryAssembly() !.DefinedTypes
.Where(candidate => candidate.GetCustomAttribute <ProvideDerivedAttribute>() != null);
foreach (var candidate in Assembly.GetEntryAssembly() !.DefinedTypes)
{
var required = candidate.GetCustomAttribute <SingletonAttribute>() != null;
foreach (var derviedFrom in serviceInterfacesAndBaseClasses
.Where(fromCandidate => fromCandidate.IsAssignableFrom(candidate) && !candidate.IsAbstract))
{
services.AddSingleton(derviedFrom, x => x.GetRequiredService(candidate));
required = true;
}
if (required)
{
if (candidate.IsValueType) // For structs.
{
services.AddSingleton(candidate, _ => Activator.CreateInstance(candidate) !);
}
else
{
services.AddSingleton(candidate, candidate);
}
}
}
}
public DefinedType GetDefinedType(string name, Location location)
{
DefinedType type = DefinedTypes.FirstOrDefault(dt => dt.Name == name);
if (type == null && location != null)
{
throw SyntaxErrorException.NonexistentType(name, location);
}
return(type);
}
public static void MapGrpcServices(this IEndpointRouteBuilder builder)
{
MethodInfo method = typeof(GrpcEndpointRouteBuilderExtensions).GetMethod("MapGrpcService");
IEnumerable <TypeInfo> typeInfos = Assembly.GetEntryAssembly() !.DefinedTypes.Where(t => t.IsClass && !t.IsAbstract && t.BaseType != null && t.BaseType.CustomAttributes.Any(a => a.AttributeType == typeof(BindServiceMethodAttribute)));
foreach (TypeInfo item in typeInfos)
{
method.MakeGenericMethod(item.AsType()).Invoke(null, new object[] { builder });
}
}
public static ExternSignature Composite(string sign, ushort index)
{
var s = new ExternSignature
{
Signature = sign, MethodIndex = index, Arguments = new List <ExternType>()
};
foreach (Match match in new Regex(@"(?<type>i32|i64|i16|i8|i2|u32|u64|u16|u8|u2|f64)+?\,?\s?").Matches(sign))
{
s.Arguments.Add(DefinedTypes.First(x => x.GetType().Name == $"{match.Groups["type"]}_Type"));
}
return(s);
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (disposing)
{
UnregisterFromCollection(Tests as INotifyCollectionChanged, TestsCollectionChanged, TestInformationChanged);
Tests.Clear();
foreach (var item in DefinedTypes)
{
if (item.Value is IDisposable)
{
((IDisposable)item.Value).Dispose();
}
}
DefinedTypes.Clear();
}
}
/// <summary>
/// This method asynchornously loads an instance of <see cref="AsyncResourceFactoryProvider"/> using this <see cref="ResourceFactoryDynamicCreationConfiguration"/> along with assembly loader callback.
/// </summary>
/// <param name="configuration">This <see cref="ResourceFactoryDynamicCreationConfiguration"/>.</param>
/// <param name="assemblyLoader">The callback to asynchronously load assembly. The parameters are, in this order: package ID, package version, and path within the package.</param>
/// <param name="token">The <see cref="CancellationToken"/> for this asynchronous operation.</param>
/// <returns>Asynchronously returns a value which either has <see cref="AsyncResourceFactoryProvider"/> or an error message.</returns>
/// <exception cref="NullReferenceException">If this <see cref="ResourceFactoryDynamicCreationConfiguration"/> is <c>null</c>.</exception>
public static async Task <EitherOr <AsyncResourceFactoryProvider, String> > AcquireResourcePoolProvider(
this ResourceFactoryDynamicCreationConfiguration configuration,
Func <String, String, String, CancellationToken, Task <Assembly> > assemblyLoader,
CancellationToken token
)
{
AsyncResourceFactoryProvider retVal = null;
String errorMessage = null;
if (configuration != null)
{
if (assemblyLoader != null)
{
var packageID = configuration.PoolProviderPackageID;
if (!String.IsNullOrEmpty(packageID))
{
try
{
var assembly = await assemblyLoader(
packageID, // package ID
configuration.PoolProviderVersion, // optional package version
configuration.PoolProviderAssemblyPath, // optional assembly path within package
token
);
if (assembly != null)
{
// Now search for the type
var typeName = configuration.PoolProviderTypeName;
var parentType = typeof(AsyncResourceFactoryProvider).GetTypeInfo();
var checkParentType = !String.IsNullOrEmpty(typeName);
Type providerType;
if (checkParentType)
{
// Instantiate directly
providerType = assembly.GetType(typeName); //, false, false );
}
else
{
// Search for first available
providerType = assembly.
#if NET40
GetTypes()
#else
DefinedTypes
#endif
.FirstOrDefault(t => !t.IsInterface && !t.IsAbstract && t.IsPublic && parentType.IsAssignableFromIgnoreAssemblyVersion(t))
#if !NET40
?.AsType()
#endif
;
}
if (providerType != null)
{
if (!checkParentType || parentType.IsAssignableFromIgnoreAssemblyVersion(providerType.GetTypeInfo()))
{
// All checks passed, instantiate the pool provider
retVal = (AsyncResourceFactoryProvider)Activator.CreateInstance(providerType);
}
else
{
errorMessage = $"The type \"{providerType.FullName}\" in \"{assembly}\" does not have required parent type \"{parentType.FullName}\".";
}
}
else
{
errorMessage = $"Failed to find type within assembly in \"{assembly}\", try specify \"{nameof( configuration.PoolProviderTypeName )}\" configuration parameter.";
}
}
else
{
errorMessage = $"Failed to load resource pool provider package \"{packageID}\".";
}
}
catch (Exception exc)
{
errorMessage = $"An exception occurred when acquiring resource pool provider: {exc.Message}";
}
}
else
{
errorMessage = $"No NuGet package ID were provided as \"{nameof( configuration.PoolProviderPackageID )}\" configuration parameter. The package ID should be of the package holding implementation for \"{nameof( AsyncResourceFactoryProvider )}\" type.";
}
}
else
{
errorMessage = "Task must be provided callback to load NuGet packages (just make constructor taking it as argument and use UtilPack.NuGet.MSBuild task factory).";
}
}
else
{
errorMessage = "Configuration was not provided.";
}
return(retVal == null ?
new EitherOr <AsyncResourceFactoryProvider, String>(errorMessage) :
new EitherOr <AsyncResourceFactoryProvider, String>(retVal));
}
public sealed override Type[] GetTypes() => DefinedTypes.ToArray();
private void GetObjects(RulesetNode rulesetNode, string file, TranslateRule globalTranslate, TranslateRule playerTranslate)
{
string absolute = new Uri(file).AbsolutePath;
// Get the defined types
foreach (var definedType in rulesetNode.DefinedTypes)
{
try
{
if (DefinedTypes.Any(type => type.Name == definedType.Name))
{
throw SyntaxErrorException.NameAlreadyDefined(definedType.Location);
}
DefinedTypes.Add(DefinedType.GetDefinedType(definedType));
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
// Get the user methods.
for (int i = 0; i < rulesetNode.UserMethods.Length; i++)
{
try
{
UserMethods.Add(UserMethod.CreateUserMethod(Root, rulesetNode.UserMethods[i]));
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
// Get the rules
RuleNodes.AddRange(rulesetNode.Rules);
List <string> importedFiles = new List <string>();
foreach (ImportObjectNode importObject in rulesetNode.ObjectImports)
{
try
{
Importer importer = new Importer(Diagnostics, importedFiles, importObject.File, file, importObject.Location);
if (!importer.AlreadyImported)
{
importedFiles.Add(importer.ResultingPath);
switch (importer.FileType)
{
case ".obj":
importer.FileData.Update();
string content = importer.FileData.Content;
Model newModel = Model.ImportObj(content);
new ModelVar(importObject.Name, Root, importObject, newModel);
break;
case ".pathmap":
PathMap pathMap = PathMap.ImportFromXML(importer.ResultingPath);
new PathMapVar(this, importObject.Name, Root, importObject, pathMap);
break;
}
}
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
// Get the variables
foreach (var definedVar in rulesetNode.DefinedVars)
{
try
{
IndexedVar var;
if (!definedVar.Extended)
{
if (definedVar.OverrideID == -1)
{
var = IndexedVar.AssignVar(VarCollection, Root, definedVar.VariableName, definedVar.IsGlobal, definedVar);
}
else
{
var = IndexedVar.AssignVar(
VarCollection,
Root,
definedVar.VariableName,
definedVar.IsGlobal,
new WorkshopVariable(definedVar.IsGlobal, definedVar.OverrideID, VarCollection.WorkshopNameFromCodeName(definedVar.IsGlobal, definedVar.VariableName)),
definedVar
);
}
}
else
{
var = IndexedVar.AssignVarExt(VarCollection, Root, definedVar.VariableName, definedVar.IsGlobal, definedVar);
}
if (definedVar.Type != null)
{
var.Type = GetDefinedType(definedVar.Type, definedVar.Location);
}
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
}
/// <summary>
/// Provides the type associated to the name
/// </summary>
/// <param name="nameSpace">the namespace in which the name should be found</param>
/// <param name="name"></param>
/// <returns></returns>
public Types.Type findType(Types.NameSpace nameSpace, string name)
{
Types.Type retVal = null;
if (name != null)
{
if (nameSpace != null)
{
if (!cache.ContainsKey(nameSpace))
{
cache[nameSpace] = new Dictionary <string, Types.Type>();
}
Dictionary <string, Types.Type> subCache = cache[nameSpace];
if (!subCache.ContainsKey(name))
{
Types.Type tmp = null;
if (!Utils.Utils.isEmpty(name))
{
tmp = nameSpace.findTypeByName(name);
if (tmp == null)
{
if (DefinedTypes.ContainsKey(name))
{
tmp = DefinedTypes[name];
}
}
if (tmp == null && DefinedTypes.ContainsKey("Default." + name))
{
tmp = DefinedTypes["Default." + name];
}
}
if (tmp == null)
{
Log.Error("Cannot find type named " + name);
}
subCache[name] = tmp;
}
retVal = subCache[name];
}
else
{
if (DefinedTypes.ContainsKey(name))
{
retVal = DefinedTypes[name];
}
else if (DefinedTypes.ContainsKey("Default." + name))
{
retVal = DefinedTypes["Default." + name];
}
}
}
return(retVal);
}
private void GetObjects(string document, string file, TranslateRule globalTranslate, TranslateRule playerTranslate, bool isRoot)
{
// If this file was already loaded, don't load it again.
if (Imported.Contains(file))
{
return;
}
Imported.Add(file);
Diagnostics.AddFile(file);
// Get the ruleset.
RulesetNode ruleset = GetRuleset(file, document);
Rulesets.Add(file, ruleset);
if (ruleset != null && !Diagnostics.ContainsErrors())
{
if (isRoot)
{
VarCollection = new VarCollection(ruleset.UseGlobalVar, ruleset.UsePlayerVar, ruleset.UseBuilderVar);
Root = new ScopeGroup(VarCollection);
}
// Get the defined types
foreach (var definedType in ruleset.DefinedTypes)
{
try
{
if (DefinedTypes.Any(type => type.Name == definedType.Name))
{
throw SyntaxErrorException.NameAlreadyDefined(definedType.Location);
}
DefinedTypes.Add(DefinedType.GetDefinedType(definedType));
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
// Get the user methods.
for (int i = 0; i < ruleset.UserMethods.Length; i++)
{
try
{
UserMethods.Add(new UserMethod(Root, ruleset.UserMethods[i]));
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
// Get the rules
RuleNodes.AddRange(ruleset.Rules);
List <string> importedFiles = new List <string>();
foreach (ImportObjectNode importObject in ruleset.ObjectImports)
{
try
{
Importer importer = new Importer(Diagnostics, importedFiles, importObject.File, file, importObject.Location);
if (!importer.AlreadyImported)
{
importedFiles.Add(importer.ResultingPath);
string content = importer.GetFile();
switch (importer.FileType)
{
case ".obj":
Model newModel = Model.ImportObj(content);
new ModelVar(importObject.Name, Root, importObject, newModel);
break;
}
}
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
// Check the imported files.
foreach (ImportNode importNode in ruleset.Imports)
{
try
{
Importer importer = new Importer(Diagnostics, importedFiles, importNode.File, file, importNode.Location);
if (!importer.AlreadyImported)
{
string content = File.ReadAllText(importer.ResultingPath);
GetObjects(content, importer.ResultingPath, globalTranslate, playerTranslate, false);
importedFiles.Add(importer.ResultingPath);
}
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
// Get the variables
foreach (var definedVar in ruleset.DefinedVars)
{
try
{
IndexedVar var;
if (definedVar.UseVar == null)
{
var = VarCollection.AssignVar(Root, definedVar.VariableName, definedVar.IsGlobal, definedVar);
}
else
{
var = VarCollection.AssignVar(
Root,
definedVar.VariableName,
definedVar.IsGlobal,
definedVar.UseVar.Variable,
definedVar.UseVar.Index,
definedVar
);
}
if (definedVar.Type != null)
{
var.Type = GetDefinedType(definedVar.Type, definedVar.Location);
}
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
}
}
