protected override void Generate(SourceGeneratorContext context, INamedTypeSymbol typeSymbol)
{
var builder = new IAInputDescBuilder();
ResolveType(builder, (typeSymbol.Name, typeSymbol));
context.AddSource($"{typeSymbol.Name}.IAInputLayout.cs", SourceText.From(builder.ToString(typeSymbol) !, Encoding.UTF8));
}
protected override void GenerateFromSymbol(GeneratorExecutionContext context, INamedTypeSymbol typeSymbol)
{
var builder = new IAInputDescBuilder();
ResolveType(builder, (typeSymbol.Name, typeSymbol), context.Compilation);
context.AddSource($"{typeSymbol}.InputAssemblerLayout.cs", SourceText.From(builder.ToString(typeSymbol) !, Encoding.UTF8));
}
/// <summary>
/// Recupera a chave do template.
/// </summary>
/// <param name="name"></param>
/// <param name="templateType"></param>
/// <param name="context"></param>
/// <returns></returns>
public ITemplateKey GetKey(string name, ResolveType templateType, ITemplateKey context)
{
if (System.Web.Hosting.HostingEnvironment.VirtualPathProvider.FileExists(name))
{
var virtualFile = System.Web.Hosting.HostingEnvironment.VirtualPathProvider.GetFile(name);
var cache = virtualFile as ITemplateCacheSupport;
RazorEngine.Templating.ITemplateKey templateKey = null;
if (cache != null)
{
if (cache.TemplateKey == null)
{
templateKey = new NameOnlyTemplateKey(name, templateType, context);
cache.Register(templateKey);
}
else
{
templateKey = cache.TemplateKey;
}
}
else
{
templateKey = new NameOnlyTemplateKey(name, templateType, context);
}
return(templateKey);
}
return(new NameOnlyTemplateKey(name, templateType, context));
}
public ITemplateKey GetKey(string name, ResolveType resolveType, ITemplateKey context)
{
if (ManifestResourceHelper.checkExistsManifestResource(name))
{
return(new ResourcePathTemplateKey(name, name, resolveType, context));
}
var existsResourceNames = layoutRoots.Select(m =>
{
string resourcePath = string.Format(m, name);
if (ManifestResourceHelper.checkExistsManifestResource(resourcePath))
{
return(resourcePath);
}
resourcePath += ".cshtml";
if (ManifestResourceHelper.checkExistsManifestResource(resourcePath))
{
return(resourcePath);
}
return(null);
});
var resourceName = existsResourceNames.Where(m => !string.IsNullOrEmpty(m)).FirstOrDefault();
if (resourceName == null)
{
throw new InvalidOperationException(string.Format("Could not resolve template {0}", name));
}
return(new ResourcePathTemplateKey(name, resourceName, resolveType, context));
}
/// <summary>
/// Get the given key.
/// </summary>
/// <param name="name"></param>
/// <param name="resolveType"></param>
/// <param name="context"></param>
/// <returns></returns>
public ITemplateKey GetKey(string name, ResolveType resolveType, ITemplateKey context)
{
if (File.Exists(name))
{
return(new FullPathTemplateKey(name, name, resolveType, context));
}
else
{
var resolved = layoutRoots.Select(l =>
{
var p = Path.Combine(l, name);
if (File.Exists(p))
{
return(p);
}
else if (File.Exists(p + ".cshtml"))
{
return(p + ".cshtml");
}
else
{
return(null);
}
}).Where(l => l != null).FirstOrDefault();
if (resolved == null)
{
throw new InvalidOperationException(string.Format("Could not resolve template {0}", name));
}
else
{
return(new FullPathTemplateKey(name, resolved, resolveType, context));
}
}
}
/// <summary>
/// Get the given key.
/// </summary>
/// <param name="name"></param>
/// <param name="resolveType"></param>
/// <param name="context"></param>
/// <returns></returns>
public new ITemplateKey GetKey(string name, ResolveType resolveType, ITemplateKey context)
{
var fullPath = ResolveFilePath(name);
var modifiedTime = File.GetLastWriteTimeUtc(fullPath);
return(new FullPathWithModifiedTimeTemplateKey(name, fullPath, modifiedTime, resolveType, context));
}
public ResolveExpr(ITargetDatabase db, CsGlobalNamespace globals, ResolveName nameResolver)
{
m_globals = globals;
m_nameResolver = nameResolver;
m_typeResolver = new ResolveType(db);
m_memberResolver = new ResolveMembers(db);
}
public ITemplateKey GetKey(string name, ResolveType resolveType, ITemplateKey context)
{
var ctx = new KeyNameResolveContext()
{
OriginalName = name,
ResolveType = resolveType,
Context = context,
ResolvedName = name,
NameResolved = false
};
// I need to read resolvers from WorkContext here, because if I injected them in the class constructor they wouldn't work properly.
// They cache their content throughout multiple requests and fail to update content templates when needed.
// This happens because IRazorTemplateManager inherits from ISingletonDependency.
var resolvers = _orchardServices.WorkContext
.Resolve <IEnumerable <ICustomRazorTemplateResolver> >()
.OrderByDescending(r => r.Priority);
foreach (var res in resolvers)
{
if (ctx.NameResolved)
{
break;
}
res.GetKeyName(ctx);
}
return(new NameOnlyTemplateKey(ctx.ResolvedName, resolveType, context));
}
/// <summary>
/// 获取键
/// </summary>
/// <param name="name">名称</param>
/// <param name="resolveType">解决类型</param>
/// <param name="key">键</param>
/// <returns>返回键</returns>
public ITemplateKey GetKey(string name, ResolveType resolveType, ITemplateKey key)
{
// 如果你可以有不同的模板具有相同名称的根据
// 上下文或resolveType你需要自己实现!
// 否则你可以使用NameOnlyTemplateKey。
return(new NameOnlyTemplateKey(name, resolveType, key));
}
/// <summary>
/// Get the given key.
/// </summary>
/// <param name="name"></param>
/// <param name="resolveType"></param>
/// <param name="context"></param>
/// <returns></returns>
public ITemplateKey GetKey(string name, ResolveType resolveType, ITemplateKey context)
{
if (File.Exists (name))
{
return new FullPathTemplateKey(name, name, resolveType, context);
}
else
{
var resolved = layoutRoots.Select(l =>
{
var p = Path.Combine(l, name);
if (File.Exists(p))
{
return p;
}
else if (File.Exists(p + ".cshtml"))
{
return p + ".cshtml";
}
else
{
return null;
}
}).Where(l => l != null).FirstOrDefault();
if (resolved == null)
{
throw new InvalidOperationException(string.Format("Could not resolve template {0}", name));
}
else
{
return new FullPathTemplateKey(name, resolved, resolveType, context);
}
}
}
public ITemplateKey GetKey(string name, ResolveType resolveType, ITemplateKey context)
{
// If you can have different templates with the same name depending on the
// context or the resolveType you need your own implementation here!
// Otherwise you can just use NameOnlyTemplateKey.
return new NameOnlyTemplateKey(name, resolveType, context);
}
/// <summary>
/// Get the given key.
/// </summary>
/// <param name="name"></param>
/// <param name="resolveType"></param>
/// <param name="context"></param>
/// <returns></returns>
public new ITemplateKey GetKey(string name, ResolveType resolveType, ITemplateKey context)
{
var fullPath = ResolveFilePath(name);
var modifiedTime = File.GetLastWriteTimeUtc(fullPath);
return new FullPathWithModifiedTimeTemplateKey(name, fullPath, modifiedTime, resolveType, context);
}
public ITemplateKey GetKey(string name, ResolveType resolveType, ITemplateKey context)
{
if (ManifestResourceHelper.checkExistsManifestResource(name))
{
return new ResourcePathTemplateKey(name, name, resolveType, context);
}
var existsResourceNames = layoutRoots.Select(m =>
{
string resourcePath = string.Format(m, name);
if (ManifestResourceHelper.checkExistsManifestResource(resourcePath))
{
return resourcePath;
}
resourcePath += ".cshtml";
if (ManifestResourceHelper.checkExistsManifestResource(resourcePath))
{
return resourcePath;
}
return null;
});
var resourceName = existsResourceNames.Where(m => !string.IsNullOrEmpty(m)).FirstOrDefault();
if (resourceName == null)
{
throw new InvalidOperationException(string.Format("Could not resolve template {0}", name));
}
return new ResourcePathTemplateKey(name, resourceName, resolveType, context);
}
public ITemplateKey GetKey(string name, ResolveType resolveType, ITemplateKey context)
{
// If you can have different templates with the same name depending on the
// context or the resolveType you need your own implementation here!
// Otherwise you can just use NameOnlyTemplateKey.
return(new NameOnlyTemplateKey(name, resolveType, context));
}
private async Task <string> generateResponse(string id, ResolveType resolveType)
{
var lectureItem = await _context.Lectures.Include(l => l.StorageItems).Include(l => l.Contents).ThenInclude(p => p.Dependencies).SingleOrDefaultAsync((item) => item.ID == id);
var packageListResolved = new List <int>();
var packageInstallCommands = new List <string>();
if (lectureItem == null)
{
return(String.Empty);
}
foreach (var package in lectureItem.Contents)
{
if (packageListResolved.Contains(package.ID))
{
continue;
}
packageListResolved.Add(package.ID);
packageInstallCommands.AddRange(resolve(package, resolveType));
}
if (resolveType == ResolveType.Download)
{
lectureItem.StorageItems?.ForEach(lsi =>
{
var url = $"{Request.Scheme}://{Request.Host}/api/lecture/{lectureItem.ID}/file/{lsi.Filename}";
packageInstallCommands.Add(DownloadScript.Replace("$!URL!$", url));
});
}
return(string.Join(" && ", packageInstallCommands));
}
/// <summary>
/// Resolves the template with the specified name.
/// </summary>
/// <param name="name">The name of the template type in cache.</param>
/// <param name="model">The model or NULL if there is no model for the template.</param>
/// <param name="modelType"></param>
/// <param name="resolveType"></param>
/// <returns>The resolved template.</returns>
public ITemplate Resolve(string name, object model, Type modelType, ResolveType resolveType)
{
DynamicWrapperService.CheckModelType(modelType);
return(_service.ResolveInternal(
name,
DynamicWrapperService.GetDynamicModel(
modelType, model, _service.Configuration.AllowMissingPropertiesOnDynamic),
modelType, resolveType, _template));
}
/// <summary>
/// Resolves the template with the specified name.
/// </summary>
/// <param name="name">The name of the template type in cache.</param>
/// <param name="model">The model or NULL if there is no model for the template.</param>
/// <param name="modelType"></param>
/// <param name="resolveType"></param>
/// <returns>The resolved template.</returns>
public ITemplate Resolve(string name, object model, Type modelType, ResolveType resolveType)
{
DynamicWrapperService.CheckModelType(modelType);
return _service.ResolveInternal(
name,
DynamicWrapperService.GetDynamicModel(
modelType, model, _service.Configuration.AllowMissingPropertiesOnDynamic),
modelType, resolveType, _template);
}
public IdentityTemplateKey(string name,
string clientId,
string tenant,
ResolveType resolveType = ResolveType.Global)
{
Name = name;
ClientId = clientId;
Tenant = tenant;
TemplateType = resolveType;
}
public ITemplateKey GetKey(string name, ResolveType resolveType, ITemplateKey context)
{
var files = PackageDirectory.EnumerateFiles("*.cshtml", SearchOption.AllDirectories);
var template = files.FirstOrDefault(f => f.Name == name);
if (template == null)
{
throw new FileNotFoundException("Could not find requested template", name);
}
return(new PackageKey(template.FullName, resolveType, context));
}
internal override ITemplate ResolveInternal(string cacheName, object model, Type modelType, DynamicViewBag viewbag, ResolveType resolveType, ITemplateKey context)
{
var templateKey = GetKey(cacheName, resolveType, context);
ICompiledTemplate compiledTemplate;
if (!Configuration.CachingProvider.TryRetrieveTemplate(templateKey, modelType, out compiledTemplate))
{
compiledTemplate = Compile(templateKey, modelType);
Configuration.CachingProvider.CacheTemplate(compiledTemplate, templateKey);
}
return CreateTemplate(compiledTemplate, model, viewbag);
}
public ITemplateKey GetKey(string name, ResolveType resolveType, ITemplateKey context)
{
var itk = context as IdentityTemplateKey;
if (itk != null)
{
return new IdentityTemplateKey(name, itk.ClientId, itk.Tenant, resolveType);
}
return null;
}
public ITemplateKey GetKey(string name, ResolveType resolveType, ITemplateKey context)
{
var itk = context as IdentityTemplateKey;
if (itk != null)
{
return(new IdentityTemplateKey(name, itk.ClientId, itk.Tenant, resolveType));
}
return(null);
}
public ResolveType SetResolveType(P4.ResolveType type)
{
try
{
ResolveType = type;
}
catch
{
return(P4.ResolveType.None);
}
return(type);
}
private List <string> resolve(Package p, ResolveType resolveType)
{
List <string> sub = new List <string>();
if (p.Dependencies == null || p.Dependencies.Count == 0)
{
foreach (var artifact in _context.Artifacts.Include(asi => asi.StorageItems).Where((art) => art.ID == p.ArtifactRefID))
{
if (resolveType.HasFlag(ResolveType.Download))
{
artifact.StorageItems?.ForEach(asi =>
{
var url = $"{Request.Scheme}://{Request.Host}/api/artifact/{artifact.ID}/file/{asi.Filename}";
sub.Add(DownloadScript.Replace("$!URL!$", url));
});
}
if (resolveType.HasFlag(ResolveType.Install))
{
sub.Add(artifact.InstallAction);
}
if (resolveType.HasFlag(ResolveType.Remove))
{
sub.Add(artifact.RemoveAction);
}
if (resolveType.HasFlag(ResolveType.Switch))
{
sub.Add(artifact.SwitchAction);
}
if (resolveType.HasFlag(ResolveType.Unswitch))
{
sub.Add(artifact.UnswitchAction);
}
}
}
else
{
foreach (var subpackage in p.Dependencies)
{
if (subpackage == null)
{
continue;
}
sub.AddRange(resolve(subpackage, resolveType));
}
}
return(sub);
}
/// <summary>
/// Gets the name of an agent by UUID. Will block for a short period of time to allow for name resolution.
/// </summary>
/// <param name="agentID">Agent UUID</param>
/// <param name="nameType">Type of name resolution. See ResolveType</param>
/// <returns>Name of agent on success, INCOMPLETE_NAME on failure or timeout</returns>
private string GetAgentName(UUID agentID, ResolveType nameType)
{
RadegastInstance instance = RadegastInstance.GlobalInstance;
string name = RadegastInstance.INCOMPLETE_NAME;
using (ManualResetEvent gotName = new ManualResetEvent(false))
{
EventHandler <UUIDNameReplyEventArgs> handler = (sender, e) =>
{
if (e.Names.ContainsKey(agentID))
{
name = e.Names[agentID];
try
{
gotName.Set();
}
catch (ObjectDisposedException) { }
}
};
instance.Names.NameUpdated += handler;
if (nameType == ResolveType.AgentDefaultName)
{
name = instance.Names.Get(agentID);
}
else if (nameType == ResolveType.AgentUsername)
{
name = instance.Names.GetUserName(agentID);
}
else if (nameType == ResolveType.AgentDisplayName)
{
name = instance.Names.GetDisplayName(agentID);
}
else
{
instance.Names.NameUpdated -= handler;
return(agentID.ToString());
}
if (name == RadegastInstance.INCOMPLETE_NAME)
{
gotName.WaitOne(instance.GlobalSettings["resolve_uri_time"], false);
}
instance.Names.NameUpdated -= handler;
}
return(name);
}
internal IResolver Create(ResolveType resolveType)
{
switch (resolveType)
{
case ResolveType.Single:
return(new SingleTypeResolver(container));
case ResolveType.Collection:
return(new CollectionTypeResolver(container));
default:
return(new SingleTypeResolver(container));
}
}
/// <summary>
/// Gets the name of an agent by UUID. Will block for a short period of time to allow for name resolution.
/// </summary>
/// <param name="agentID">Agent UUID</param>
/// <param name="nameType">Type of name resolution. See ResolveType</param>
/// <returns>Name of agent on success, INCOMPLETE_NAME on failure or timeout</returns>
private string GetAgentName(UUID agentID, ResolveType nameType)
{
METAboltInstance instance = METAboltInstance.GlobalInstance;
string name = METAboltInstance.INCOMPLETE_NAME;
using (ManualResetEvent gotName = new ManualResetEvent(false))
{
EventHandler <UUIDNameReplyEventArgs> handler = (object sender, UUIDNameReplyEventArgs e) =>
{
if (e.Names.ContainsKey(agentID))
{
name = e.Names[agentID];
try
{
gotName.Set();
}
catch (ObjectDisposedException) { }
}
};
instance.Names.NameUpdated += handler;
if (nameType == ResolveType.AgentCompleteName)
{
name = instance.Names.GetLegacyName(agentID);
}
else if (nameType == ResolveType.AgentUsername)
{
name = instance.Names.GetUserName(agentID);
}
else if (nameType == ResolveType.AgentDisplayName)
{
name = instance.Names.GetDisplayName(agentID);
}
else
{
return(agentID.ToString());
}
if (name == METAboltInstance.INCOMPLETE_NAME)
{
gotName.WaitOne(NameResolveTimeoutInMs, false);
}
instance.Names.NameUpdated -= handler;
}
return(name);
}
public async Task <bool> Update(ResolveType resolveType, List <string> errors)
{
try
{
resolveType.IsActive = true;
_unitOfWork.ResolveTypes.Update(resolveType);
return(await _unitOfWork.CommitAsync() > 0);
}
catch (Exception ex)
{
errors.Add(ex.Message);
return(false);
}
}
string Resolve(string key, ResolveType type)
{
switch (type)
{
case ResolveType.AgentCompleteName:
case ResolveType.AgentDisplayName:
case ResolveType.AgentUsername:
return(GetAgentName(key, type));
case ResolveType.Group:
return(GetGroupName(key));
default:
return("{Resolved " + type + "}");
}
}
private string GetAgentName(string key, ResolveType nameType)
{
UUID agentID = new UUID(key);
string name = null;
using (ManualResetEvent gotName = new ManualResetEvent(false))
{
EventHandler <UUIDNameReplyEventArgs> handler = (object sender, UUIDNameReplyEventArgs e) =>
{
if (e.Names.ContainsKey(agentID))
{
name = e.Names[agentID];
gotName.Set();
}
};
instance.Names.NameUpdated += handler;
if (nameType == ResolveType.AgentCompleteName)
{
name = instance.Names.GetLegacyName(agentID);
}
else if (nameType == ResolveType.AgentUsername)
{
name = instance.Names.GetUserName(agentID);
}
else if (nameType == ResolveType.AgentDisplayName)
{
name = instance.Names.GetDisplayName(agentID);
}
else
{
return("[INVALID]");
}
if (name == RadegastInstance.INCOMPLETE_NAME)
{
gotName.WaitOne(NameResolveTimeoutInMs, false);
}
instance.Names.NameUpdated -= handler;
}
return(name);
}
/// <summary>
/// Attempts to resolve the name of a given key by type (Agent, Group, Parce, etc)
/// </summary>
/// <param name="id">UUID of object to resolve</param>
/// <param name="type">Type of object</param>
/// <returns>Revoled name</returns>
private string Resolve(UUID id, ResolveType type)
{
switch (type)
{
case ResolveType.AgentDefaultName:
case ResolveType.AgentDisplayName:
case ResolveType.AgentUsername:
return(GetAgentName(id, type));
case ResolveType.Group:
return(GetGroupName(id));
case ResolveType.Parcel:
return(GetParcelName(id));
default:
return(id.ToString());
}
}
public async Task <ActionResult> Edit(ResolveType resolveType)
{
try
{
if (ModelState.IsValid)
{
var result = await _resolveType.Update(resolveType, errors);
if (result)
{
TempData["isSuccess"] = true;
return(RedirectToAction("Index", "ResolveType"));
}
}
}
catch
{
}
ViewBag.InsertFailed = true;
return(View(resolveType));
}
public static string GetName(Dictionary <ulong, Record> map, CASCHandler handler, ulong id)
{
if (handler == null)
{
return(null);
}
ResolveType type = (ResolveType)GUID.Type(id);
if (type == ResolveType.COSMETIC)
{
return(ListInventory.GetInventoryName(id, map, handler)?.Item1);
}
if (type == ResolveType.WEAPON_SKIN)
{
return(null); // TODO: A lot of overhead to get weaponskin name.
}
if (type == ResolveType.HERO)
{
STUD hero = new STUD(OverTool.Util.OpenFile(map[id], handler));
HeroMaster master = hero?.Instances[0] as HeroMaster;
if (master == null)
{
return(null);
}
return(OverTool.Util.GetString(master.Header.name.key, map, handler));
}
if (type == ResolveType.MAP)
{
return(null); // TODO: document 002 file types
}
return(null);
}
internal static void ResolveStudioFilter(ExtensibleSaveFormat.PluginData extData, ResolveType resolveType)
{
//Set filter ID to the resolved ID
int filterID = Studio.Studio.Instance.sceneInfo.aceNo;
if (extData != null && extData.data.ContainsKey("filterInfoGUID"))
{
string filterGUID = (string)extData.data["filterInfoGUID"];
StudioResolveInfo intResolve = LoadedStudioResolutionInfo.FirstOrDefault(x => x.ResolveItem && x.Slot == filterID && x.GUID == filterGUID);
if (intResolve != null)
{
if (resolveType == ResolveType.Load && Sideloader.DebugLogging.Value)
{
Sideloader.Logger.Log(LogLevel.Debug, $"Resolving (Studio Filter) [{filterGUID}] {filterID}->{intResolve.LocalSlot}");
}
Studio.Studio.Instance.sceneInfo.aceNo = intResolve.LocalSlot;
}
else
{
ShowGUIDError(filterGUID);
}
}
else if (resolveType == ResolveType.Load)
{
if (!Info.Instance.dicFilterLoadInfo.TryGetValue(filterID, out Info.LoadCommonInfo filterInfo))
{
//Filter ID saved to the scene doesn't exist in the filter list, try compatibility resolving
StudioResolveInfo intResolve = LoadedStudioResolutionInfo.FirstOrDefault(x => x.ResolveItem && x.Slot == filterID);
if (intResolve != null)
{
//Found a matching sideloader mod
if (Sideloader.DebugLogging.Value)
{
Sideloader.Logger.Log(LogLevel.Debug, $"Compatibility resolving (Studio Filter) {filterID}->{intResolve.LocalSlot}");
}
Studio.Studio.Instance.sceneInfo.aceNo = intResolve.LocalSlot;
}
else
{
Sideloader.Logger.Log(LogLevel.Warning | LogLevel.Message, $"[UAR] Compatibility resolving (Studio Filter) failed, no match found for ID {filterID}");
}
}
}
}
/// <summary>
/// Gets the key for a template.
/// See <see cref="ITemplateManager.GetKey"/>.
/// </summary>
/// <param name="name">name of the template</param>
/// <param name="templateType">the type of the resolve-context</param>
/// <param name="context">the context (ie. parent template).</param>
/// <returns></returns>
public ITemplateKey GetKey(string name, ResolveType templateType, ITemplateKey context)
{
return new NameOnlyTemplateKey(name, templateType, context);
}
/// <summary>
/// Gets a given key from the <see cref="ITemplateManager"/> implementation.
/// See <see cref="ITemplateManager.GetKey"/>.
/// </summary>
/// <param name="cacheName"></param>
/// <param name="resolveType"></param>
/// <param name="context"></param>
/// <returns></returns>
public ITemplateKey GetKey(string cacheName, ResolveType resolveType = ResolveType.Global, ITemplateKey context = null)
{
return _core_with_cache.GetKey(cacheName, resolveType, context);
}
public ITemplateKey GetKey(string name, ResolveType resolveType = ResolveType.Global, ITemplateKey context = null)
{
return _origin.GetKey(name, resolveType, context);
}
/// <summary>
/// Initializes a new instance of the <see cref="NameOnlyTemplateKey"/> class.
/// </summary>
/// <param name="name"></param>
/// <param name="resolveType"></param>
/// <param name="context"></param>
public NameOnlyTemplateKey(string name, ResolveType resolveType, ITemplateKey context)
: base(name, resolveType, context) { }
/// <summary>
/// Create a new <see cref="BaseTemplateKey"/> instance.
/// </summary>
/// <param name="name">See <see cref="ITemplateKey.Name"/></param>
/// <param name="resolveType">See <see cref="ITemplateKey.TemplateType"/></param>
/// <param name="context">See <see cref="ITemplateKey.Context"/></param>
public BaseTemplateKey(string name, ResolveType resolveType, ITemplateKey context)
{
_name = name;
_resolveType = resolveType;
_context = context;
}
public ITemplateKey GetKey(string cacheName, ResolveType resolveType = ResolveType.Global, ITemplateKey context = null)
{
return _config.TemplateManager.GetKey(cacheName, resolveType, context);
}
/// <summary>
/// Gets a given key from the <see cref="ITemplateManager"/> implementation.
/// See <see cref="ITemplateManager.GetKey"/>.
/// </summary>
/// <param name="cacheName"></param>
/// <param name="resolveType"></param>
/// <param name="context"></param>
/// <returns></returns>
public ITemplateKey GetKey(string cacheName, ResolveType resolveType = ResolveType.Global, ITemplateKey context = null)
{
return(_core_with_cache.GetKey(cacheName, resolveType, context));
}
internal static void ResolveStudioRamp(ExtensibleSaveFormat.PluginData extData, ResolveType resolveType)
{
//Set ramp ID to the resolved ID
int rampID = Studio.Studio.Instance.sceneInfo.rampG;
if (extData != null && extData.data.ContainsKey("rampInfoGUID"))
{
string rampGUID = (string)extData.data["rampInfoGUID"];
ResolveInfo intResolve = LoadedResolutionInfo.FirstOrDefault(x => x.Property == "Ramp" && x.GUID == rampGUID && x.Slot == rampID);
if (intResolve != null)
{
if (resolveType == ResolveType.Load && Sideloader.DebugLogging.Value)
{
Sideloader.Logger.Log(LogLevel.Debug, $"Resolving (Studio Ramp) [{rampID}] {rampID}->{intResolve.LocalSlot}");
}
Studio.Studio.Instance.sceneInfo.rampG = intResolve.LocalSlot;
}
else
{
ShowGUIDError(rampGUID);
}
}
else if (resolveType == ResolveType.Load)
{
if (!ListLoader.InternalDataList[ChaListDefine.CategoryNo.mt_ramp].ContainsKey(rampID))
{
//Ramp ID saved to the scene doesn't exist in the items list, try compatibility resolving
ResolveInfo intResolve = LoadedResolutionInfo.FirstOrDefault(x => x.Property == "Ramp" && x.Slot == rampID);
if (intResolve != null)
{
//Found a matching sideloader mod
if (Sideloader.DebugLogging.Value)
{
Sideloader.Logger.Log(LogLevel.Debug, $"Compatibility resolving (Studio Ramp) {rampID}->{intResolve.LocalSlot}");
}
Studio.Studio.Instance.sceneInfo.rampG = intResolve.LocalSlot;
}
else
{
Sideloader.Logger.Log(LogLevel.Warning | LogLevel.Message, $"[UAR] Compatibility resolving (Studio Ramp) failed, no match found for ID {rampID}");
}
}
}
}
/// <summary>
/// Attempts to resolve the name of a given key by type (Agent, Group, Parce, etc)
/// </summary>
/// <param name="id">UUID of object to resolve</param>
/// <param name="type">Type of object</param>
/// <returns>Revoled name</returns>
private string Resolve(UUID id, ResolveType type)
{
switch (type)
{
case ResolveType.AgentCompleteName:
case ResolveType.AgentDisplayName:
case ResolveType.AgentUsername:
return GetAgentName(id, type);
case ResolveType.Group:
return GetGroupName(id);
case ResolveType.Parcel:
return GetParcelName(id);
default:
return id.ToString();
}
}
/// <summary>
/// Get the given key.
/// </summary>
/// <param name="name"></param>
/// <param name="resolveType"></param>
/// <param name="context"></param>
/// <returns></returns>
public ITemplateKey GetKey(string name, ResolveType resolveType, ITemplateKey context)
{
return new FullPathTemplateKey(name, ResolveFilePath(name), resolveType, context);
}
/// <summary>
/// Gets the name of an agent by UUID. Will block for a short period of time to allow for name resolution.
/// </summary>
/// <param name="agentID">Agent UUID</param>
/// <param name="nameType">Type of name resolution. See ResolveType</param>
/// <returns>Name of agent on success, INCOMPLETE_NAME on failure or timeout</returns>
private string GetAgentName(UUID agentID, ResolveType nameType)
{
RadegastInstance instance = RadegastInstance.GlobalInstance;
string name = RadegastInstance.INCOMPLETE_NAME;
using (ManualResetEvent gotName = new ManualResetEvent(false))
{
EventHandler<UUIDNameReplyEventArgs> handler = (object sender, UUIDNameReplyEventArgs e) =>
{
if (e.Names.ContainsKey(agentID))
{
name = e.Names[agentID];
try
{
gotName.Set();
}
catch (ObjectDisposedException) { }
}
};
instance.Names.NameUpdated += handler;
if (nameType == ResolveType.AgentCompleteName)
{
name = instance.Names.GetLegacyName(agentID);
}
else if (nameType == ResolveType.AgentUsername)
{
name = instance.Names.GetUserName(agentID);
}
else if (nameType == ResolveType.AgentDisplayName)
{
name = instance.Names.GetDisplayName(agentID);
}
else
{
return agentID.ToString();
}
if (name == RadegastInstance.INCOMPLETE_NAME)
{
gotName.WaitOne(NameResolveTimeoutInMs, false);
}
instance.Names.NameUpdated -= handler;
}
return name;
}
public ResolveName(CsMember context, ITargetDatabase database, ICsLocalsParser locals, string text, int offset, CsGlobalNamespace globals)
{
Profile.Start("ResolveName::ctor");
m_database = database;
m_typeResolver = new ResolveType(database);
m_globals = globals;
m_offset = offset;
m_context = context;
Profile.Start("DoFindMember");
m_member = DoFindMember(m_globals);
Profile.Stop("DoFindMember");
Profile.Start("DoGetVariables");
m_variables = DoGetVariables(text, locals);
Profile.Stop("DoGetVariables");
Profile.Stop("ResolveName::ctor");
}
internal static void ResolveStudioObjects(ExtensibleSaveFormat.PluginData extendedData, ResolveType resolveType)
{
Dictionary <int, ObjectInfo> ObjectList = StudioObjectSearch.FindObjectInfo(StudioObjectSearch.SearchType.All);
//Resolve every item with extended data
if (extendedData != null && extendedData.data.ContainsKey("itemInfo"))
{
List <StudioResolveInfo> extInfo;
if (resolveType == ResolveType.Save)
{
extInfo = ((List <byte[]>)extendedData.data["itemInfo"]).Select(x => StudioResolveInfo.Deserialize(x)).ToList();
}
else
{
extInfo = ((object[])extendedData.data["itemInfo"]).Select(x => StudioResolveInfo.Deserialize((byte[])x)).ToList();
}
foreach (StudioResolveInfo extResolve in extInfo)
{
ResolveStudioObject(extResolve, ObjectList[extResolve.DicKey], resolveType);
ObjectList.Remove(extResolve.DicKey);
}
}
//Resolve every item without extended data in case of hard mods
if (resolveType == ResolveType.Load)
{
foreach (ObjectInfo OI in ObjectList.Where(x => x.Value is OIItemInfo || x.Value is OILightInfo).Select(x => x.Value))
{
if (OI is OIItemInfo Item)
{
ResolveStudioObject(Item);
}
else if (OI is OILightInfo Light)
{
ResolveStudioObject(Light);
}
}
}
}
public ResourcePathTemplateKey(string name, string resourcePath, ResolveType resolveType, ITemplateKey context)
: base(name, resolveType, context)
{
ResourcePath = resourcePath;
}
public ITemplateKey GetKey(string name, ResolveType resolveType = ResolveType.Global, ITemplateKey context = null)
{
return(_origin.GetKey(name, resolveType, context));
}
/// <summary>
/// Gets a key for the given template.
/// </summary>
/// <param name="name"></param>
/// <param name="resolveType"></param>
/// <param name="context"></param>
/// <returns></returns>
public ITemplateKey GetKey(string name, ResolveType resolveType, ITemplateKey context)
{
return inner.GetKey(name, resolveType, context);
}
internal virtual ITemplate ResolveInternal(string cacheName, object model, Type modelType, DynamicViewBag viewBag, ResolveType resolveType, ITemplateKey context)
{
var templateKey = GetKey(cacheName, resolveType, context);
var compiledTemplate = Compile(templateKey, modelType);
return CreateTemplate(compiledTemplate, model, viewBag);
}
/// <summary>
/// Initializes a new instance of the <see cref="NameOnlyTemplateKey"/> class.
/// </summary>
/// <param name="name"></param>
/// <param name="fullPath"></param>
/// <param name="resolveType"></param>
/// <param name="context"></param>
public FullPathTemplateKey(string name, string fullPath, ResolveType resolveType, ITemplateKey context)
: base(name, resolveType, context)
{
this.fullPath = NormalizePath(fullPath);
}
