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);
}
