public void AddProtocolMappingSilentlyOverwritesExistingProtocol() { ResourceHandlerRegistry.RegisterResourceHandler("beep", typeof(FileSystemResource)); // overwrite, must not complain... ResourceHandlerRegistry.RegisterResourceHandler("beep", typeof(AssemblyResource)); IResource res = new ConfigurableResourceLoader().GetResource("beep://Oragon.Spring.Core.Tests/Spring/TestResource.txt"); Assert.IsNotNull(res, "Resource must not be null"); Assert.AreEqual(typeof(AssemblyResource), res.GetType(), "The original IResource Type associated with the 'beep' protocol " + "must have been overwritten; expecting an AssemblyResource 'cos " + "we registered it last under the 'beep' protocol."); }
public void SetUp() { loader = new ConfigurableResourceLoader(); }
/// <summary> /// Creates a new resource that is relative to this resource based on the /// supplied <paramref name="resourceName"/>. /// </summary> /// <remarks> /// <p> /// This method can accept either a fully qualified resource name or a /// relative resource name as it's parameter. /// </p> /// <p> /// A fully qualified resource is one that has a protocol prefix and /// all elements of the resource name. All other resources are treated /// as relative to this resource, and the following rules are used to /// locate a relative resource: /// </p> /// <list type="bullet"> /// <item> /// If the <paramref name="resourceName"/> starts with <c>'..'</c>, /// the current resource path is navigated backwards before the /// <paramref name="resourceName"/> is concatenated to the current /// <see cref="Oragon.Spring.Core.IO.AbstractResource.ResourcePath"/> of /// this resource. /// </item> /// <item> /// If the <paramref name="resourceName"/> starts with '/', the /// current resource path is ignored and a new resource name is /// appended to the /// <see cref="Oragon.Spring.Core.IO.AbstractResource.RootLocation"/> of /// this resource. /// </item> /// <item> /// If the <paramref name="resourceName"/> starts with '.' or a /// letter, a new path is appended to the current /// <see cref="Oragon.Spring.Core.IO.AbstractResource.ResourcePath"/> of /// this resource. /// </item> /// </list> /// </remarks> /// <param name="resourceName"> /// The name of the resource to create. /// </param> /// <returns>The relative resource.</returns> /// <exception cref="System.UriFormatException"> /// If the process of resolving the relative resource yielded an /// invalid URI. /// </exception> /// <exception cref="System.NotSupportedException"> /// If this resource does not support the resolution of relative /// resources (as determined by the value of the /// <see cref="Oragon.Spring.Core.IO.AbstractResource.SupportsRelativeResources"/> /// property). /// </exception> /// <seealso cref="Oragon.Spring.Core.IO.AbstractResource.ResourcePath"/> public virtual IResource CreateRelative(string resourceName) { AssertUtils.ArgumentNotNull(resourceName, "relativePath"); // try to create fully qualified resource... IResourceLoader loader = GetResourceLoader(); if (ConfigurableResourceLoader.HasProtocol(resourceName)) { IResource resource = loader.GetResource(resourceName); if (resource != null) { return(resource); } } if (!SupportsRelativeResources) { throw new NotSupportedException(GetType().Name + " does not support relative resources. Please use fully qualified resource name."); } StringBuilder fullResourceName = new StringBuilder(256); if (Protocol != null && Protocol != String.Empty) { fullResourceName.Append(Protocol).Append(ConfigurableResourceLoader.ProtocolSeparator); } if (!IsRelativeResource(resourceName)) { fullResourceName.Append(resourceName); } else { string targetResource; string resourcePath; int n = resourceName.LastIndexOfAny(new char[] { '/', '\\' }); if (n >= 0) { targetResource = resourceName.Substring(n + 1); resourcePath = CalculateResourcePath(resourceName.Substring(0, n + 1)); } else // only resource name is specified, so current path should be used { targetResource = resourceName; resourcePath = ResourcePath; } fullResourceName.Append(RootLocation.TrimEnd('\\', '/')); if (resourcePath != null && resourcePath != String.Empty) { fullResourceName.Append('/').Append(resourcePath); } fullResourceName.Append('/').Append(targetResource); } string resultResourceName = fullResourceName.ToString(); if (!ConfigurableResourceLoader.HasProtocol(resultResourceName)) { // give derived resource classes a chance to create an instance on their own IResource resultResource = CreateResourceInstance(resultResourceName); if (resultResource != null) { return(resultResource); } } // create resource instance using default loader return(loader.GetResource(resultResourceName)); }
/// <summary> /// Creates a new instance of the /// <see cref="Oragon.Spring.Core.IO.AbstractResource"/> class. /// </summary> /// <remarks> /// <p> /// This is an <see langword="abstract"/> class, and as such exposes no /// public constructors. /// </p> /// </remarks> /// <param name="resourceName"> /// A string representation of the resource. /// </param> /// <exception cref="System.ArgumentNullException"> /// If the supplied <paramref name="resourceName"/> is /// <see langword="null"/> or contains only whitespace character(s). /// </exception> protected AbstractResource(string resourceName) { AssertUtils.ArgumentHasText(resourceName, "resourceName"); this.protocol = ConfigurableResourceLoader.GetProtocol(resourceName); this.resourceName = resourceName; }