Ignore:
Timestamp:
2024-04-22T20:59:26+02:00 (4 weeks ago)
Author:
taylor.smock
Message:

Revert most var changes from r19048, fix most new compile warnings and checkstyle issues

Also, document why various ErrorProne checks were originally disabled and fix
generic SonarLint issues.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/tools/Utils.java

    r19048 r19050  
    99import java.awt.font.FontRenderContext;
    1010import java.awt.font.GlyphVector;
    11 import java.io.ByteArrayOutputStream;
    1211import java.io.Closeable;
    1312import java.io.File;
     
    3029import java.nio.file.StandardCopyOption;
    3130import java.nio.file.attribute.BasicFileAttributes;
     31import java.nio.file.attribute.FileTime;
    3232import java.security.MessageDigest;
    3333import java.security.NoSuchAlgorithmException;
     
    152152     */
    153153    public static <T> int indexOf(Iterable<? extends T> collection, Predicate<? super T> predicate) {
    154         var i = 0;
    155         for (var item : collection) {
     154        int i = 0;
     155        for (T item : collection) {
    156156            if (predicate.test(item))
    157157                return i;
     
    168168     * @throws AssertionError if the condition is not met
    169169     */
    170     public static void ensure(boolean condition, String message, Object...data) {
     170    public static void ensure(boolean condition, String message, Object... data) {
    171171        if (!condition)
    172172            throw new AssertionError(
     
    185185        if (n <= 0)
    186186            throw new IllegalArgumentException("n must be <= 0 but is " + n);
    187         var res = a % n;
     187        int res = a % n;
    188188        if (res < 0) {
    189189            res += n;
     
    303303            Logging.warn("Unable to create directory "+out.getPath());
    304304        }
    305         var files = in.listFiles();
     305        File[] files = in.listFiles();
    306306        if (files != null) {
    307             for (var f : files) {
    308                 var target = new File(out, f.getName());
     307            for (File f : files) {
     308                File target = new File(out, f.getName());
    309309                if (f.isDirectory()) {
    310310                    copyDirectory(f, target);
     
    324324    public static boolean deleteDirectory(File path) {
    325325        if (path.exists()) {
    326             var files = path.listFiles();
     326            File[] files = path.listFiles();
    327327            if (files != null) {
    328                 for (var file : files) {
     328                for (File file : files) {
    329329                    if (file.isDirectory()) {
    330330                        deleteDirectory(file);
     
    371371     */
    372372    public static boolean deleteFile(File file, String warnMsg) {
    373         var result = file.delete();
     373        boolean result = file.delete();
    374374        if (!result) {
    375375            Logging.warn(tr(warnMsg, file.getPath()));
     
    397397     */
    398398    public static boolean mkDirs(File dir, String warnMsg) {
    399         var result = dir.mkdirs();
     399        boolean result = dir.mkdirs();
    400400        if (!result) {
    401401            Logging.warn(tr(warnMsg, dir.getPath()));
     
    497497            throw new JosmRuntimeException(e);
    498498        }
    499         var byteData = data.getBytes(StandardCharsets.UTF_8);
    500         var byteDigest = md.digest(byteData);
     499        byte[] byteData = data.getBytes(StandardCharsets.UTF_8);
     500        byte[] byteDigest = md.digest(byteData);
    501501        return toHexString(byteDigest);
    502502    }
     
    517517        }
    518518
    519         final var len = bytes.length;
     519        final int len = bytes.length;
    520520        if (len == 0) {
    521521            return "";
    522522        }
    523523
    524         var hexChars = new char[len * 2];
    525         var j = 0;
     524        char[] hexChars = new char[len * 2];
     525        int j = 0;
    526526        for (final int v : bytes) {
    527527            hexChars[j++] = HEX_ARRAY[(v & 0xf0) >> 4];
     
    541541     */
    542542    public static <T> List<T> topologicalSort(final MultiMap<T, T> dependencies) {
    543         var deps = new MultiMap<T, T>();
    544         for (var key : dependencies.keySet()) {
     543        MultiMap<T, T> deps = new MultiMap<>();
     544        for (T key : dependencies.keySet()) {
    545545            deps.putVoid(key);
    546             for (var val : dependencies.get(key)) {
     546            for (T val : dependencies.get(key)) {
    547547                deps.putVoid(val);
    548548                deps.put(key, val);
     
    550550        }
    551551
    552         var size = deps.size();
     552        int size = deps.size();
    553553        List<T> sorted = new ArrayList<>();
    554         for (var i = 0; i < size; ++i) {
    555             var parentless = deps.keySet().stream()
     554        for (int i = 0; i < size; ++i) {
     555            T parentless = deps.keySet().stream()
    556556                    .filter(key -> deps.get(key).isEmpty())
    557557                    .findFirst().orElse(null);
     
    559559            sorted.add(parentless);
    560560            deps.remove(parentless);
    561             for (var key : deps.keySet()) {
     561            for (T key : deps.keySet()) {
    562562                deps.remove(key, parentless);
    563563            }
     
    679679            return Collections.emptyMap();
    680680        } else if (map.size() == 1) {
    681             final var entry = map.entrySet().iterator().next();
     681            final Map.Entry<K, V> entry = map.entrySet().iterator().next();
    682682            return Collections.singletonMap(entry.getKey(), entry.getValue());
    683683        } else if (mapOfEntries != null) {
     
    795795        }
    796796
    797         var start = 0;
    798         var end = str.length();
    799         var leadingSkipChar = true;
     797        int start = 0;
     798        int end = str.length();
     799        boolean leadingSkipChar = true;
    800800        while (leadingSkipChar && start < end) {
    801801            leadingSkipChar = isStrippedChar(str.charAt(start), skipChars);
     
    804804            }
    805805        }
    806         var trailingSkipChar = true;
     806        boolean trailingSkipChar = true;
    807807        while (trailingSkipChar && end > start) {
    808808            trailingSkipChar = isStrippedChar(str.charAt(end - 1), skipChars);
     
    866866            Logging.debug(String.join(" ", command));
    867867        }
    868         var out = Files.createTempFile("josm_exec_" + command.get(0) + "_", ".txt");
     868        Path out = Files.createTempFile("josm_exec_" + command.get(0) + "_", ".txt");
    869869        try {
    870             var p = new ProcessBuilder(command).redirectErrorStream(true).redirectOutput(out.toFile()).start();
     870            Process p = new ProcessBuilder(command).redirectErrorStream(true).redirectOutput(out.toFile()).start();
    871871            if (!p.waitFor(timeout, unit) || p.exitValue() != 0) {
    872872                throw new ExecutionException(command.toString(), null);
     
    888888     */
    889889    public static File getJosmTempDir() {
    890         var tmpDir = getSystemProperty("java.io.tmpdir");
     890        String tmpDir = getSystemProperty("java.io.tmpdir");
    891891        if (tmpDir == null) {
    892892            return null;
    893893        }
    894         final var josmTmpDir = new File(tmpDir, "JOSM");
     894        final File josmTmpDir = new File(tmpDir, "JOSM");
    895895        if (!josmTmpDir.exists() && !josmTmpDir.mkdirs()) {
    896896            Logging.warn("Unable to create temp directory " + josmTmpDir);
     
    920920        // Is it less than 1 hour ?
    921921        if (elapsedTime < MILLIS_OF_HOUR) {
    922             final var min = elapsedTime / MILLIS_OF_MINUTE;
     922            final long min = elapsedTime / MILLIS_OF_MINUTE;
    923923            return String.format("%d %s %d %s", min, tr("min"), (elapsedTime - min * MILLIS_OF_MINUTE) / MILLIS_OF_SECOND, tr("s"));
    924924        }
    925925        // Is it less than 1 day ?
    926926        if (elapsedTime < MILLIS_OF_DAY) {
    927             final var hour = elapsedTime / MILLIS_OF_HOUR;
     927            final long hour = elapsedTime / MILLIS_OF_HOUR;
    928928            return String.format("%d %s %d %s", hour, tr("h"), (elapsedTime - hour * MILLIS_OF_HOUR) / MILLIS_OF_MINUTE, tr("min"));
    929929        }
    930         var days = elapsedTime / MILLIS_OF_DAY;
     930        long days = elapsedTime / MILLIS_OF_DAY;
    931931        return String.format("%d %s %d %s", days, trn("day", "days", days), (elapsedTime - days * MILLIS_OF_DAY) / MILLIS_OF_HOUR, tr("h"));
    932932    }
     
    943943            throw new IllegalArgumentException("bytes must be >= 0");
    944944        }
    945         var unitIndex = 0;
     945        int unitIndex = 0;
    946946        double value = bytes;
    947947        while (value >= 1024 && unitIndex < SIZE_UNITS.length) {
     
    967967    public static String getPositionListString(List<Integer> positionList) {
    968968        Collections.sort(positionList);
    969         final var sb = new StringBuilder(32);
     969        final StringBuilder sb = new StringBuilder(32);
    970970        sb.append(positionList.get(0));
    971         var cnt = 0;
     971        int cnt = 0;
    972972        int last = positionList.get(0);
    973         for (var i = 1; i < positionList.size(); ++i) {
     973        for (int i = 1; i < positionList.size(); ++i) {
    974974            int cur = positionList.get(i);
    975975            if (cur == last + 1) {
     
    10301030     */
    10311031    public static Throwable getRootCause(Throwable t) {
    1032         var result = t;
     1032        Throwable result = t;
    10331033        if (result != null) {
    1034             var cause = result.getCause();
     1034            Throwable cause = result.getCause();
    10351035            while (cause != null && !cause.equals(result)) {
    10361036                result = cause;
     
    10501050     */
    10511051    public static <T> T[] addInArrayCopy(T[] array, T item) {
    1052         var biggerCopy = Arrays.copyOf(array, array.length + 1);
     1052        T[] biggerCopy = Arrays.copyOf(array, array.length + 1);
    10531053        biggerCopy[array.length] = item;
    10541054        return biggerCopy;
     
    10631063     */
    10641064    public static String shortenString(String s, int maxLength) {
    1065         final var ellipses = "...";
     1065        final String ellipses = "...";
    10661066        CheckParameterUtil.ensureThat(maxLength >= ellipses.length(), "maxLength is shorter than " + ellipses.length());
    10671067        if (s != null && s.length() > maxLength) {
     
    11011101            if (elements.size() > maxElements) {
    11021102                final Collection<T> r = new ArrayList<>(maxElements);
    1103                 final var it = elements.iterator();
     1103                final Iterator<T> it = elements.iterator();
    11041104                while (r.size() < maxElements - 1) {
    11051105                    r.add(it.next());
     
    11261126            return url;
    11271127
    1128         final var query = url.substring(url.indexOf('?') + 1);
    1129 
    1130         final var sb = new StringBuilder(url.substring(0, url.indexOf('?') + 1));
    1131 
    1132         for (var i = 0; i < query.length(); i++) {
    1133             final var c = query.substring(i, i + 1);
     1128        final String query = url.substring(url.indexOf('?') + 1);
     1129
     1130        final StringBuilder sb = new StringBuilder(url.substring(0, url.indexOf('?') + 1));
     1131
     1132        for (int i = 0; i < query.length(); i++) {
     1133            final String c = query.substring(i, i + 1);
    11341134            if (URL_CHARS.contains(c)) {
    11351135                sb.append(c);
     
    11521152     */
    11531153    public static String encodeUrl(String s) {
    1154         final var enc = StandardCharsets.UTF_8.name();
     1154        final String enc = StandardCharsets.UTF_8.name();
    11551155        try {
    11561156            return URLEncoder.encode(s, enc);
     
    11721172     */
    11731173    public static String decodeUrl(String s) {
    1174         final var enc = StandardCharsets.UTF_8.name();
     1174        final String enc = StandardCharsets.UTF_8.name();
    11751175        try {
    11761176            return URLDecoder.decode(s, enc);
     
    12201220            @Override
    12211221            public Thread newThread(final Runnable runnable) {
    1222                 final var thread = new Thread(runnable, String.format(Locale.ENGLISH, nameFormat, count.getAndIncrement()));
     1222                final Thread thread = new Thread(runnable, String.format(Locale.ENGLISH, nameFormat, count.getAndIncrement()));
    12231223                thread.setPriority(threadPriority);
    12241224                return thread;
     
    12981298    public static boolean isSimilar(String string1, String string2) {
    12991299        // check plain strings
    1300         var distance = getLevenshteinDistance(string1, string2);
     1300        int distance = getLevenshteinDistance(string1, string2);
    13011301
    13021302        // check if only the case differs, so we don't consider large distance as different strings
     
    13391339        }
    13401340
    1341         for (var length : values) {
     1341        for (double length : values) {
    13421342            standardDeviation += Math.pow(length - mean, 2);
    13431343        }
     
    13601360        }
    13611361        List<int[]> groups = new ArrayList<>();
    1362         var current = new int[]{Integer.MIN_VALUE, Integer.MIN_VALUE};
     1362        int[] current = {Integer.MIN_VALUE, Integer.MIN_VALUE};
    13631363        groups.add(current);
    1364         for (var row : integers) {
     1364        for (int row : integers) {
    13651365            if (current[0] == Integer.MIN_VALUE) {
    13661366                current[0] = row;
     
    13971397    @SuppressWarnings("ThreadPriorityCheck")
    13981398    public static ForkJoinPool newForkJoinPool(String pref, final String nameFormat, final int threadPriority) {
    1399         final var noThreads = Config.getPref().getInt(pref, Runtime.getRuntime().availableProcessors());
     1399        final int noThreads = Config.getPref().getInt(pref, Runtime.getRuntime().availableProcessors());
    14001400        return new ForkJoinPool(noThreads, new ForkJoinPool.ForkJoinWorkerThreadFactory() {
    14011401            final AtomicLong count = new AtomicLong(0);
     
    14671467        if (value != null) {
    14681468            try {
    1469                 var old = System.setProperty(key, value);
     1469                String old = System.setProperty(key, value);
    14701470                if (Logging.isDebugEnabled() && !value.equals(old)) {
    14711471                    if (!key.toLowerCase(Locale.ENGLISH).contains("password")) {
     
    14931493     */
    14941494    public static boolean hasExtension(String filename, String... extensions) {
    1495         var name = filename.toLowerCase(Locale.ENGLISH).replace("?format=raw", "");
     1495        String name = filename.toLowerCase(Locale.ENGLISH).replace("?format=raw", "");
    14961496        return Arrays.stream(extensions)
    14971497                .anyMatch(ext -> name.endsWith('.' + ext.toLowerCase(Locale.ENGLISH)));
     
    15161516     * @return byte array of data in input stream (empty if stream is null)
    15171517     * @throws IOException if any I/O error occurs
    1518      */
     1518     * @deprecated since xxx -- use {@link InputStream#readAllBytes()} instead
     1519     */
     1520    @Deprecated
    15191521    public static byte[] readBytesFromStream(InputStream stream) throws IOException {
    1520         // TODO: remove this method when switching to Java 11 and use InputStream.readAllBytes
    15211522        if (stream == null) {
    15221523            return new byte[0];
    15231524        }
    1524         try (stream; var bout = new ByteArrayOutputStream(stream.available())) {
    1525             final var buffer = new byte[8192];
    1526             var finished = false;
    1527             do {
    1528                 var read = stream.read(buffer);
    1529                 if (read >= 0) {
    1530                     bout.write(buffer, 0, read);
    1531                 } else {
    1532                     finished = true;
    1533                 }
    1534             } while (!finished);
    1535             if (bout.size() == 0)
    1536                 return new byte[0];
    1537             return bout.toByteArray();
    1538         }
     1525        return stream.readAllBytes();
    15391526    }
    15401527
     
    16001587     */
    16011588    public static List<GlyphVector> getGlyphVectorsBidi(String string, Font font, FontRenderContext frc) {
    1602         final var gvs = new ArrayList<GlyphVector>();
    1603         final var bidi = new Bidi(string, Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
    1604         final var levels = new byte[bidi.getRunCount()];
    1605         final var dirStrings = new DirectionString[levels.length];
    1606         for (var i = 0; i < levels.length; ++i) {
     1589        final List<GlyphVector> gvs = new ArrayList<>();
     1590        final Bidi bidi = new Bidi(string, Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
     1591        final byte[] levels = new byte[bidi.getRunCount()];
     1592        final DirectionString[] dirStrings = new DirectionString[levels.length];
     1593        for (int i = 0; i < levels.length; ++i) {
    16071594            levels[i] = (byte) bidi.getRunLevel(i);
    1608             final var substr = string.substring(bidi.getRunStart(i), bidi.getRunLimit(i));
    1609             final var dir = levels[i] % 2 == 0 ? Bidi.DIRECTION_LEFT_TO_RIGHT : Bidi.DIRECTION_RIGHT_TO_LEFT;
     1595            final String substr = string.substring(bidi.getRunStart(i), bidi.getRunLimit(i));
     1596            final int dir = levels[i] % 2 == 0 ? Bidi.DIRECTION_LEFT_TO_RIGHT : Bidi.DIRECTION_RIGHT_TO_LEFT;
    16101597            dirStrings[i] = new DirectionString(dir, substr);
    16111598        }
    16121599        Bidi.reorderVisually(levels, 0, dirStrings, 0, levels.length);
    1613         for (var dirString : dirStrings) {
    1614             var chars = dirString.str.toCharArray();
     1600        for (DirectionString dirString : dirStrings) {
     1601            final char[] chars = dirString.str.toCharArray();
    16151602            gvs.add(font.layoutGlyphVector(frc, chars, 0, chars.length, dirString.direction));
    16161603        }
     
    17091696    public static int getJavaVersion() {
    17101697        // Switch to Runtime.version() once we move past Java 8
    1711         var version = Objects.requireNonNull(getSystemProperty("java.version"));
     1698        String version = Objects.requireNonNull(getSystemProperty("java.version"));
    17121699        if (version.startsWith("1.")) {
    17131700            version = version.substring(2);
     
    17181705        // 9
    17191706        // 9.0.1
    1720         var dotPos = version.indexOf('.');
    1721         var dashPos = version.indexOf('-');
     1707        int dotPos = version.indexOf('.');
     1708        int dashPos = version.indexOf('-');
    17221709        return Integer.parseInt(version.substring(0,
    17231710                dotPos > -1 ? dotPos : dashPos > -1 ? dashPos : version.length()));
     
    17311718    public static int getJavaUpdate() {
    17321719        // Switch to Runtime.version() once we move past Java 8
    1733         var version = Objects.requireNonNull(getSystemProperty("java.version"));
     1720        String version = Objects.requireNonNull(getSystemProperty("java.version"));
    17341721        if (version.startsWith("1.")) {
    17351722            version = version.substring(2);
     
    17421729        // 17.0.4.1+1-LTS
    17431730        // $MAJOR.$MINOR.$SECURITY.$PATCH
    1744         var undePos = version.indexOf('_');
    1745         var dashPos = version.indexOf('-');
     1731        int undePos = version.indexOf('_');
     1732        int dashPos = version.indexOf('-');
    17461733        if (undePos > -1) {
    17471734            return Integer.parseInt(version.substring(undePos + 1,
    17481735                    dashPos > -1 ? dashPos : version.length()));
    17491736        }
    1750         var firstDotPos = version.indexOf('.');
    1751         var secondDotPos = version.indexOf('.', firstDotPos + 1);
     1737        int firstDotPos = version.indexOf('.');
     1738        int secondDotPos = version.indexOf('.', firstDotPos + 1);
    17521739        if (firstDotPos == secondDotPos) {
    17531740            return 0;
     
    17641751    public static int getJavaBuild() {
    17651752        // Switch to Runtime.version() once we move past Java 8
    1766         var version = Objects.requireNonNull(getSystemProperty("java.runtime.version"));
    1767         var bPos = version.indexOf('b');
    1768         var pPos = version.indexOf('+');
     1753        String version = Objects.requireNonNull(getSystemProperty("java.runtime.version"));
     1754        int bPos = version.indexOf('b');
     1755        int pPos = version.indexOf('+');
    17691756        try {
    17701757            return Integer.parseInt(version.substring(bPos > -1 ? bPos + 1 : pPos + 1));
     
    17831770        try {
    17841771            Object value;
    1785             var c = Class.forName("com.sun.deploy.config.BuiltInProperties");
     1772            Class<?> c = Class.forName("com.sun.deploy.config.BuiltInProperties");
    17861773            try {
    17871774                value = c.getDeclaredField("JRE_EXPIRATION_DATE").get(null);
     
    18071794    public static String getJavaLatestVersion() {
    18081795        try {
    1809             var versions = HttpClient.create(
     1796            String[] versions = HttpClient.create(
    18101797                    new URL(Config.getPref().get(
    18111798                            "java.baseline.version.url",
     
    18131800                    .connect().fetchContent().split("\n", -1);
    18141801            if (getJavaVersion() <= 11 && isRunningWebStart()) { // OpenWebStart currently only has Java 11
    1815                 for (var version : versions) {
     1802                for (String version : versions) {
    18161803                    if (version.startsWith("11")) {
    18171804                        return version;
     
    18191806                }
    18201807            } else if (getJavaVersion() <= 17) {
    1821                 for (var version : versions) {
     1808                for (String version : versions) {
    18221809                    if (version.startsWith("17")) { // Use current Java LTS
    18231810                        return version;
     
    19421929                    return url.openStream();
    19431930                } catch (FileNotFoundException | InvalidPathException e) {
    1944                     final var betterUrl = betterJarUrl(url);
     1931                    final URL betterUrl = betterJarUrl(url);
    19451932                    if (betterUrl != null) {
    19461933                        try {
     
    19791966    public static URL betterJarUrl(URL jarUrl, URL defaultUrl) throws IOException {
    19801967        // Workaround to https://bugs.openjdk.java.net/browse/JDK-4523159
    1981         var urlPath = jarUrl.getPath().replace("%20", " ");
     1968        String urlPath = jarUrl.getPath().replace("%20", " ");
    19821969        if (urlPath.startsWith("file:/") && urlPath.split("!", -1).length > 2) {
    19831970            // Locate jar file
    1984             var index = urlPath.lastIndexOf("!/");
    1985             final var jarFile = Paths.get(urlPath.substring("file:/".length(), index));
    1986             var filename = jarFile.getFileName();
    1987             var jarTime = Files.readAttributes(jarFile, BasicFileAttributes.class).lastModifiedTime();
     1971            int index = urlPath.lastIndexOf("!/");
     1972            final Path jarFile = Paths.get(urlPath.substring("file:/".length(), index));
     1973            Path filename = jarFile.getFileName();
     1974            FileTime jarTime = Files.readAttributes(jarFile, BasicFileAttributes.class).lastModifiedTime();
    19881975            // Copy it to temp directory (hopefully free of exclamation mark) if needed (missing or older jar)
    1989             final var jarCopy = Paths.get(getSystemProperty("java.io.tmpdir")).resolve(filename);
     1976            final Path jarCopy = Paths.get(getSystemProperty("java.io.tmpdir")).resolve(filename);
    19901977            if (!jarCopy.toFile().exists() ||
    19911978                    Files.readAttributes(jarCopy, BasicFileAttributes.class).lastModifiedTime().compareTo(jarTime) < 0) {
     
    20262013            Logging.trace(e);
    20272014            try {
    2028                 final var betterUrl = betterJarUrl(cl.getResource(path));
     2015                final URL betterUrl = betterJarUrl(cl.getResource(path));
    20292016                if (betterUrl != null) {
    20302017                    return betterUrl.openStream();
Note: See TracChangeset for help on using the changeset viewer.