JavaVersion.java

  1. /*
  2.  * Licensed to the Apache Software Foundation (ASF) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * The ASF licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *      http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.apache.commons.lang3;

  19. import org.apache.commons.lang3.math.NumberUtils;

  21. /**
  22.  * An enum representing all the versions of the Java specification.
  23.  * This is intended to mirror available values from the
  24.  * <em>java.specification.version</em> System property.
  25.  *
  26.  * @since 3.0
  27.  */
  28. public enum JavaVersion {

  30.     /**
  31.      * The Java version reported by Android. This is not an official Java version number.
  32.      */
  33.     JAVA_0_9(1.5f, "0.9"),

  35.     /**
  36.      * Java 1.1.
  37.      */
  38.     JAVA_1_1(1.1f, "1.1"),

  40.     /**
  41.      * Java 1.2.
  42.      */
  43.     JAVA_1_2(1.2f, "1.2"),

  45.     /**
  46.      * Java 1.3.
  47.      */
  48.     JAVA_1_3(1.3f, "1.3"),

  50.     /**
  51.      * Java 1.4.
  52.      */
  53.     JAVA_1_4(1.4f, "1.4"),

  55.     /**
  56.      * Java 1.5.
  57.      */
  58.     JAVA_1_5(1.5f, "1.5"),

  60.     /**
  61.      * Java 1.6.
  62.      */
  63.     JAVA_1_6(1.6f, "1.6"),

  65.     /**
  66.      * Java 1.7.
  67.      */
  68.     JAVA_1_7(1.7f, "1.7"),

  70.     /**
  71.      * Java 1.8.
  72.      */
  73.     JAVA_1_8(1.8f, "1.8"),

  75.     /**
  76.      * Java 1.9.
  77.      *
  78.      * @deprecated As of release 3.5, replaced by {@link #JAVA_9}
  79.      */
  80.     @Deprecated
  81.     JAVA_1_9(9.0f, "9"),

  83.     /**
  84.      * Java 9.
  85.      *
  86.      * @since 3.5
  87.      */
  88.     JAVA_9(9.0f, "9"),

  90.     /**
  91.      * Java 10.
  92.      *
  93.      * @since 3.7
  94.      */
  95.     JAVA_10(10.0f, "10"),

  97.     /**
  98.      * Java 11.
  99.      *
  100.      * @since 3.8
  101.      */
  102.     JAVA_11(11.0f, "11"),

  104.     /**
  105.      * Java 12.
  106.      *
  107.      * @since 3.9
  108.      */
  109.     JAVA_12(12.0f, "12"),

  111.     /**
  112.      * Java 13.
  113.      *
  114.      * @since 3.9
  115.      */
  116.     JAVA_13(13.0f, "13"),

  118.     /**
  119.      * Java 14.
  120.      *
  121.      * @since 3.11
  122.      */
  123.     JAVA_14(14.0f, "14"),

  125.     /**
  126.      * Java 15.
  127.      *
  128.      * @since 3.11
  129.      */
  130.     JAVA_15(15.0f, "15"),

  132.     /**
  133.      * Java 16.
  134.      *
  135.      * @since 3.11
  136.      */
  137.     JAVA_16(16.0f, "16"),

  139.     /**
  140.      * Java 17.
  141.      *
  142.      * @since 3.12.0
  143.      */
  144.     JAVA_17(17.0f, "17"),

  146.     /**
  147.      * Java 18.
  148.      *
  149.      * @since 3.13.0
  150.      */
  151.     JAVA_18(18.0f, "18"),

  153.     /**
  154.      * Java 19.
  155.      *
  156.      * @since 3.13.0
  157.      */
  158.     JAVA_19(19.0f, "19"),

  160.     /**
  161.      * Java 20.
  162.      *
  163.      * @since 3.13.0
  164.      */
  165.     JAVA_20(20, "20"),

  167.     /**
  168.      * Java 21.
  169.      *
  170.      * @since 3.13.0
  171.      */
  172.     JAVA_21(21, "21"),

  174.     /**
  175.      * Java 22.
  176.      *
  177.      * @since 3.15.0
  178.      */
  179.     JAVA_22(22, "22"),

  181.     /**
  182.      * The most recent Java version. Mainly introduced to avoid to break when a new version of Java is used.
  183.      */
  184.     JAVA_RECENT(maxVersion(), Float.toString(maxVersion()));

  186.     /**
  187.      * The regex to split version strings.
  188.      */
  189.     private static final String VERSION_SPLIT_REGEX = "\\.";

  191.     /**
  192.      * Transforms the given string with a Java version number to the
  193.      * corresponding constant of this enumeration class. This method is used
  194.      * internally.
  195.      *
  196.      * @param versionStr the Java version as string
  197.      * @return the corresponding enumeration constant or <b>null</b> if the
  198.      * version is unknown
  199.      */
  200.     static JavaVersion get(final String versionStr) {
  201.         if (versionStr == null) {
  202.             return null;
  203.         }
  204.         switch (versionStr) {
  205.         case "0.9":
  206.             return JAVA_0_9;
  207.         case "1.1":
  208.             return JAVA_1_1;
  209.         case "1.2":
  210.             return JAVA_1_2;
  211.         case "1.3":
  212.             return JAVA_1_3;
  213.         case "1.4":
  214.             return JAVA_1_4;
  215.         case "1.5":
  216.             return JAVA_1_5;
  217.         case "1.6":
  218.             return JAVA_1_6;
  219.         case "1.7":
  220.             return JAVA_1_7;
  221.         case "1.8":
  222.             return JAVA_1_8;
  223.         case "9":
  224.             return JAVA_9;
  225.         case "10":
  226.             return JAVA_10;
  227.         case "11":
  228.             return JAVA_11;
  229.         case "12":
  230.             return JAVA_12;
  231.         case "13":
  232.             return JAVA_13;
  233.         case "14":
  234.             return JAVA_14;
  235.         case "15":
  236.             return JAVA_15;
  237.         case "16":
  238.             return JAVA_16;
  239.         case "17":
  240.             return JAVA_17;
  241.         case "18":
  242.             return JAVA_18;
  243.         case "19":
  244.             return JAVA_19;
  245.         case "20":
  246.             return JAVA_20;
  247.         case "21":
  248.             return JAVA_21;
  249.         case "22":
  250.             return JAVA_22;
  251.         default:
  252.             final float v = toFloatVersion(versionStr);
  253.             if (v - 1. < 1.) { // then we need to check decimals > .9
  254.                 final int firstComma = Math.max(versionStr.indexOf('.'), versionStr.indexOf(','));
  255.                 final int end = Math.max(versionStr.length(), versionStr.indexOf(',', firstComma));
  256.                 if (Float.parseFloat(versionStr.substring(firstComma + 1, end)) > .9f) {
  257.                     return JAVA_RECENT;
  258.                 }
  259.             } else if (v > 10) {
  260.                 return JAVA_RECENT;
  261.             }
  262.             return null;
  263.         }
  264.     }

  266.     /**
  267.      * Transforms the given string with a Java version number to the
  268.      * corresponding constant of this enumeration class. This method is used
  269.      * internally.
  270.      *
  271.      * @param versionStr the Java version as string
  272.      * @return the corresponding enumeration constant or <b>null</b> if the
  273.      * version is unknown
  274.      */
  275.     static JavaVersion getJavaVersion(final String versionStr) {
  276.         return get(versionStr);
  277.     }

  279.     /**
  280.      * Gets the Java Version from the system or 99.0 if the {@code java.specification.version} system property is not set.
  281.      *
  282.      * @return the value of {@code java.specification.version} system property or 99.0 if it is not set.
  283.      */
  284.     private static float maxVersion() {
  285.         final float v = toFloatVersion(SystemProperties.getJavaSpecificationVersion("99.0"));
  286.         return v > 0 ? v : 99f;
  287.     }

  289.     static String[] split(final String value) {
  290.         return value.split(VERSION_SPLIT_REGEX);
  291.     }

  293.     /**
  294.      * Parses a float value from a String.
  295.      *
  296.      * @param value the String to parse.
  297.      * @return the float value represented by the string or -1 if the given String can not be parsed.
  298.      */
  299.     private static float toFloatVersion(final String value) {
  300.         final int defaultReturnValue = -1;
  301.         if (!value.contains(".")) {
  302.             return NumberUtils.toFloat(value, defaultReturnValue);
  303.         }
  304.         final String[] toParse = split(value);
  305.         if (toParse.length >= 2) {
  306.             return NumberUtils.toFloat(toParse[0] + '.' + toParse[1], defaultReturnValue);
  307.         }
  308.         return defaultReturnValue;
  309.     }

  311.     /**
  312.      * The float value.
  313.      */
  314.     private final float value;

  316.     /**
  317.      * The standard name.
  318.      */
  319.     private final String name;

  321.     /**
  322.      * Constructs a new instance.
  323.      *
  324.      * @param value  the float value
  325.      * @param name  the standard name, not null
  326.      */
  327.     JavaVersion(final float value, final String name) {
  328.         this.value = value;
  329.         this.name = name;
  330.     }

  332.     /**
  333.      * Tests whether this version of Java is at least the version of Java passed in.
  334.      *
  335.      * <p>For example:<br>
  336.      *  {@code myVersion.atLeast(JavaVersion.JAVA_1_4)}</p>
  337.      *
  338.      * @param requiredVersion  the version to check against, not null
  339.      * @return true if this version is equal to or greater than the specified version
  340.      */
  341.     public boolean atLeast(final JavaVersion requiredVersion) {
  342.         return this.value >= requiredVersion.value;
  343.     }

  345.     /**
  346.      * Tests whether this version of Java is at most the version of Java passed in.
  347.      *
  348.      * <p>For example:<br>
  349.      *  {@code myVersion.atMost(JavaVersion.JAVA_1_4)}</p>
  350.      *
  351.      * @param requiredVersion  the version to check against, not null
  352.      * @return true if this version is equal to or greater than the specified version
  353.      * @since 3.9
  354.      */
  355.     public boolean atMost(final JavaVersion requiredVersion) {
  356.         return this.value <= requiredVersion.value;
  357.     }

  359.     /**
  360.      * The string value is overridden to return the standard name.
  361.      *
  362.      * <p>For example, {@code "1.5"}.</p>
  363.      *
  364.      * @return the name, not null
  365.      */
  366.     @Override
  367.     public String toString() {
  368.         return name;
  369.     }
  370. }
Created with JaCoCo 0.8.12.202403310830