50 
  51     private static final String VERSION_BUILD =
  52         "@@VERSION_BUILD@@";
  53 
  54     private static final String VERSION_PRE =
  55         "@@VERSION_PRE@@";
  56 
  57     private static final String VERSION_OPT =
  58         "@@VERSION_OPT@@";
  59 
  60     static {
  61         init();
  62     }
  63 
  64     public static void init() {
  65         System.setProperty("java.version", java_version);
  66         System.setProperty("java.runtime.version", java_runtime_version);
  67         System.setProperty("java.runtime.name", java_runtime_name);
  68     }
  69 
  70     static List<Integer> versionNumbers() {










  71         List<Integer> versionNumbers = new ArrayList<>(4);
  72         int prevIndex = 0;
  73         int index = VERSION_NUMBER.indexOf('.');
  74         while (index > 0) {

  75             versionNumbers.add(
  76                     Integer.parseInt(VERSION_NUMBER, prevIndex, index, 10));
  77             prevIndex = index + 1; // Skip the period
  78             index = VERSION_NUMBER.indexOf('.', prevIndex);
  79         }
  80         versionNumbers.add(Integer.parseInt(VERSION_NUMBER,
  81                 prevIndex, VERSION_NUMBER.length(), 10));






  82         return versionNumbers;




  83     }
  84 
  85     static Optional<String> pre() {
  86         return optionalOf(VERSION_PRE);
  87     }
  88 
  89     static Optional<Integer> build() {
  90         return VERSION_BUILD.isEmpty() ?
  91                 Optional.empty() :
  92                 Optional.of(Integer.parseInt(VERSION_BUILD));
  93     }
  94 
  95     static Optional<String> optional() {
  96         return optionalOf(VERSION_OPT);
  97     }
  98 
  99     // Treat empty strings as value not being present
 100     private static Optional<String> optionalOf(String value) {
 101         if (!value.isEmpty()) {
 102             return Optional.of(value);

  50 
  51     private static final String VERSION_BUILD =
  52         "@@VERSION_BUILD@@";
  53 
  54     private static final String VERSION_PRE =
  55         "@@VERSION_PRE@@";
  56 
  57     private static final String VERSION_OPT =
  58         "@@VERSION_OPT@@";
  59 
  60     static {
  61         init();
  62     }
  63 
  64     public static void init() {
  65         System.setProperty("java.version", java_version);
  66         System.setProperty("java.runtime.version", java_runtime_version);
  67         System.setProperty("java.runtime.name", java_runtime_name);
  68     }
  69 
  70     private static void check(String s, int prevIndex, int index) {
  71         if (index - prevIndex > 1 &&
  72             Character.digit(s.charAt(prevIndex), 10) <= 0)
  73             throw new IllegalArgumentException("Leading zeros not supported (" +
  74                     s.substring(prevIndex, index) + ")");
  75     }
  76 
  77     // This method is reflectively regression tested from
  78     // test/java/lang/Runtime/Version/VersionProps.java
  79     // If you rename or remove this method, please update the test accordingly.
  80     static List<Integer> parseVersionNumbers(String versionNumber) {
  81         List<Integer> versionNumbers = new ArrayList<>(4);
  82         int prevIndex = 0;
  83         int index = versionNumber.indexOf('.');
  84         while (index > 0) {
  85             check(versionNumber, prevIndex, index);
  86             versionNumbers.add(
  87                     Integer.parseInt(versionNumber, prevIndex, index, 10));
  88             prevIndex = index + 1; // Skip the period
  89             index = versionNumber.indexOf('.', prevIndex);
  90         }
  91         check(versionNumber, prevIndex, versionNumber.length());
  92         versionNumbers.add(Integer.parseInt(versionNumber,
  93                 prevIndex, versionNumber.length(), 10));
  94 
  95         if (versionNumbers.get(0) == 0 || versionNumbers.get(versionNumbers.size() - 1) == 0)
  96             throw new IllegalArgumentException("Leading or trailing zeros not supported (" +
  97                     versionNumbers + ")");
  98 
  99         return versionNumbers;
 100     }
 101 
 102     static List<Integer> versionNumbers() {
 103         return parseVersionNumbers(VERSION_NUMBER);
 104     }
 105 
 106     static Optional<String> pre() {
 107         return optionalOf(VERSION_PRE);
 108     }
 109 
 110     static Optional<Integer> build() {
 111         return VERSION_BUILD.isEmpty() ?
 112                 Optional.empty() :
 113                 Optional.of(Integer.parseInt(VERSION_BUILD));
 114     }
 115 
 116     static Optional<String> optional() {
 117         return optionalOf(VERSION_OPT);
 118     }
 119 
 120     // Treat empty strings as value not being present
 121     private static Optional<String> optionalOf(String value) {
 122         if (!value.isEmpty()) {
 123             return Optional.of(value);