/// <summary>
/// A leaf node in an expression can only be a License or an Exception. Run a func on each one.
/// </summary>
/// <param name="expression">The expression to be walked.</param>
/// <param name="licenseProcessor">A processor for the licenses.</param>
/// <param name="exceptionProcessor">A processor for the exceptions.</param>
public static void OnEachLeafNode(this NuGetLicenseExpression expression, Action <NuGetLicense> licenseProcessor, Action <NuGetLicenseException> exceptionProcessor)
{
switch (expression.Type)
{
case LicenseExpressionType.License:
var license = (NuGetLicense)expression;
licenseProcessor?.Invoke(license);
break;
case LicenseExpressionType.Operator:
var licenseOperator = (LicenseOperator)expression;
switch (licenseOperator.OperatorType)
{
case LicenseOperatorType.LogicalOperator:
var logicalOperator = (LogicalOperator)licenseOperator;
logicalOperator.Left.OnEachLeafNode(licenseProcessor, exceptionProcessor);
logicalOperator.Right.OnEachLeafNode(licenseProcessor, exceptionProcessor);
break;
case LicenseOperatorType.WithOperator:
var withOperator = (WithOperator)licenseOperator;
licenseProcessor?.Invoke(withOperator.License);
exceptionProcessor?.Invoke(withOperator.Exception);
break;
default:
break;
}
break;
default:
break;
}
}
/// <summary>
/// Determines whether all the licenses and exceptions are not deprecated.
/// </summary>
/// <param name="expression">expression to be validated</param>
/// <returns>Whether this expression consists of licenses with standard identifiers</returns>
public static bool HasOnlyStandardIdentifiers(this NuGetLicenseExpression expression)
{
switch (expression.Type)
{
case LicenseExpressionType.License:
return((expression as NuGetLicense).IsStandardLicense);
case LicenseExpressionType.Operator:
var licenseOperator = expression as LicenseOperator;
switch (licenseOperator.OperatorType)
{
case LicenseOperatorType.LogicalOperator:
var logicalOperator = (LogicalOperator)licenseOperator;
return(logicalOperator.Left.HasOnlyStandardIdentifiers() && logicalOperator.Right.HasOnlyStandardIdentifiers());
case LicenseOperatorType.WithOperator:
var withOperator = (WithOperator)licenseOperator;
return(withOperator.License.IsStandardLicense);
default:
return(false);
}
default:
return(false);
}
}
public LogicalOperator(LogicalOperatorType logicalOperatorType, NuGetLicenseExpression left, NuGetLicenseExpression right) :
base(LicenseOperatorType.LogicalOperator)
{
LogicalOperatorType = logicalOperatorType;
Left = left ?? throw new ArgumentNullException(nameof(left));
Right = right ?? throw new ArgumentNullException(nameof(right));
}
public static bool IsUnlicensed(this NuGetLicenseExpression expression)
{
switch (expression.Type)
{
case LicenseExpressionType.License:
return(((NuGetLicense)expression).IsUnlicensed());
case LicenseExpressionType.Operator: // expressions with operators cannot be unlicensed.
default:
return(false);
}
}
