// Copyright Keysight Technologies 2012-2019
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
|
using System.Collections.Generic;
|
using System.Linq;
|
|
namespace OpenTap
|
{
|
internal abstract class LicenseBase
|
{
|
internal abstract bool Matches(HashSet<string> licenses);
|
internal abstract IEnumerable<LicenseBase> FindMatch(HashSet<string> licenses);
|
|
internal static string FormatFriendly(string licenseString, bool humanReadable = true)
|
{
|
return PrintLicense(Prune(LicenseParser.ParseString(licenseString)), humanReadable);
|
}
|
|
private static LicenseBase Prune(LicenseBase real)
|
{
|
if (real is LicenseAll)
|
{
|
var all = (real as LicenseAll).Licenses.Select(Prune).ToArray();
|
|
if (all.Any(l => l == null))
|
return null;
|
|
all = all.Where(l => !(l is LicenseProcess)).ToArray();
|
|
if (all.Length == 1)
|
return all.First();
|
else if (all.Length == 0)
|
return null;
|
else
|
return new LicenseAll(all);
|
}
|
else if (real is LicenseAny)
|
{
|
var all = (real as LicenseAny).Licenses.Select(Prune).Where(x => x != null).ToArray();
|
|
if (all.OfType<LicenseProcess>().Any())
|
return all.OfType<LicenseProcess>().First();
|
|
if (all.Length == 1)
|
return all.First();
|
else if (all.Length == 0)
|
return null;
|
else
|
return new LicenseAny(all);
|
}
|
else if (real is LicenseProcess)
|
{
|
if ((real as LicenseProcess).ProcessName.ToLowerInvariant().Contains("keysight.opentap"))
|
return real;
|
else
|
return null;
|
}
|
|
return real;
|
}
|
|
private static string PrintLicense(LicenseBase license, bool humanReadable)
|
{
|
if (license is LicenseAll)
|
{
|
List<string> outputs = (license as LicenseAll).Licenses.Select(l =>
|
{
|
string output = PrintLicense(l, humanReadable);
|
if (l is LicenseAny && !string.IsNullOrEmpty(output))
|
output = "(" + output + ")";
|
return output;
|
}
|
).ToList();
|
|
// If two licenses are required (&) and one of them is "secret" (not printed), then the other one should not be printed either.
|
// For example: KS8000A&{BenchVue} should yield no output, as {BenchVue} is hidden and KS8000A will not work on its own.
|
if (outputs.Any(s => string.IsNullOrEmpty(s)))
|
return "";
|
else
|
return string.Join(humanReadable ? " and " : "&", outputs);
|
}
|
else if (license is LicenseAny)
|
{
|
return string.Join(humanReadable ? " or " : "|", (license as LicenseAny).Licenses.Select(l =>
|
{
|
string output = PrintLicense(l, humanReadable);
|
if (l is LicenseAll && !string.IsNullOrEmpty(output))
|
output = "(" + output + ")";
|
return output;
|
}
|
).Where(x => x != ""));
|
}
|
else if (license is LicenseRequired)
|
{
|
string featureSeed = (license as LicenseRequired).FeatureSeed;
|
|
if (humanReadable && featureSeed.Contains("-INT")) // hide -INT licenses only when printing to the user, when printing to an xml file we need to keep the int license
|
return "";
|
else
|
return featureSeed;
|
}
|
|
return "";
|
}
|
}
|
|
internal class LicenseRequired : LicenseBase
|
{
|
internal readonly string FeatureSeed;
|
|
internal override bool Matches(HashSet<string> licenses)
|
{
|
return licenses.Contains(FeatureSeed);
|
}
|
|
internal override IEnumerable<LicenseBase> FindMatch(HashSet<string> licenses)
|
{
|
if (Matches(licenses))
|
yield return this;
|
}
|
|
public LicenseRequired(string text)
|
{
|
FeatureSeed = text;
|
}
|
}
|
|
internal class LicenseProcess : LicenseBase
|
{
|
internal readonly string ProcessName;
|
|
internal override bool Matches(HashSet<string> licenses)
|
{
|
return ProcessName.ToLowerInvariant().Contains("keysight.opentap");
|
}
|
|
internal override IEnumerable<LicenseBase> FindMatch(HashSet<string> licenses)
|
{
|
if (Matches(licenses))
|
yield return this;
|
}
|
|
public LicenseProcess(string processName)
|
{
|
ProcessName = processName;
|
}
|
}
|
|
internal class LicenseAny : LicenseBase
|
{
|
internal readonly LicenseBase[] Licenses;
|
|
internal override bool Matches(HashSet<string> licenses)
|
{
|
return Licenses.Any(l => l.Matches(licenses));
|
}
|
|
internal override IEnumerable<LicenseBase> FindMatch(HashSet<string> licenses)
|
{
|
var l = Licenses.FirstOrDefault(lic => lic.Matches(licenses));
|
|
if (l != null)
|
return l.FindMatch(licenses);
|
else
|
return Enumerable.Empty<LicenseBase>();
|
}
|
|
public LicenseAny(LicenseBase[] licenseBase)
|
{
|
Licenses = licenseBase;
|
}
|
}
|
|
internal class LicenseAll : LicenseBase
|
{
|
internal readonly LicenseBase[] Licenses;
|
|
internal override bool Matches(HashSet<string> licenses)
|
{
|
return Licenses.All(l => l.Matches(licenses));
|
}
|
|
internal override IEnumerable<LicenseBase> FindMatch(HashSet<string> licenses)
|
{
|
if (Matches(licenses))
|
return Licenses.SelectMany(l => l.FindMatch(licenses));
|
else
|
return Enumerable.Empty<LicenseBase>();
|
}
|
|
public LicenseAll(LicenseBase[] licenseBase)
|
{
|
Licenses = licenseBase;
|
}
|
}
|
}
|
