public string GetCurrentVersionComponentValue(VersionComponent component)
{
string result;
switch (component)
{
case VersionComponent.Major:
result = this.CurrentVersion.Major;
break;
case VersionComponent.Minor:
result = this.CurrentVersion.Minor;
break;
case VersionComponent.Build:
result = this.CurrentVersion.Build;
break;
case VersionComponent.Revision:
result = this.CurrentVersion.Revision;
break;
default:
result = "0";
break;
}
return(result);
}
public override void Increment(IncrementContext context, VersionComponent versionComponent)
{
string currentVersionComponentValue = context.GetCurrentVersionComponentValue(versionComponent);
string value = this.Increment(currentVersionComponentValue, context.BuildStartDate, context.ProjectStartDate, context.ProjectFilename);
context.SetNewVersionComponentValue(versionComponent, value);
}
/// <summary>
/// Increments the specified version.
/// </summary>
/// <param name="currentVersion">The current version.</param>
/// <param name="buildStartDate">The build start date.</param>
/// <param name="projectStartDate">The project start date.</param>
/// <returns>The incremented version.</returns>
internal StringVersion Increment(StringVersion currentVersion, DateTime buildStartDate, DateTime projectStartDate, SolutionItem solutionItem)
{
IncrementContext context = new IncrementContext(currentVersion, buildStartDate, projectStartDate, solutionItem.Filename);
BaseIncrementor[] incrementors = new BaseIncrementor[] { Major, Minor, Build, Revision };
for (int i = 0; i < 4; i++)
{
BaseIncrementor incrementor = incrementors[i];
if (incrementor == null)
{
continue;
}
VersionComponent component = (VersionComponent)i;
incrementor.Increment(context, component);
if (!context.Continue)
{
break;
}
}
return(context.NewVersion);
/*int major = Major == null ? currentVersion.Major : Major.Increment(currentVersion.Major, buildStartDate, projectStartDate, solutionItem.Filename);
* int minor = Minor == null ? currentVersion.Minor : Minor.Increment(currentVersion.Minor, buildStartDate, projectStartDate, solutionItem.Filename);
* int build = Build == null ? currentVersion.Build : Build.Increment(currentVersion.Build, buildStartDate, projectStartDate, solutionItem.Filename);
* int revision = Revision == null ? currentVersion.Revision : Revision.Increment(currentVersion.Revision, buildStartDate, projectStartDate, solutionItem.Filename);
*
* return new Version(major, minor, build, revision);*/
}
public override void Execute(IncrementContext context, VersionComponent versionComponent)
{
var currentValue = context.GetCurrentVersionComponentValue(versionComponent);
var newValue = IncrementImpl(currentValue, context.BuildStartDate, context.ProjectStartDate);
context.SetNewVersionComponentValue(versionComponent, newValue);
}
internal StringVersion Increment(StringVersion currentVersion, DateTime buildStartDate, DateTime projectStartDate, SolutionItem solutionItem)
{
IncrementContext incrementContext = new IncrementContext(currentVersion, buildStartDate, projectStartDate, solutionItem.Filename);
BaseIncrementor[] array = new BaseIncrementor[]
{
this.Major,
this.Minor,
this.Build,
this.Revision
};
for (int i = 0; i < 4; i++)
{
BaseIncrementor baseIncrementor = array[i];
if (baseIncrementor != null)
{
VersionComponent versionComponent = (VersionComponent)i;
baseIncrementor.Increment(incrementContext, versionComponent);
if (!incrementContext.Continue)
{
break;
}
}
}
return(incrementContext.NewVersion);
}
public IActionResult GetVersions()
{
IActionResult result;
Versions response = new Versions();
response.BuildNumber = VersionsHelper.GetCurrentAssemblyVersions(true)?.Item2; // Use full version with pre-release suffix
#if DEBUG
foreach (Tuple <string, string> nameVersionPair in VersionsHelper.GetAssemblyVersions(null, true))
#else
foreach (Tuple <string, string> nameVersionPair in VersionsHelper.GetAssemblyVersions())
#endif
{
VersionComponent component = new VersionComponent();
component.Name = nameVersionPair.Item1;
component.Version = nameVersionPair.Item2;
if (response.Components == null)
{
response.Components = new List <VersionComponent>();
}
response.Components.Add(component);
}
result = Request.GetObjectResult(response);
return(result);
}
public static Version Bump(this Version version, VersionComponent component)
{
if (component == VersionComponent.Major)
{
return(new Version(version.Major + 1, 0, 0, version.PreRelease, version.Build));
}
if (component == VersionComponent.Minor)
{
return(new Version(version.Major, version.Minor + 1, 0, version.PreRelease, version.Build));
}
if (component == VersionComponent.Patch)
{
return(new Version(version.Major, version.Minor, version.Patch + 1, version.PreRelease, version.Build));
}
if (component == VersionComponent.Pre)
{
var pre = version.PreRelease;
pre = BumpPre(pre);
return(new Version(version.Major, version.Minor, version.Patch, pre, version.Build));
}
else
{
return(null);
}
}
/// <summary>
/// Executes the increment.
/// </summary>
/// <param name="context">The context of the increment.</param>
/// <param name="versionComponent">The version component that needs to be incremented.</param>
/// <remarks>
/// Use the method <see cref="IncrementContext.SetNewVersionComponentValue"/> to set the new version component value.
/// Set the <see cref="IncrementContext.Continue"/> property to <c>false</c> to skip updating the other component values.
/// </remarks>
public override void Increment(IncrementContext context, VersionComponent versionComponent)
{
// Find out the directory
String projectPath = context.ProjectFilename;
String projectPathDirectory = Directory.GetParent(projectPath).FullName;
//Logger.Write("PATH: " + projectPath, LogLevel.Debug);
//Logger.Write("PATH: " + projectPathDirectory, LogLevel.Debug);
if (!String.IsNullOrEmpty(projectPath) && !String.IsNullOrEmpty(projectPathDirectory))
{
try
{
long svnRevision = GetRevision(projectPathDirectory);
Logger.Write("Revision retrieved from the working copy: " + svnRevision, LogLevel.Info);
// Return the head revision or "0" if not under version control
context.SetNewVersionComponentValue(versionComponent, svnRevision.ToString());
}
catch (Exception ex)
{
Logger.Write("Error while retrieving revision: " + ex.ToString(), LogLevel.Error);
}
}
}
/// <summary>
/// Executes the increment.
/// </summary>
/// <param name="context">The context of the increment.</param>
/// <param name="versionComponent">The version component that needs to be incremented.</param>
/// <remarks>
/// Use the method <see cref="IncrementContext.SetNewVersionComponentValue"/> to set the new version component value.
/// Set the <see cref="IncrementContext.Continue"/> property to <c>false</c> to skip updating the other component values.
/// </remarks>
public override void Increment(IncrementContext context, VersionComponent versionComponent)
{
Logger.Write("Setting a random version number.", LogLevel.Debug);
// Set the requested version component of the IncrementContext to a random number
context.SetNewVersionComponentValue(versionComponent, _rnd.Next((int)short.MaxValue).ToString());
}
/// <summary>
/// Executes the increment.
/// </summary>
/// <param name="context">The context of the increment.</param>
/// <param name="versionComponent">The version component that needs to be incremented.</param>
/// <remarks>
/// Use the method <see cref="IncrementContext.SetNewVersionComponentValue"/> to set the new version component value.
/// Set the <see cref="IncrementContext.Continue"/> property to <c>false</c> to skip updating the other component values.
/// </remarks>
public override void Increment(IncrementContext context, VersionComponent versionComponent)
{
Logger.Write("Ah! I always thought something was fundamentally wrong with the universe.", LogLevel.Info);
// Set the requested version component of the IncrementContext to the number 42
context.SetNewVersionComponentValue(versionComponent, "42");
}
/// <summary>
/// Executes the increment.
/// </summary>
/// <param name="context">The context of the increment.</param>
/// <param name="versionComponent">The version component that needs to be incremented.</param>
/// <remarks>
/// Use the method <see cref="IncrementContext.SetNewVersionComponentValue"/> to set the new version component value.
/// Set the <see cref="IncrementContext.Continue"/> property to <c>false</c> to skip updating the other component values.
/// </remarks>
public override void Increment(IncrementContext context, VersionComponent versionComponent)
{
Logger.Write("Resetting version number to 1.0.0.0", LogLevel.Debug);
// Set all the version components
context.SetNewVersionComponentValue(versionComponent,
versionComponent == VersionComponent.Major ? "1" : "0");
// Tell the addin to stop incrementing the other version components
// context.Continue = false;
}
public void BumpVersion(VersionComponent component)
{
var node = document.GetVersionNode();
var value = node.Value;
if (value is string)
{
Version version = new Version(value, loose: true);
var bumped = version.Bump(component);
node.SetValue(bumped.ToString());
}
else
{
node.SetValue("0.0.1");
}
}
public string GetCurrentVersionComponentValue(VersionComponent component)
{
switch (component)
{
case VersionComponent.Build:
return(CurrentVersion.Build);
case VersionComponent.Major:
return(CurrentVersion.Major);
case VersionComponent.Minor:
return(CurrentVersion.Minor);
case VersionComponent.Revision:
return(CurrentVersion.Revision);
}
return("0");
}
private static int GetNextComponentValue(Version v, VersionComponent component)
{
switch (component)
{
case VersionComponent.None:
return(v.Major);
case VersionComponent.Major:
return(v.Minor);
case VersionComponent.Minor:
return(v.Build);
case VersionComponent.Build:
return(v.Revision);
default:
return(0);
}
}
public void SetNewVersionComponentValue(VersionComponent component, string value)
{
switch (component)
{
case VersionComponent.Major:
this.NewVersion = new StringVersion(value, this.NewVersion.Minor, this.NewVersion.Build, this.NewVersion.Revision);
break;
case VersionComponent.Minor:
this.NewVersion = new StringVersion(this.NewVersion.Major, value, this.NewVersion.Build, this.NewVersion.Revision);
break;
case VersionComponent.Build:
this.NewVersion = new StringVersion(this.NewVersion.Major, this.NewVersion.Minor, value, this.NewVersion.Revision);
break;
case VersionComponent.Revision:
this.NewVersion = new StringVersion(this.NewVersion.Major, this.NewVersion.Minor, this.NewVersion.Build, value);
break;
}
}
public string GetCurrentVersionComponentValue(VersionComponent component)
{
string result;
switch (component)
{
case VersionComponent.Major:
result = this.CurrentVersion.Major;
break;
case VersionComponent.Minor:
result = this.CurrentVersion.Minor;
break;
case VersionComponent.Build:
result = this.CurrentVersion.Build;
break;
case VersionComponent.Revision:
result = this.CurrentVersion.Revision;
break;
default:
result = "0";
break;
}
return result;
}
public void Increment(VersionComponent component)
{
switch (component)
{
case VersionComponent.Major:
IncrementMajor();
break;
case VersionComponent.Minor:
IncrementMinor();
break;
case VersionComponent.Build:
if ((this.Build + 1) > MaxBuild)
{
IncrementMinor();
}
else
{
this.Build++;
}
break;
}
}
public void SetNewVersionComponentValue(VersionComponent component, string value)
{
switch (component)
{
case VersionComponent.Build:
NewVersion = new StringVersion(NewVersion.Major, NewVersion.Minor, value, NewVersion.Revision);
break;
case VersionComponent.Major:
NewVersion = new StringVersion(value, NewVersion.Minor, NewVersion.Build, NewVersion.Revision);
break;
case VersionComponent.Minor:
NewVersion = new StringVersion(NewVersion.Major, value, NewVersion.Build, NewVersion.Revision);
break;
case VersionComponent.Revision:
NewVersion = new StringVersion(NewVersion.Major, NewVersion.Minor, NewVersion.Build, value);
break;
default:
throw new ArgumentOutOfRangeException(nameof(component), component, null);
}
}
protected static float GetFirmwareVersion(IntPtr evt, VersionComponent component)
{
return(PlatformInvocation.Running32Bit
? event_get_firmware_version_32(evt, component)
: event_get_firmware_version_64(evt, component));
}
public abstract void Increment(IncrementContext context, VersionComponent versionComponent);
private static ulong GetWindowsVersionComponent(ulong version, VersionComponent versionComponentType)
{
var shift = (int)versionComponentType;
return((version & (0xFFFFUL << shift)) >> shift);
}
public abstract void Increment(IncrementContext context, VersionComponent versionComponent);
public XsltContextAssetVersionGetter(VersionComponent? ignoredVersionComponent = null)
{
this._ignoredVersionComponent = ignoredVersionComponent;
}
public void SetNewVersionComponentValue(VersionComponent component, string value)
{
switch (component)
{
case VersionComponent.Major:
this.NewVersion = new StringVersion(value, this.NewVersion.Minor, this.NewVersion.Build, this.NewVersion.Revision);
break;
case VersionComponent.Minor:
this.NewVersion = new StringVersion(this.NewVersion.Major, value, this.NewVersion.Build, this.NewVersion.Revision);
break;
case VersionComponent.Build:
this.NewVersion = new StringVersion(this.NewVersion.Major, this.NewVersion.Minor, value, this.NewVersion.Revision);
break;
case VersionComponent.Revision:
this.NewVersion = new StringVersion(this.NewVersion.Major, this.NewVersion.Minor, this.NewVersion.Build, value);
break;
}
}
public Bundle(VersionComponent? ignoreVersionComponent)
{
this._bundle = new XDocument(new XElement("bundle"));
this._ignoreVersionComponent = ignoreVersionComponent;
}
public float GetFirmwareVersion(IntPtr evt, VersionComponent component)
{
Contract.Requires <ArgumentException>(evt != IntPtr.Zero, "The event handle must be set.");
return(default(float));
}
internal static bool FilterPackage(SemanticVersion specVer1, SemanticVersion packageVer2, VersionComponent filterComponent)
{
bool filterPackage = false;
if (!string.IsNullOrEmpty(specVer1.SpecialVersion) && specVer1.SpecialVersion != packageVer2.SpecialVersion)
{
filterPackage |= true;
}
Version specV = specVer1.Version;
Version packageV = packageVer2.Version;
switch (filterComponent)
{
case Utils.VersionComponent.Major:
if (specV.Major != packageV.Major)
{
filterPackage |= true;
}
break;
case Utils.VersionComponent.Minor:
if (specV.Major != packageV.Major || specV.Minor != packageV.Minor)
{
filterPackage |= true;
}
break;
case Utils.VersionComponent.Build:
if (specV.Major != packageV.Major || specV.Minor != packageV.Minor || specV.Build != specV.Build)
{
filterPackage |= true;
}
break;
}
return(filterPackage);
}
/// <inheritdoc />
public uint EventGetFirmwareVersion64(IntPtr evt, VersionComponent component)
{
return(event_get_firmware_version_64(evt, component));
}
private static extern uint event_get_firmware_version_64(IntPtr evt, VersionComponent component);
public uint EventGetFirmwareVersion64(IntPtr evt, VersionComponent component)
{
// Contract.Requires<ArgumentException>(evt != IntPtr.Zero, "The pointer to the event must be set.");
return(default(uint));
}
private static CustomXsltContext CreateCustomXsltContext(VersionComponent? ignoredVersionComponent)
{
CustomXsltContext xpathContext = new CustomXsltContext();
xpathContext.RegisterFunction(string.Empty, "get-id", new XsltContextAssetIdGetter());
xpathContext.RegisterFunction(string.Empty, "get-version", new XsltContextAssetVersionGetter());
xpathContext.RegisterFunction(string.Empty, "substring-before-last", new XsltContextSubstringBeforeLastFunction());
xpathContext.RegisterFunction(string.Empty, "substring-after-last", new XsltContextSubstringAfterLastFunction());
xpathContext.RegisterFunction(string.Empty, "iif", new XsltContextTernaryOperator());
xpathContext.RegisterFunction(string.Empty, "get-significant-version", new XsltContextAssetVersionGetter(ignoredVersionComponent));
xpathContext.RegisterFunction(string.Empty, "coalesce", new XsltContextCoalesceFunction());
xpathContext.RegisterFunction(string.Empty, "join", new XsltContextJoinFunction());
return xpathContext;
}
/// <inheritdoc />
public float GetFirmwareVersion(IntPtr evt, VersionComponent component)
{
return PlatformInvocation.Running32Bit
? _myoDeviceBridge.EventGetFirmwareVersion32(evt, component)
: _myoDeviceBridge.EventGetFirmwareVersion64(evt, component);
}
private static CustomXsltContext CreateCustomXsltContext(VersionComponent? ignoredVersionComponent)
{
CustomXsltContext xpathContext = new CustomXsltContext();
xpathContext.RegisterFunction(string.Empty, "get-id", new XsltContextAssetIdGetter());
xpathContext.RegisterFunction(string.Empty, "get-version", new XsltContextAssetVersionGetter());
xpathContext.RegisterFunction(string.Empty, "get-significant-version", new XsltContextAssetVersionGetter(ignoredVersionComponent));
xpathContext.RegisterFunction(string.Empty, "coalesce", new XsltContextCoalesceFunction());
xpathContext.RegisterFunction(string.Empty, "join", new XsltContextJoinFunction());
return xpathContext;
}
internal static void GetPackageSpecComponents(string packageSpec, out string packageId, out VersionOp versionOp, out SemanticVersion semVer, out VersionComponent filterComponent)
{
string packageVersion;
var specComponents = packageSpec.Split(' ');
if (specComponents.Length == 1)
{
packageId = specComponents[0];
versionOp = VersionOp.GreaterEqual;
packageVersion = "0";
}
else if (specComponents.Length == 3)
{
packageId = specComponents[0];
versionOp = OpsMapping[specComponents[1]];
packageVersion = specComponents[2];
}
else
{
throw new InvalidDataException(string.Format("Invlaid package spec {0}, needs to be \"packageName compOperator x[.y.z.w-tag]", packageSpec));
}
int idx = 0;
int filterThreshold = 0;
while (idx < packageVersion.Length && packageVersion[idx] != '-')
{
if (packageVersion[idx++] == '.')
{
filterThreshold++;
}
}
if (filterThreshold == 0)
{
packageVersion = packageVersion.Insert(idx, ".0");
}
semVer = ParseVersion(packageVersion);
filterComponent = (VersionComponent)Math.Min(filterThreshold, (int)VersionComponent.Build);
}
/// <inheritdoc />
public float GetFirmwareVersion(IntPtr evt, VersionComponent component)
{
return(PlatformInvocation.Running32Bit
? _myoDeviceBridge.EventGetFirmwareVersion32(evt, component)
: _myoDeviceBridge.EventGetFirmwareVersion64(evt, component));
}
internal static bool ValidPackage(SemanticVersion specVer1, SemanticVersion packageVer2, VersionComponent filterComponent, VersionOp versionOp)
{
Version specV = specVer1.Version;
Version packageV = packageVer2.Version;
return(comparisonFunctions[(int)versionOp](packageV, specV, filterComponent));
}
public uint EventGetFirmwareVersion64(IntPtr evt, VersionComponent component)
{
Contract.Requires<ArgumentException>(evt != IntPtr.Zero, "The pointer to the event must be set.");
return default(uint);
}
public static extern uint event_get_firmware_version(IntPtr evt, VersionComponent component);
private int this[VersionComponent component]
{
get { return((int)Version[component]); }
}
public static extern uint event_get_firmware_version(IntPtr evt, VersionComponent component);
public override void Increment(IncrementContext context, VersionComponent versionComponent)
{
string currentVersionComponentValue = context.GetCurrentVersionComponentValue(versionComponent);
string value = this.Increment(currentVersionComponentValue, context.BuildStartDate, context.ProjectStartDate, context.ProjectFilename);
context.SetNewVersionComponentValue(versionComponent, value);
}
