internal VersionCompositeComparator(IEnumerable <IVersionComparator> comparators, VersionCompositor compositor, string originalString) { if (comparators != null) { foreach (var comparator in comparators) { InternalAdd(comparator); } } _compositor = compositor; _originalString = originalString; }
public VersionCompositeComparator(IEnumerable <IVersionComparator> comparators, VersionCompositor compositor = VersionCompositor.And) : this(comparators, compositor, null) { }
public VersionCompositeComparator(VersionCompositeComparator comparator) { _comparators.AddRange(comparator); _compositor = comparator._compositor; _originalString = comparator._originalString; }
public VersionCompositeComparator(IEnumerable <Version> versions, VersionCompositor compositor = VersionCompositor.And) : this(versions?.Select(version => version == null ? null : new VersionComparator(version)), compositor) { }
private static bool TryParseCompositeExpression(string value, string operatorString, VersionCompositor compositor, out IVersionComparator comparator) { comparator = null; if (value.IndexOf(operatorString, StringComparison.Ordinal) == -1) { return(false); } Func <bool, IVersionComparator> parse = ignoreParanthesis => { string[] expressions; if (!SplitByOperator(value, operatorString, ignoreParanthesis, out expressions)) { return(null); } if (expressions.Length <= 1) { return(null); } var comparators = new List <IVersionComparator>(); bool result = true; foreach (var expression in expressions) { IVersionComparator childComparator; if (!TryParseExpression(expression, out childComparator)) { result = false; break; } comparators.Add(childComparator); } return(result ? new VersionCompositeComparator(comparators, compositor) : null); }; comparator = parse(false) ?? parse(true); if (comparator != null) { return(true); } if (value[0] == '(') { if (value[value.Length - 1] != ')') { return(false); } return(TryParseCompositeExpression(value.Substring(1, value.Length - 2).Trim(), operatorString, compositor, out comparator)); } return(false); }