public static void Precache(Assembly asm)
{
if (asm == null || _LoadAssembly == null)
{
return;
}
_Preloaded.Add(asm.GetName().Name);
_Preloaded.Add(asm.FullName);
try {
_LoadAssembly(asm.FullName);
} catch {
// no-op.
}
foreach (Type type in asm.GetTypes())
{
// Non-public type instances can still be passed / returned.
/*
* if (!type.IsPublic)
* continue;
*/
_Preloaded.Add(type.FullName);
if (!AllNamespaces.TryGetValue(type.Namespace ?? "", out CachedNamespace cns))
{
string ns = type.Namespace;
CachedNamespace cnsPrev = Global;
for (int i = 0, iPrev = -1; i != -1; iPrev = i, cnsPrev = cns)
{
i = ns.IndexOf('.', iPrev + 1);
string part = i == -1 ? ns.Substring(iPrev + 1) : ns.Substring(iPrev + 1, i - iPrev - 1);
if (cnsPrev.NamespaceMap.TryGetValue(part, out cns))
{
continue;
}
cns = new CachedNamespace(cnsPrev, part);
cnsPrev.NamespaceMap[part] = cns;
AllNamespaces[cns.FullName] = cns;
}
}
if (!AllTypes.TryGetValue(type.FullName, out CachedType ctype))
{
string part = type.Name;
ctype = new CachedType(cns, type);
cns.TypeMap[part] = ctype;
AllTypes[ctype.FullName] = ctype;
}
}
}
private string GetModuleNamespace(UField field, out UnrealModuleType moduleAssetType, bool allowFoldersAsNamespace = true)
{
moduleAssetType = UnrealModuleType.Unknown;
UPackage package = field.GetOutermost();
if (package != null)
{
CachedNamespace cachedNamespace;
if (namespaceCache.TryGetValue(package, out cachedNamespace))
{
moduleAssetType = cachedNamespace.ModuleAssetType;
return(cachedNamespace.Namespace);
}
UnrealModuleType moduleType = UnrealModuleType.Unknown;
moduleAssetType = UnrealModuleType.Unknown;
string packageFilename = package.FileName.ToString();
if (string.IsNullOrEmpty(packageFilename.ToString()) || packageFilename == FName.None.ToString())
{
packageFilename = field.GetPathName();
}
string moduleName = FPackageName.GetShortName(package.GetName());
if (packageFilename.StartsWith("/Script"))
{
if (!modulesByName.TryGetValue(new FName(moduleName), out moduleType))
{
moduleType = UnrealModuleType.Unknown;
FMessage.Log(ELogVerbosity.Error, string.Format("Failed to find module for module '{0}'", moduleName));
}
}
else if (packageFilename.StartsWith("/Game/"))
{
moduleType = UnrealModuleType.Game;
moduleAssetType = UnrealModuleType.Game;
moduleName = FPaths.GetBaseFilename(FPaths.ProjectFilePath);// {Module} same as {Game}
}
else if (packageFilename.StartsWith("/Engine/"))
{
moduleType = UnrealModuleType.Game;
moduleAssetType = UnrealModuleType.Engine;
moduleName = Settings.Namespaces.Default;
}
else
{
string rootName = null;
if (packageFilename.Length > 1 && packageFilename[0] == '/')
{
int slashIndex = packageFilename.IndexOf('/', 1);
if (slashIndex >= 0)
{
rootName = packageFilename.Substring(1, slashIndex - 1);
moduleName = rootName;// Update ModuleName for {Module}
if (!modulesByName.TryGetValue(new FName(rootName), out moduleAssetType))
{
moduleAssetType = UnrealModuleType.Unknown;
}
}
}
if (moduleAssetType == UnrealModuleType.Unknown)
{
FMessage.Log(ELogVerbosity.Error, string.Format("Unknown module asset type root:'{0}' path:'{1}' name:'{2}' path2:'{3}'",
rootName, packageFilename, field.GetName(), field.GetPathName()));
}
moduleType = UnrealModuleType.Game;
}
if (moduleType != UnrealModuleType.Unknown)
{
string namespaceName = GetModuleNamespace(moduleType, moduleName, moduleAssetType, allowFoldersAsNamespace, packageFilename);
namespaceCache[package] = new CachedNamespace(namespaceName, moduleName, moduleType, moduleAssetType);
return(namespaceName);
}
else
{
FMessage.Log(ELogVerbosity.Error, string.Format("Unknown module type {0} {1}", packageFilename, moduleName));
}
}
return(null);
}
public CachedType(CachedNamespace ns, Type type)
: this(type) {
Namespace = ns;
}
public CachedNamespace(CachedNamespace ns, string name)
{
Name = name;
Parent = ns;
FullName = ns?.Name == null ? name : (ns.FullName + "." + name);
}
