/// <summary>
/// Registers the namespace of the given Type with the given prefix
/// </summary>
/// <param name="service">The service to register to</param>
/// <param name="prefix">The prefix that should be used</param>
/// <param name="ns">The namespace that should get registered</param>
/// <param name="overwrite">The flag if the existing should be overwritten</param>
/// <returns>The service itself</returns>
public static XamlService RegisterNamespace(this XamlService service, string prefix, string ns, bool overwrite = false)
{
if (string.IsNullOrEmpty(ns))
{
return(service);
}
if (string.IsNullOrEmpty(prefix))
{
return(service);
}
if (service is null)
{
return(null);
}
var prefixExists = service.XmlnsDeclarations.ContainsKey(prefix);
var foundNamespace = service.XmlnsDeclarations.FirstOrDefault(o => o.Value.Declaration == ns).Value;
var newDeclaration = new XmlnsDeclaration(prefix, ns, false);
// if both (namespace and prefix) exists -> abort
if (prefixExists && foundNamespace != null)
{
return(service);
}
// if only namespace exists and overwrite is false
if (!overwrite && foundNamespace != null)
{
return(service);
}
// if only namespace exists
if (foundNamespace != null)
{
// delete the found registered
service.XmlnsDeclarations.Remove(foundNamespace.Prefix);
service.XmlnsDeclarations.Add(prefix, newDeclaration);
return(service);
}
// if only prefix exists and overwrite is false
if (!overwrite && prefixExists)
{
return(service);
}
// if only prefix exists and overwrite is true
if (overwrite && prefixExists)
{
service.XmlnsDeclarations[prefix] = newDeclaration;
}
// if nothing exists
else
{
service.XmlnsDeclarations.Add(prefix, newDeclaration);
}
return(service);
}
/// <summary>
/// Generates a unique prefix with the given namespace for the given service
/// </summary>
/// <param name="service">The service to register to</param>
/// <param name="ns">The namespaces that should get registered to the url</param>
/// <returns>The generated prefix</returns>
// ReSharper disable once InconsistentNaming
private static string GeneratePrefix(this XamlService service, string ns)
{
// check if namespace is null or empty
if (string.IsNullOrEmpty(ns))
{
return(null);
}
// helper lists -> prefixes and declarations
var declarations = service.XmlnsDeclarations.Values.Select(o => o.Declaration).ToList();
var prefixes = service.XmlnsDeclarations.Keys.ToList();
// if namespace is already used
if (declarations.Contains(ns))
{
return(null);
}
var resultPrefix = string.Empty;
var splitted = ns.Split('.');
var exists = true;
var iteration = 0;
var longest = splitted.Select(o => o.Length).OrderByDescending(o => o).First();
// try combinations of the words from the namespaces
while (exists)
{
iteration++;
resultPrefix = splitted.Aggregate(string.Empty, (current, split) => current + string.Concat(split.Take(iteration)));
resultPrefix = resultPrefix.ToLower();
exists = prefixes.Contains(resultPrefix) || iteration == longest;
}
// if prefix is not used -> return result
if (!prefixes.Contains(resultPrefix))
{
return(resultPrefix);
}
// add x to the end until it is unique :-p
exists = true;
while (exists)
{
resultPrefix += 'x';
exists = prefixes.Contains(resultPrefix);
}
return(resultPrefix);
}
/// <summary>
/// Registers the should serialize Function with the given T and TParent
/// </summary>
/// <param name="service">The service to register to</param>
/// <param name="shouldSerialize">The function that defines the shouldSerialize behavior</param>
/// <typeparam name="T">The object itself</typeparam>
/// <typeparam name="TParent">The objects parent</typeparam>
/// <returns>The service itself</returns>
public static XamlService RegisterShouldSerialize <T, TParent>(this XamlService service, Func <T, TParent, bool> shouldSerialize)
{
var objectType = typeof(T);
if (service.ShouldSerializeSettings.ContainsKey(objectType))
{
service.ShouldSerializeSettings[objectType].Register(shouldSerialize);
}
else
{
var setting = new ShouldSerializeSetting();
setting.Register(shouldSerialize);
service.ShouldSerializeSettings.Add(objectType, setting);
}
return(service);
}
public static XamlService RegisterStringSerializer <T>(this XamlService service, Func <T, string> serialize, RegisterPriority priority)
{
return(service);
}
public static XamlService RegisterChildrenProperty <T, TParent>(this XamlService service, Func <T, TParent, bool> shouldUseFilter, RegisterPriority priority)
{
return(service);
}
public static XamlService RegisterChildrenProperty(this XamlService service, Type property, Type parent, RegisterPriority priority)
{
return(service);
}
public static XamlService RegisterChildrenProperty(this XamlService service, Func <object, object, bool> shouldUseFilter, RegisterPriority priority) => service.RegisterChildrenProperty <object, object>(shouldUseFilter, priority);
public static XamlService RegisterChildrenProperty <T, TParent>(this XamlService service, RegisterPriority priority) => service.RegisterChildrenProperty(typeof(T), typeof(TParent), priority);
/// <summary> /// Registers the namespace of the given Type with the given prefix /// </summary> /// <param name="service">The service to register to</param> /// <param name="ns">The namespace that should get registered</param> /// <param name="overwrite">The flag if the existing should be overwritten</param> /// <returns>The service itself</returns> public static XamlService RegisterNamespace(this XamlService service, string ns, bool overwrite = false) => service.RegisterNamespace(service.GeneratePrefix(ns), ns, overwrite);
/// <summary> /// Registers the namespace of the given Type with the given prefix /// </summary> /// <param name="service">The service to register to</param> /// <param name="prefix">The prefix that should be used</param> /// <param name="overwrite">The flag if the existing should be overwritten</param> /// <typeparam name="T">The Type of which the namespace should get registered</typeparam> /// <returns>The service itself</returns> public static XamlService RegisterNamespace <T>(this XamlService service, string prefix, bool overwrite = false) => service.RegisterNamespace(prefix, typeof(T).Namespace, overwrite);
public static XamlService RegisterThreadExecution(this XamlService service, Action <Action> executeInside, RegisterPriority priority)
{
return(service);
}
public static XamlService RegisterThreadExecution(this XamlService service, Thread thread, RegisterPriority priority)
{
return(service);
}
public static XamlService RegisterContentProperty(this XamlService service, Type property, RegisterPriority priority)
{
service.RegisterContentProperty <object>(RegisterPriority.Highest);
return(service);
}
public static XamlService RegisterStringSerializer <T, TParent>(this XamlService service, Func <T, TParent, string> serialize, Func <T, TParent, bool> shouldSerialize, RegisterPriority priority)
{
return(service);
}
/// <summary>
/// Registers the namespaces to the given url with the given prefix
/// </summary>
/// <param name="service">The service to register to</param>
/// <param name="prefix">The prefix that should be used</param>
/// <param name="url">The url that should get registered</param>
/// <param name="overwrite">The flag if the existing should be overwritten</param>
/// <param name="ns">The namespaces that should get registered to the url</param>
/// <returns>The service itself</returns>
public static XamlService RegisterUrl(this XamlService service, string prefix, string url, bool overwrite, params string[] ns)
{
if (string.IsNullOrEmpty(prefix))
{
return(service);
}
if (string.IsNullOrEmpty(url))
{
return(service);
}
if (ns is null || ns.Length == 0)
{
return(service);
}
if (ns.Any(string.IsNullOrEmpty))
{
return(service);
}
var existingUrl = service.XmlnsDeclarations.FirstOrDefault(o => o.Value.IsUrlDefinition && o.Value.Url == url).Value;
var prefixExists = service.XmlnsDeclarations.ContainsKey(prefix);
var newDeclaration = new XmlnsDeclaration(prefix, url, true);
newDeclaration.RegisterNamespace(ns);
// url and prefix exists and overwrite false -> only add namespaces
if (existingUrl != null && prefixExists && existingUrl.Prefix == prefix && !overwrite)
{
existingUrl.RegisterNamespace(ns);
return(service);
}
if (existingUrl != null && prefixExists && existingUrl.Prefix != prefix)
{
return(service);
}
// only url exists and overwrite is false
if (existingUrl != null && !overwrite)
{
return(service);
}
// only url exists and overwrite is true
if (existingUrl != null)
{
service.XmlnsDeclarations.Remove(existingUrl.Prefix);
service.XmlnsDeclarations.Add(newDeclaration.Prefix, newDeclaration);
return(service);
}
// only prefix exists and overwrite is false
if (prefixExists && !overwrite)
{
return(service);
}
// only prefix exists and overwrite is true
if (prefixExists)
{
service.XmlnsDeclarations[prefix] = newDeclaration;
return(service);
}
// nothing exists
service.XmlnsDeclarations.Add(newDeclaration.Prefix, newDeclaration);
return(service);
}
public static XamlService RegisterObjectConverter <T, TParent, TOut>(this XamlService service, Func <T, TParent, TOut> convert, Func <T, TParent, bool> shouldConvert, RegisterPriority priority)
{
return(service);
}
public static XamlService RegisterContentProperty <T>(this XamlService service, RegisterPriority priority) => service.RegisterContentProperty(typeof(T), priority);