private static int FindCommonFragmentLength(Qualifier q1, Qualifier q2, StringComparison comparison = StringComparison.Ordinal) { if (null == q1 || null == q2) { return(int.MinValue); } if (!q1.IsCompliantTo(q2)) { return(int.MinValue); } if (q1.GuidOrNameCase != Qualifier.GuidOrNameOneofCase.Named) { return(int.MinValue); } int count = Math.Min(q1.Named.Frags.Count, q2.Named.Frags.Count); int index; for (index = 0; index < count; index++) { if (0 != string.Compare(q1.Named.Frags[index], q2.Named.Frags[index], comparison)) { return(index); } } return(index); }
public static Classifier ToClassifier(this Qualifier name) { var c = new Classifier(); c.Path.Add(name); return(c); }
/// <summary> /// If both qualifiers have the same type. /// </summary> /// <param name="qualifier">A qualifier</param> /// <param name="other">Other qualifier</param> /// <returns>True, if both have the same type</returns> public static bool IsCompliantTo(this Qualifier qualifier, Qualifier other) { if (null == qualifier || null == other) { return(false); } return(qualifier.GuidOrNameCase == other.GuidOrNameCase); }
/// <summary> /// Fetches the subset classifier if there's any. /// </summary> /// <param name="classifier">The classifier</param> /// <param name="qualifier">The qualifier</param> /// <returns>A new subset classifier trace or a classifier with <see cref="IsNothing(Classifier)"/> returning true.</returns> public static Classifier ToSubClassifierOf(this Classifier classifier, Qualifier qualifier) { var subClassifier = new Classifier(); for (int i = classifier.Path.IndexOf(qualifier); i > 0 && i < classifier.Path.Count; i++) { subClassifier.Path.Add(classifier.Path[i]); } return(subClassifier); }
/// <summary> /// True, if the given qualifier is a super qualifier of at least on path fragment. /// </summary> /// <param name="classifier">The classifier which is a sub set of the qualifier</param> /// <param name="superQualifier">The qualifier</param> /// <param name="comparison">The string comparision method</param> /// <returns>True, if the given qualifier is (paritally) a super qualifier of the classifier</returns> public static bool IsSubMatching(this Classifier classifier, Qualifier superQualifier, StringComparison comparison = StringComparison.Ordinal) { switch (superQualifier.GuidOrNameCase) { case Qualifier.GuidOrNameOneofCase.Anonymous: // Same as matching if using GUIDs return(classifier.IsExactMatching(superQualifier)); default: return(classifier.Path.Any(q => superQualifier.IsSuperQualifierOf(q, comparison))); } }
public static Qualifier ToCommonRoot(this Qualifier qualifier, Qualifier other, StringComparison comparison = StringComparison.Ordinal) { var fragmentLength = FindCommonFragmentLength(qualifier, other, comparison); switch (fragmentLength) { case int.MinValue: return(new Qualifier()); default: return(qualifier.ToTrimmedNamed(0, fragmentLength)); } }
public static bool IsSuperQualifierOf(this Qualifier supQualifier, Qualifier subQualifier, StringComparison comparison = StringComparison.Ordinal) { var fragmentLength = FindCommonFragmentLength(supQualifier, subQualifier, comparison); switch (fragmentLength) { case int.MinValue: return(false); default: // Only if super qualifier is completely covered by sub qualifier return(fragmentLength == supQualifier.Named.Frags.Count); } }
public static Qualifier Append(this Qualifier aQualifier, Qualifier bQualifier) { if (aQualifier.IsCompliantTo(bQualifier)) { switch (aQualifier.GuidOrNameCase) { case Qualifier.GuidOrNameOneofCase.Named: return(aQualifier.Named.Frags.Concat(bQualifier.Named.Frags).ToArray().ToQualifier()); default: throw new NotSupportedException($"Not support for '{Qualifier.GuidOrNameOneofCase.Anonymous}'"); } } throw new NotSupportedException("Incompliant qualifier types"); }
/// <summary> /// Extracts a sub qualifier relative to given super qualifier given the current qualifier. /// </summary> /// <param name="qualifier">The given qualifier</param> /// <param name="supQualifier">The super qualifier</param> /// <param name="comparison">Comparision method</param> /// <returns>A sub qualifier relative to super qualifier</returns> public static Qualifier ToSubQualifierOf(this Qualifier qualifier, Qualifier supQualifier, StringComparison comparison = StringComparison.Ordinal) { var fragmentLength = FindCommonFragmentLength(supQualifier, qualifier, comparison); switch (fragmentLength) { case int.MaxValue: return(new Qualifier()); default: if (fragmentLength == supQualifier.Named.Frags.Count) { // Only if super qualifier is completely covered by sub qualifier return(qualifier.ToTrimmedNamed(supQualifier.Named.Frags.Count)); } else { return(new Qualifier()); } } }
public static bool IsEmpty(this Qualifier qualifier) { if (null == qualifier) { return(true); } switch (qualifier.GuidOrNameCase) { case Qualifier.GuidOrNameOneofCase.Anonymous: return(false); case Qualifier.GuidOrNameOneofCase.Named: return(qualifier.Named.Frags.Count == 0); case Qualifier.GuidOrNameOneofCase.None: return(true); default: throw new NotSupportedException($"State of '{qualifier}' not supported."); } }
public static string ToLabel(this Qualifier c, string separator = ".", int fromStart = 0, int fromEnd = 0) { switch (c.GuidOrNameCase) { case Qualifier.GuidOrNameOneofCase.Anonymous: switch (c.Anonymous.NumericalOrStringCase) { case GlobalUniqueId.NumericalOrStringOneofCase.Guid: return(new System.Guid(c.Anonymous.Guid.Raw.ToByteArray()).ToString()); case GlobalUniqueId.NumericalOrStringOneofCase.Base64: return(c.Anonymous.ToBase64String()); } return(null); case Qualifier.GuidOrNameOneofCase.Named: return(c.Named.ToLabel(separator, fromStart, fromEnd)); default: return(null); } }
public static Qualifier ToTrimmedNamed(this Qualifier qualifier, int startFrag, int countFrags = int.MaxValue) { if (null == qualifier) { return(null); } startFrag = Math.Max(0, startFrag); switch (qualifier.GuidOrNameCase) { case Qualifier.GuidOrNameOneofCase.Named: if (startFrag > qualifier.Named.Frags.Count) { return(new Qualifier()); } var newFrags = new string[Math.Min(qualifier.Named.Frags.Count - startFrag, countFrags)]; Array.Copy(qualifier.Named.Frags.ToArray(), startFrag, newFrags, 0, newFrags.Length); return(newFrags.ToQualifier()); default: throw new NotSupportedException($"Cannot trim '{qualifier}' of type '{qualifier.GuidOrNameCase}'"); } }
public static Classifier Enqueue(this Classifier classifier, Qualifier tail) { classifier?.Path.Add(tail); return(classifier); }
/// <summary> /// Filters the classifier for sub matches of given super qualifier. /// </summary> /// <param name="classifier"></param> /// <param name="superQualifier"></param> /// <param name="comparison"></param> /// <returns>An enumerable of the qualifiers</returns> public static IEnumerable <Qualifier> FilterSubMatching(this Classifier classifier, Qualifier superQualifier, StringComparison comparison = StringComparison.Ordinal) { switch (superQualifier.GuidOrNameCase) { case Qualifier.GuidOrNameOneofCase.Anonymous: // Same as matching if using GUIDs return(classifier.IsExactMatching(superQualifier) ? new Qualifier[] { superQualifier } : Enumerable.Empty <Qualifier>()); default: return(classifier.Path.Where(q => superQualifier.IsSuperQualifierOf(q, comparison))); } }
/// <summary> /// True, if the given qualifier is held by this classifier. /// </summary> /// <param name="classifier">The classifier</param> /// <param name="qualifier">The qualifier</param> /// <returns>True, if the qualifier is held by this classifier</returns> public static bool IsExactMatching(this Classifier classifier, Qualifier qualifier) { return(classifier.Path.Any(q => q.Equals(qualifier))); }
/// <summary> /// Extracts a filtered enumeration sub qualifiers which hava a common root with given qualifier. /// </summary> /// <param name="classifier">The classifier</param> /// <param name="qualifier">The qualifier</param> /// <param name="comparison">The string comparision method</param> /// <returns></returns> public static IEnumerable <Qualifier> ToSubQualifiers(this Classifier classifier, Qualifier qualifier, StringComparison comparison = StringComparison.Ordinal) { switch (qualifier.GuidOrNameCase) { case Qualifier.GuidOrNameOneofCase.Anonymous: return(classifier.Path.Where(q => q.Equals(qualifier))); default: return(classifier.Path.Select(q => q.ToSubQualifierOf(qualifier, comparison)).Where(q => !q.IsEmpty())); } }