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 XsltContextAssetVersionGetter(VersionComponent? ignoredVersionComponent = null) { this._ignoredVersionComponent = ignoredVersionComponent; }
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]); } }