### Install Semver4j Dependency

Source: https://github.com/vdurmont/semver4j/blob/master/README.md

Configuration snippets for adding the Semver4j library to Maven or Gradle build files.

```xml
<dependency>
  <groupId>com.vdurmont</groupId>
  <artifactId>semver4j</artifactId>
  <version>3.1.0</version>
</dependency>
```

```gradle
compile 'com.vdurmont:semver4j:3.1.0'
```

--------------------------------

### Initialize Semver Object

Source: https://github.com/vdurmont/semver4j/blob/master/README.md

Demonstrates how to instantiate a Semver object using different versioning modes. Throws a SemverException if the input string is invalid.

```java
Semver sem1 = new Semver("1.2.3-beta.4+sha899d8g79f87"); // Defaults to STRICT mode
Semver sem2 = new Semver("1.2.3-beta.4+sha899d8g79f87", SemverType.NPM); // Specify the mode
```

--------------------------------

### Compare Versions

Source: https://github.com/vdurmont/semver4j/blob/master/README.md

Demonstrates various comparison methods including greater than, lower than, equality, and equivalence checks.

```java
Semver sem = new Semver("1.2.3");
sem.isGreaterThan("1.2.2"); // true
sem.isLowerThan("1.2.4"); // true

Semver sem2 = new Semver("1.2.3+sha123456789");
sem2.isEqualTo("1.2.3+sha123456789"); // true
sem2.isEquivalentTo("1.2.3+shaABCDEFGHI"); // true
```

--------------------------------

### Compare Semver Objects in Java

Source: https://context7.com/vdurmont/semver4j/llms.txt

Illustrates various version comparison methods in Java provided by Semver4j, including greater than, less than, equal to, and equivalence checks. These methods correctly handle pre-release tags and build metadata according to semantic versioning rules.

```java
import com.vdurmont.semver4j.Semver;

Semver version = new Semver("1.2.3");

// Greater than comparison
System.out.println(version.isGreaterThan("1.2.2"));           // true
System.out.println(version.isGreaterThan("1.2.4"));           // false
System.out.println(version.isGreaterThan("1.2.3"));           // false

// Greater than or equal comparison
System.out.println(version.isGreaterThanOrEqualTo("1.2.3"));  // true
System.out.println(version.isGreaterThanOrEqualTo("1.2.2"));  // true

// Lower than comparison
System.out.println(version.isLowerThan("1.2.4"));             // true
System.out.println(version.isLowerThan("1.2.2"));             // false

// Lower than or equal comparison
System.out.println(version.isLowerThanOrEqualTo("1.2.3"));    // true
System.out.println(version.isLowerThanOrEqualTo("1.2.4"));    // true

// Exact equality (includes build metadata)
Semver versionWithBuild = new Semver("1.2.3+sha123456789");
System.out.println(versionWithBuild.isEqualTo("1.2.3+sha123456789")); // true
System.out.println(versionWithBuild.isEqualTo("1.2.3+shaABCDEFGHI")); // false

// Equivalence (ignores build metadata)
System.out.println(versionWithBuild.isEquivalentTo("1.2.3+sha123456789")); // true
System.out.println(versionWithBuild.isEquivalentTo("1.2.3+shaABCDEFGHI")); // true

// Pre-release version comparison
Semver alpha = new Semver("1.0.0-alpha.1");
Semver beta = new Semver("1.0.0-beta.1");
Semver release = new Semver("1.0.0");
System.out.println(alpha.isLowerThan(beta));     // true
System.out.println(beta.isLowerThan(release));   // true
```

--------------------------------

### Ivy/Gradle Mode Requirement Satisfaction in Java

Source: https://context7.com/vdurmont/semver4j/llms.txt

Demonstrates how to use semver4j in Ivy/Gradle mode to satisfy version requirements using dynamic versions and mathematical range notation. This is useful for managing dependencies with flexible versioning schemes. It requires the semver4j library.

```java
import com.vdurmont.semver4j.Semver;
import com.vdurmont.semver4j.Semver.SemverType;
import com.vdurmont.semver4j.Requirement;

Semver version = new Semver("1.2.3", SemverType.IVY);

// Dynamic patch version (1.2.+)
System.out.println(version.satisfies("1.2.+")); // true (>= 1.2.0 and < 1.3.0)
System.out.println(version.satisfies("1.3.+")); // false

// Dynamic minor version (1.+)
System.out.println(version.satisfies("1.+"));   // true (>= 1.0.0 and < 2.0.0)
System.out.println(version.satisfies("2.+"));   // false

// Mathematical range notation - bounded ranges
// [1.0,2.0] means >= 1.0.0 and <= 2.0.0
System.out.println(version.satisfies("[1.0,2.0]")); // true
// ]1.0,2.0[ means > 1.0.0 and < 2.0.0
System.out.println(version.satisfies("]1.0,2.0[")); // true
// [1.0,1.2[ means >= 1.0.0 and < 1.2.0
System.out.println(version.satisfies("[1.0,1.2[")); // false

// Unbounded ranges
// (,2.0] means <= 2.0.0
System.out.println(version.satisfies("(,2.0]")); // true
// [1.0,) means >= 1.0.0
System.out.println(version.satisfies("[1.0,)")); // true

// Using Requirement.buildIvy directly
Requirement ivyReq = Requirement.buildIvy("[1.0,2.0]");
System.out.println(ivyReq.isSatisfiedBy("1.5.0")); // true
System.out.println(ivyReq.isSatisfiedBy("2.5.0")); // false

```

--------------------------------

### Create Semver Objects in Java with Different Versioning Modes

Source: https://context7.com/vdurmont/semver4j/llms.txt

Demonstrates how to create `Semver` objects in Java, specifying different versioning modes like STRICT, NPM, LOOSE, COCOAPODS, and IVY. It also shows how to access individual version components such as major, minor, patch, suffix, and build metadata.

```java
import com.vdurmont.semver4j.Semver;
import com.vdurmont.semver4j.Semver.SemverType;

// STRICT mode (default) - requires major.minor.patch
Semver strictVersion = new Semver("1.2.3");
Semver strictWithSuffix = new Semver("1.2.3-beta.4+sha899d8g79f87");

// NPM mode - supports 'v' prefix and wildcards
Semver npmVersion = new Semver("v1.2.3", SemverType.NPM);
Semver npmLoose = new Semver("1.2", SemverType.NPM);

// LOOSE mode - only major is required
Semver looseVersion = new Semver("1", SemverType.LOOSE);

// COCOAPODS mode
Semver podVersion = new Semver("1.2.3", SemverType.COCOAPODS);

// IVY mode (Gradle compatibility)
Semver ivyVersion = new Semver("1.2.3", SemverType.IVY);

// Access version components
System.out.println(strictWithSuffix.getMajor());        // 1
System.out.println(strictWithSuffix.getMinor());        // 2
System.out.println(strictWithSuffix.getPatch());        // 3
System.out.println(strictWithSuffix.getSuffixTokens()); // ["beta", "4"]
System.out.println(strictWithSuffix.getBuild());        // "sha899d8g79f87"
System.out.println(strictWithSuffix.getValue());        // "1.2.3-beta.4+sha899d8g79f87"
```

--------------------------------

### Handle SemverException in Java

Source: https://context7.com/vdurmont/semver4j/llms.txt

Demonstrates how to catch and handle SemverException when parsing invalid version strings with the Semver4j library. It covers scenarios like completely invalid formats, strict mode violations, and empty build metadata. A safe parsing pattern is also provided to return null instead of throwing an exception.

```java
import com.vdurmont.semver4j.Semver;
import com.vdurmont.semver4j.Semver.SemverType;
import com.vdurmont.semver4j.SemverException;

// Invalid version handling
try {
    new Semver("not-a-version");
} catch (SemverException e) {
    System.out.println("Invalid version: " + e.getMessage());
}

// STRICT mode requires all components
try {
    new Semver("1.2", SemverType.STRICT);
} catch (SemverException e) {
    System.out.println("STRICT mode requires patch: " + e.getMessage());
}

// Empty build is invalid
try {
    new Semver("1.2.3+");
} catch (SemverException e) {
    System.out.println("Empty build: " + e.getMessage());
}

// Safe parsing pattern
public static Semver safeParse(String version, SemverType type) {
    try {
        return new Semver(version, type);
    } catch (SemverException e) {
        return null; // or return a default version
    }
}

Semver parsed = safeParse("1.2.3", SemverType.NPM);
if (parsed != null) {
    System.out.println("Valid version: " + parsed.getValue());
}
```

--------------------------------

### NPM Mode Requirement Satisfaction in Java

Source: https://context7.com/vdurmont/semver4j/llms.txt

Illustrates NPM mode requirement satisfaction in semver4j, supporting a wide array of operators like comparison, tilde, caret, wildcards, hyphen ranges, and logical operators (AND/OR). This mode is suitable for complex dependency management scenarios.

```java
import com.vdurmont.semver4j.Semver;
import com.vdurmont.semver4j.Semver.SemverType;
import com.vdurmont.semver4j.Requirement;

Semver version = new Semver("1.2.3", SemverType.NPM);

// Comparison operators
System.out.println(version.satisfies(">1.2.2"));   // true
System.out.println(version.satisfies(">=1.2.3"));  // true
System.out.println(version.satisfies("<1.3.0"));   // true
System.out.println(version.satisfies("<=1.2.3"));  // true
System.out.println(version.satisfies("=1.2.3"));   // true

// Tilde (~) - allows patch-level changes
System.out.println(version.satisfies("~1.2.1"));   // true  (>=1.2.1 <1.3.0)
System.out.println(version.satisfies("~1.2.4"));   // false

// Caret (^) - allows minor-level changes (non-breaking)
System.out.println(version.satisfies("^1.1.1"));   // true  (>=1.1.1 <2.0.0)
System.out.println(version.satisfies("^1.3.0"));   // false

// Wildcards
System.out.println(version.satisfies("1.2.x"));    // true
System.out.println(version.satisfies("1.2.*"));    // true
System.out.println(version.satisfies("1.x"));      // true
System.out.println(version.satisfies("*"));        // true
System.out.println(version.satisfies("1.1.*"));    // false

// Hyphen ranges
System.out.println(version.satisfies("1.0.0 - 2.0.0"));  // true
System.out.println(version.satisfies("1.2.0 - 1.2.5"));  // true

// OR operator (||)
System.out.println(version.satisfies("1.1.1 || 1.2.3 - 2.0.0")); // true
System.out.println(version.satisfies("^1.0.0 || ^2.0.0"));       // true

// AND operator (space-separated)
System.out.println(version.satisfies(">=1.2.0 <1.3.0")); // true

// Using Requirement.buildNPM directly
Requirement npmReq = Requirement.buildNPM("^1.0.0");
System.out.println(npmReq.isSatisfiedBy("1.5.0")); // true
System.out.println(npmReq.isSatisfiedBy("2.0.0")); // false
```

--------------------------------

### Sorting and Comparing Semver Versions in Java

Source: https://context7.com/vdurmont/semver4j/llms.txt

Explains how to sort and compare semantic versions using the `Semver` class in semver4j, which implements `Comparable`. This allows for easy ordering of versions in lists and sorted collections. It requires the semver4j library and standard Java collections.

```java
import com.vdurmont.semver4j.Semver;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.TreeSet;

// Create a list of versions
List<Semver> versions = new ArrayList<>();
versions.add(new Semver("2.0.0"));
versions.add(new Semver("1.0.0-alpha"));
versions.add(new Semver("1.0.0"));
versions.add(new Semver("1.0.0-beta"));
versions.add(new Semver("1.5.0"));
versions.add(new Semver("1.0.0-alpha.1"));

// Sort ascending
Collections.sort(versions);
for (Semver v : versions) {
    System.out.println(v);
}
// Output:
// 1.0.0-alpha
// 1.0.0-alpha.1
// 1.0.0-beta
// 1.0.0
// 1.5.0
// 2.0.0

// Sort descending
Collections.sort(versions, Collections.reverseOrder());

// Use in TreeSet for automatic ordering
TreeSet<Semver> sortedSet = new TreeSet<>();
sortedSet.add(new Semver("1.2.3"));
sortedSet.add(new Semver("1.0.0"));
sortedSet.add(new Semver("2.0.0"));
System.out.println(sortedSet.first()); // 1.0.0
System.out.println(sortedSet.last());  // 2.0.0

// compareTo returns -1, 0, or 1
Semver v1 = new Semver("1.0.0");
Semver v2 = new Semver("2.0.0");
System.out.println(v1.compareTo(v2)); // -1
System.out.println(v2.compareTo(v1)); // 1
System.out.println(v1.compareTo(v1)); // 0

```

--------------------------------

### Custom Version Range Operations in Java

Source: https://context7.com/vdurmont/semver4j/llms.txt

Illustrates how to perform low-level version range checking using the `Range` class in semver4j. This allows for custom requirement logic with explicit operators like greater than, less than, etc. It requires the semver4j library.

```java
import com.vdurmont.semver4j.Range;
import com.vdurmont.semver4j.Range.RangeOperator;
import com.vdurmont.semver4j.Semver;

// Create ranges with explicit operators
Range eqRange = new Range("1.2.3", RangeOperator.EQ);
Range gtRange = new Range("1.0.0", RangeOperator.GT);
Range gteRange = new Range("1.0.0", RangeOperator.GTE);
Range ltRange = new Range("2.0.0", RangeOperator.LT);
Range lteRange = new Range("2.0.0", RangeOperator.LTE);

Semver version = new Semver("1.5.0");

// Check satisfaction
System.out.println(eqRange.isSatisfiedBy(version));  // false
System.out.println(gtRange.isSatisfiedBy(version));  // true
System.out.println(gteRange.isSatisfiedBy(version)); // true
System.out.println(ltRange.isSatisfiedBy(version));  // true
System.out.println(lteRange.isSatisfiedBy(version)); // true

// String representation
System.out.println(gtRange.toString());  // >1.0.0
System.out.println(lteRange.toString()); // <=2.0.0

// Check with Semver objects
Range semverRange = new Range(new Semver("1.5.0"), RangeOperator.EQ);
System.out.println(semverRange.isSatisfiedBy(version)); // true

```

--------------------------------

### Strict Mode Requirement Satisfaction in Java

Source: https://context7.com/vdurmont/semver4j/llms.txt

Demonstrates how to check for exact version matches in STRICT mode using semver4j. In this mode, only an identical version string satisfies the requirement. Ranges or wildcards are not supported and will throw an exception.

```java
import com.vdurmont.semver4j.Semver;
import com.vdurmont.semver4j.Semver.SemverType;
import com.vdurmont.semver4j.Requirement;

// STRICT mode - exact version match only
Semver version = new Semver("1.2.3", SemverType.STRICT);
System.out.println(version.satisfies("1.2.3")); // true
System.out.println(version.satisfies("1.2.2")); // false
System.out.println(version.satisfies("1.2.4")); // false
// version.satisfies(">1.2.2"); // Throws SemverException - ranges not supported in STRICT

// Using Requirement directly
Requirement strictReq = Requirement.buildStrict("1.2.3");
System.out.println(strictReq.isSatisfiedBy("1.2.3")); // true
System.out.println(strictReq.isSatisfiedBy("1.2.4")); // false

// LOOSE mode - also exact match
Requirement looseReq = Requirement.buildLoose("1.2");
System.out.println(looseReq.isSatisfiedBy("1.2.0")); // true
```

--------------------------------

### Normalize Loose Versions to Strict Semver with `toStrict`

Source: https://context7.com/vdurmont/semver4j/llms.txt

The `toStrict()` method converts loose version formats to the strict semantic versioning format by filling in missing minor and patch numbers with zeros. This method also preserves any existing suffix and build metadata.

```java
import com.vdurmont.semver4j.Semver;
import com.vdurmont.semver4j.Semver.SemverType;

// Convert loose versions to strict format
Semver looseVersion = new Semver("1", SemverType.LOOSE);
Semver strictVersion = looseVersion.toStrict();
System.out.println(strictVersion.getValue());            // 1.0.0

Semver partialVersion = new Semver("1.2", SemverType.NPM);
System.out.println(partialVersion.toStrict().getValue()); // 1.2.0

// Preserves suffix and build when normalizing
Semver withSuffix = new Semver("1.2-alpha+build", SemverType.LOOSE);
System.out.println(withSuffix.toStrict().getValue());     // 1.2.0-alpha+build
```

--------------------------------

### Check Version Satisfaction with Semver4j

Source: https://github.com/vdurmont/semver4j/blob/master/README.md

Demonstrates how to use the `satisfies` method in semver4j to check if a version meets specified requirements. Supports STRICT, NPM, COCOAPODS, and IVY modes, each with different requirement syntaxes. Incompatible requirements in STRICT mode will throw a SemverException.

```java
import com.vdurmont.semver4j.Semver;
import com.vdurmont.semver4j.SemverException;
import com.vdurmont.semver4j.SemverType;

// STRICT mode
Semver semStrict = new Semver("1.2.3", SemverType.STRICT);
System.out.println(semStrict.satisfies("1.2.3")); // true
System.out.println(semStrict.satisfies("1.2.2")); // false
System.out.println(semStrict.satisfies("1.2.4")); // false
try {
    semStrict.satisfies(">1.2.2"); // SemverException, incompatible requirement for a STRICT mode
} catch (SemverException e) {
    System.out.println("Caught expected exception: " + e.getMessage());
}

// NPM mode (those are just examples, check NPM documentation to see all the cases)
Semver semNPM = new Semver("1.2.3", SemverType.NPM);
System.out.println(semNPM.satisfies(">1.2.2")); // true
System.out.println(semNPM.satisfies("1.1.1 || 1.2.3 - 2.0.0")); // true
System.out.println(semNPM.satisfies("1.1.*")); // false
System.out.println(semNPM.satisfies("~1.2.1")); // true
System.out.println(semNPM.satisfies("^1.1.1")); // true

// COCOAPODS mode (those are just examples, check CocoaPods documentation to see all the cases)
Semver semPOD = new Semver("1.2.3", SemverType.COCOAPODS);
System.out.println(semPOD.satisfies("> 1.2.2")); // true
System.out.println(semPOD.satisfies("~> 1.2.1")); // true
System.out.println(semPOD.satisfies("<= 1.1.1")); // false

// IVY mode (those are just examples, check Ivy/gradle documentation to see all the cases)
Semver semIVY = new Semver("1.2.3", SemverType.IVY);
System.out.println(semIVY.satisfies("1.2.+")); // true
System.out.println(semIVY.satisfies("(,1.8.9]")); // true
System.out.println(semIVY.satisfies("[0.2,1.4]")); // true

```

--------------------------------

### Increment Version Components with `withInc` and `next` Methods

Source: https://context7.com/vdurmont/semver4j/llms.txt

Semver4j provides methods to create new version objects with incremented components. The `Semver` object is immutable, so these operations return new instances. Methods like `withIncMajor`, `withIncMinor`, `withIncPatch` preserve suffixes and build metadata, while `nextMajor`, `nextMinor`, and `nextPatch` clear them.

```java
import com.vdurmont.semver4j.Semver;

Semver version = new Semver("1.2.3-beta.4+sha899d8g79f87");

// Increment with suffix/build preservation
System.out.println(version.withIncMajor());     // 2.2.3-beta.4+sha899d8g79f87
System.out.println(version.withIncMajor(2));    // 3.2.3-beta.4+sha899d8g79f87
System.out.println(version.withIncMinor());     // 1.3.3-beta.4+sha899d8g79f87
System.out.println(version.withIncPatch());     // 1.2.4-beta.4+sha899d8g79f87

// Next version (clears suffix and build)
System.out.println(version.nextMajor());        // 2.0.0
System.out.println(version.nextMinor());        // 1.3.0
System.out.println(version.nextPatch());        // 1.2.4

// Clear suffix or build
System.out.println(version.withClearedSuffix());         // 1.2.3+sha899d8g79f87
System.out.println(version.withClearedBuild());          // 1.2.3-beta.4
System.out.println(version.withClearedSuffixAndBuild()); // 1.2.3

// Set new suffix or build
Semver base = new Semver("1.2.3");
System.out.println(base.withSuffix("rc.1"));             // 1.2.3-rc.1
System.out.println(base.withBuild("build.456"));         // 1.2.3+build.456
```

--------------------------------

### CocoaPods Mode Requirement Satisfaction in Java

Source: https://context7.com/vdurmont/semver4j/llms.txt

Details CocoaPods mode requirement satisfaction in semver4j, which supports standard comparison operators and the optimistic operator (~>). This mode is tailored for iOS/macOS dependency management.

```java
import com.vdurmont.semver4j.Semver;
import com.vdurmont.semver4j.Semver.SemverType;
import com.vdurmont.semver4j.Requirement;

Semver version = new Semver("1.2.3", SemverType.COCOAPODS);

// Comparison operators
System.out.println(version.satisfies("> 1.2.2"));  // true
System.out.println(version.satisfies(">= 1.2.3")); // true
System.out.println(version.satisfies("< 1.3.0"));  // true
System.out.println(version.satisfies("<= 1.2.3")); // true
System.out.println(version.satisfies("<= 1.1.1")); // false

// Optimistic operator (~>) - similar to tilde in NPM
// ~> 1.2.1 means >= 1.2.1 and < 1.3.0
System.out.println(version.satisfies("~> 1.2.1")); // true
System.out.println(version.satisfies("~> 1.2"));   // true (>= 1.2.0 and < 2.0.0)
System.out.println(version.satisfies("~> 1.3.0")); // false

// Using Requirement.buildCocoapods directly
Requirement podReq = Requirement.buildCocoapods("~> 1.0");
System.out.println(podReq.isSatisfiedBy("1.9.9")); // true
System.out.println(podReq.isSatisfiedBy("2.0.0")); // false
```

--------------------------------

### Modify Semver Version Immutably with Semver4j

Source: https://github.com/vdurmont/semver4j/blob/master/README.md

Illustrates how to create new `Semver` objects with modified version components using immutable methods. This includes incrementing major, minor, or patch versions, clearing suffixes or build information, and advancing to the next major, minor, or patch version.

```java
import com.vdurmont.semver4j.Semver;

Semver original = new Semver("1.2.3-beta.4+sha32iddfu987");

// Incrementing specific parts
Semver incMajor = original.withIncMajor(); // 2.2.3-beta.4+sha32iddfu987
Semver incMinor = original.withIncMinor(2); // 1.4.3-beta.4+sha32iddfu987
Semver incPatch = original.withIncPatch(); // 1.2.4-beta.4+sha32iddfu987

// Clearing parts
Semver clearedSuffix = original.withClearedSuffix(); // 1.2.3+sha32iddfu987
Semver clearedBuild = original.withClearedBuild(); // 1.2.3-beta.4

// Advancing to next version parts
Semver nextMajor = original.nextMajor(); // 2.0.0
Semver nextMinor = original.nextMinor(); // 1.3.0
Semver nextPatch = original.nextPatch(); // 1.2.4

System.out.println("Original: " + original);
System.out.println("Inc Major: " + incMajor);
System.out.println("Inc Minor: " + incMinor);
System.out.println("Inc Patch: " + incPatch);
System.out.println("Cleared Suffix: " + clearedSuffix);
System.out.println("Cleared Build: " + clearedBuild);
System.out.println("Next Major: " + nextMajor);
System.out.println("Next Minor: " + nextMinor);
System.out.println("Next Patch: " + nextPatch);

```

--------------------------------

### Detect Version Differences with `diff` Method

Source: https://context7.com/vdurmont/semver4j/llms.txt

The `diff` method in semver4j detects the greatest difference between two version strings. It returns a `VersionDiff` enum value indicating NONE, MAJOR, MINOR, PATCH, SUFFIX, or BUILD differences. This is useful for upgrade detection and understanding compatibility.

```java
import com.vdurmont.semver4j.Semver;
import com.vdurmont.semver4j.Semver.VersionDiff;

Semver version = new Semver("1.2.3-beta.4+sha899d8g79f87");

// Identify the greatest difference between versions
System.out.println(version.diff("1.2.3-beta.4+sha899d8g79f87")); // NONE
System.out.println(version.diff("2.3.4-alpha.5+sha32iddfu987")); // MAJOR
System.out.println(version.diff("1.3.4-alpha.5+sha32iddfu987")); // MINOR
System.out.println(version.diff("1.2.4-alpha.5+sha32iddfu987")); // PATCH
System.out.println(version.diff("1.2.3-alpha.5+sha32iddfu987")); // SUFFIX
System.out.println(version.diff("1.2.3-beta.4+sha32iddfu987"));  // BUILD

// Use diff for upgrade detection
Semver current = new Semver("2.1.0");
Semver update = new Semver("3.0.0");
VersionDiff diff = current.diff(update);
if (diff == VersionDiff.MAJOR) {
    System.out.println("Breaking changes possible - review changelog!");
}
```

--------------------------------

### Check Version Stability with `isStable` Method

Source: https://context7.com/vdurmont/semver4j/llms.txt

The `isStable` method determines if a version is considered stable. A version is stable if its major number is strictly positive and it does not have a pre-release suffix. This method is crucial for differentiating between release versions and development or pre-release versions.

```java
import com.vdurmont.semver4j.Semver;

// Stable versions (major > 0 and no suffix)
System.out.println(new Semver("1.2.3").isStable());                          // true
System.out.println(new Semver("1.2.3+sha.0nSFGKjkjsdf").isStable());         // true
System.out.println(new Semver("2.0.0").isStable());                           // true

// Unstable versions (major = 0 or has suffix)
System.out.println(new Semver("0.1.2").isStable());                           // false
System.out.println(new Semver("0.1.2+sha.0nSFGKjkjsdf").isStable());          // false
System.out.println(new Semver("1.2.3-BETA.11+sha.0nSFGKjkjsdf").isStable());  // false
System.out.println(new Semver("1.0.0-rc.1").isStable());                      // false
```

--------------------------------

### Check Version Stability

Source: https://github.com/vdurmont/semver4j/blob/master/README.md

Uses the isStable() method to determine if a version is considered stable based on its major number and absence of suffixes.

```java
// TRUE
new Semver("1.2.3").isStable();
new Semver("1.2.3+sHa.0nSFGKjkjsdf").isStable();

// FALSE
new Semver("0.1.2").isStable());
new Semver("0.1.2+sHa.0nSFGKjkjsdf").isStable();
new Semver("1.2.3-BETA.11+sHa.0nSFGKjkjsdf").isStable();
```

--------------------------------

### Calculate Version Diffs

Source: https://github.com/vdurmont/semver4j/blob/master/README.md

Uses the diff method to identify the primary difference between two versions, returning a VersionDiff enum value.

```java
Semver sem = new Semver("1.2.3-beta.4+sha899d8g79f87");
sem.diff("1.2.3-beta.4+sha899d8g79f87"); // NONE
sem.diff("2.3.4-alpha.5+sha32iddfu987"); // MAJOR
sem.diff("1.3.4-alpha.5+sha32iddfu987"); // MINOR
sem.diff("1.2.4-alpha.5+sha32iddfu987"); // PATCH
sem.diff("1.2.3-alpha.5+sha32iddfu987"); // SUFFIX
sem.diff("1.2.3-beta.4+sha32iddfu987"); // BUILD
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.