Ignore:
Timestamp:
2017-07-30T00:22:46+02:00 (3 years ago)
Author:
Don-vip
Message:

PMD - VariableNamingConventions

Location:
trunk/src/org/openstreetmap/josm/data
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/data/Preferences.java

    r12409 r12537  
    14571457            throw new IllegalArgumentException(ex);
    14581458        }
    1459         for (Entry<String, String> key_value : hash.entrySet()) {
     1459        for (Entry<String, String> keyValue : hash.entrySet()) {
    14601460            Object value;
    14611461            Field f;
    14621462            try {
    1463                 f = klass.getDeclaredField(key_value.getKey().replace('-', '_'));
     1463                f = klass.getDeclaredField(keyValue.getKey().replace('-', '_'));
    14641464            } catch (NoSuchFieldException ex) {
    14651465                Main.trace(ex);
     
    14711471            Utils.setObjectsAccessible(f);
    14721472            if (f.getType() == Boolean.class || f.getType() == boolean.class) {
    1473                 value = Boolean.valueOf(key_value.getValue());
     1473                value = Boolean.valueOf(keyValue.getValue());
    14741474            } else if (f.getType() == Integer.class || f.getType() == int.class) {
    14751475                try {
    1476                     value = Integer.valueOf(key_value.getValue());
     1476                    value = Integer.valueOf(keyValue.getValue());
    14771477                } catch (NumberFormatException nfe) {
    14781478                    continue;
     
    14801480            } else if (f.getType() == Double.class || f.getType() == double.class) {
    14811481                try {
    1482                     value = Double.valueOf(key_value.getValue());
     1482                    value = Double.valueOf(keyValue.getValue());
    14831483                } catch (NumberFormatException nfe) {
    14841484                    continue;
    14851485                }
    14861486            } else if (f.getType() == String.class) {
    1487                 value = key_value.getValue();
     1487                value = keyValue.getValue();
    14881488            } else if (f.getType().isAssignableFrom(Map.class)) {
    1489                 value = mapFromJson(key_value.getValue());
     1489                value = mapFromJson(keyValue.getValue());
    14901490            } else if (f.getType().isAssignableFrom(MultiMap.class)) {
    1491                 value = multiMapFromJson(key_value.getValue());
     1491                value = multiMapFromJson(keyValue.getValue());
    14921492            } else
    14931493                throw new JosmRuntimeException("unsupported preference primitive type");
  • trunk/src/org/openstreetmap/josm/data/SystemOfMeasurement.java

    r11553 r12537  
    8080    }
    8181
    82     private static final CopyOnWriteArrayList<SoMChangeListener> somChangeListeners = new CopyOnWriteArrayList<>();
     82    private static final CopyOnWriteArrayList<SoMChangeListener> SOM_CHANGE_LISTENERS = new CopyOnWriteArrayList<>();
    8383
    8484    /**
     
    8989     */
    9090    public static void removeSoMChangeListener(SoMChangeListener listener) {
    91         somChangeListeners.remove(listener);
     91        SOM_CHANGE_LISTENERS.remove(listener);
    9292    }
    9393
     
    100100    public static void addSoMChangeListener(SoMChangeListener listener) {
    101101        if (listener != null) {
    102             somChangeListeners.addIfAbsent(listener);
     102            SOM_CHANGE_LISTENERS.addIfAbsent(listener);
    103103        }
    104104    }
    105105
    106106    protected static void fireSoMChanged(String oldSoM, String newSoM) {
    107         for (SoMChangeListener l : somChangeListeners) {
     107        for (SoMChangeListener l : SOM_CHANGE_LISTENERS) {
    108108            l.systemOfMeasurementChanged(oldSoM, newSoM);
    109109        }
  • trunk/src/org/openstreetmap/josm/data/cache/JCSCacheManager.java

    r11746 r12537  
    4848    public static final BooleanProperty USE_BLOCK_CACHE = new BooleanProperty(PREFERENCE_PREFIX + ".use_block_cache", true);
    4949
    50     private static final AuxiliaryCacheFactory diskCacheFactory =
     50    private static final AuxiliaryCacheFactory DISK_CACHE_FACTORY =
    5151            USE_BLOCK_CACHE.get() ? new BlockDiskCacheFactory() : new IndexedDiskCacheFactory();
    5252    private static FileLock cacheDirLock;
     
    177177            try {
    178178                if (cc.getAuxCaches().length == 0) {
    179                     AuxiliaryCache<K, V> diskCache = diskCacheFactory.createCache(diskAttributes, cacheManager, null, new StandardSerializer());
    180                     cc.setAuxCaches(new AuxiliaryCache[]{diskCache});
     179                    cc.setAuxCaches(new AuxiliaryCache[]{DISK_CACHE_FACTORY.createCache(
     180                            diskAttributes, cacheManager, null, new StandardSerializer())});
    181181                }
    182182            } catch (IOException e) {
  • trunk/src/org/openstreetmap/josm/data/cache/JCSCachedTileLoaderJob.java

    r11958 r12537  
    8181
    8282
    83     private static final ConcurrentMap<String, Set<ICachedLoaderListener>> inProgress = new ConcurrentHashMap<>();
    84     private static final ConcurrentMap<String, Boolean> useHead = new ConcurrentHashMap<>();
     83    private static final ConcurrentMap<String, Set<ICachedLoaderListener>> IN_PROGRESS = new ConcurrentHashMap<>();
     84    private static final ConcurrentMap<String, Boolean> USE_HEAD = new ConcurrentHashMap<>();
    8585
    8686    protected final long now; // when the job started
     
    162162            throw new IllegalArgumentException("No url returned");
    163163        }
    164         synchronized (inProgress) {
    165             Set<ICachedLoaderListener> newListeners = inProgress.get(deduplicationKey);
     164        synchronized (IN_PROGRESS) {
     165            Set<ICachedLoaderListener> newListeners = IN_PROGRESS.get(deduplicationKey);
    166166            if (newListeners == null) {
    167167                newListeners = new HashSet<>();
    168                 inProgress.put(deduplicationKey, newListeners);
     168                IN_PROGRESS.put(deduplicationKey, newListeners);
    169169                first = true;
    170170            }
     
    259259    private void finishLoading(LoadResult result) {
    260260        Set<ICachedLoaderListener> listeners;
    261         synchronized (inProgress) {
     261        synchronized (IN_PROGRESS) {
    262262            try {
    263                 listeners = inProgress.remove(getUrl().toString());
     263                listeners = IN_PROGRESS.remove(getUrl().toString());
    264264            } catch (IOException e) {
    265265                listeners = null;
     
    312312            // then just use HEAD request and check returned values
    313313            if (isObjectLoadable() &&
    314                     Boolean.TRUE.equals(useHead.get(getServerKey())) &&
     314                    Boolean.TRUE.equals(USE_HEAD.get(getServerKey())) &&
    315315                    isCacheValidUsingHead()) {
    316316                LOG.log(Level.FINE, "JCS - cache entry verified using HEAD request: {0}", getUrl());
     
    346346                LOG.log(Level.INFO, "JCS - Host: {0} found not to return 304 codes for If-Modified-Since or If-None-Match headers",
    347347                        serverKey);
    348                 useHead.put(serverKey, Boolean.TRUE);
     348                USE_HEAD.put(serverKey, Boolean.TRUE);
    349349            }
    350350
  • trunk/src/org/openstreetmap/josm/data/imagery/TMSCachedTileLoaderJob.java

    r11858 r12537  
    5151    // we need another deduplication of Tile Loader listeners, as for each submit, new TMSCachedTileLoaderJob was created
    5252    // that way, we reduce calls to tileLoadingFinished, and general CPU load due to surplus Map repaints
    53     private static final ConcurrentMap<String, Set<TileLoaderListener>> inProgress = new ConcurrentHashMap<>();
     53    private static final ConcurrentMap<String, Set<TileLoaderListener>> IN_PROGRESS = new ConcurrentHashMap<>();
    5454
    5555    /**
     
    7171        if (listener != null) {
    7272            String deduplicationKey = getCacheKey();
    73             synchronized (inProgress) {
    74                 Set<TileLoaderListener> newListeners = inProgress.get(deduplicationKey);
     73            synchronized (IN_PROGRESS) {
     74                Set<TileLoaderListener> newListeners = IN_PROGRESS.get(deduplicationKey);
    7575                if (newListeners == null) {
    7676                    newListeners = new HashSet<>();
    77                     inProgress.put(deduplicationKey, newListeners);
     77                    IN_PROGRESS.put(deduplicationKey, newListeners);
    7878                }
    7979                newListeners.add(listener);
     
    162162        this.attributes = attributes; // as we might get notification from other object than our selfs, pass attributes along
    163163        Set<TileLoaderListener> listeners;
    164         synchronized (inProgress) {
    165             listeners = inProgress.remove(getCacheKey());
     164        synchronized (IN_PROGRESS) {
     165            listeners = IN_PROGRESS.remove(getCacheKey());
    166166        }
    167167        boolean status = result.equals(LoadResult.SUCCESS);
  • trunk/src/org/openstreetmap/josm/data/imagery/TemplatedWMSTileSource.java

    r11860 r12537  
    4545    // CHECKSTYLE.ON: SingleSpaceSeparator
    4646
    47     private static final NumberFormat latLonFormat = new DecimalFormat("###0.0000000", new DecimalFormatSymbols(Locale.US));
     47    private static final NumberFormat LATLON_FORMAT = new DecimalFormat("###0.0000000", new DecimalFormatSymbols(Locale.US));
    4848
    4949    private static final Pattern[] ALL_PATTERNS = {
     
    111111        String bbox;
    112112        if (switchLatLon) {
    113             bbox = String.format("%s,%s,%s,%s", latLonFormat.format(s), latLonFormat.format(w), latLonFormat.format(n), latLonFormat.format(e));
     113            bbox = String.format("%s,%s,%s,%s",
     114                    LATLON_FORMAT.format(s), LATLON_FORMAT.format(w), LATLON_FORMAT.format(n), LATLON_FORMAT.format(e));
    114115        } else {
    115             bbox = String.format("%s,%s,%s,%s", latLonFormat.format(w), latLonFormat.format(s), latLonFormat.format(e), latLonFormat.format(n));
     116            bbox = String.format("%s,%s,%s,%s",
     117                    LATLON_FORMAT.format(w), LATLON_FORMAT.format(s), LATLON_FORMAT.format(e), LATLON_FORMAT.format(n));
    116118        }
    117119
     
    132134                break;
    133135            case "w":
    134                 replacement = latLonFormat.format(w);
     136                replacement = LATLON_FORMAT.format(w);
    135137                break;
    136138            case "s":
    137                 replacement = latLonFormat.format(s);
     139                replacement = LATLON_FORMAT.format(s);
    138140                break;
    139141            case "e":
    140                 replacement = latLonFormat.format(e);
     142                replacement = LATLON_FORMAT.format(e);
    141143                break;
    142144            case "n":
    143                 replacement = latLonFormat.format(n);
     145                replacement = LATLON_FORMAT.format(n);
    144146                break;
    145147            case "width":
  • trunk/src/org/openstreetmap/josm/data/osm/ChangesetCache.java

    r11349 r12537  
    3737public final class ChangesetCache implements PreferenceChangedListener {
    3838    /** the unique instance */
    39     private static final ChangesetCache instance = new ChangesetCache();
     39    private static final ChangesetCache INSTANCE = new ChangesetCache();
    4040
    4141    /** the cached changesets */
     
    5656     */
    5757    public static ChangesetCache getInstance() {
    58         return instance;
     58        return INSTANCE;
    5959    }
    6060
  • trunk/src/org/openstreetmap/josm/data/osm/DataSet.java

    r12479 r12537  
    638638     * dataset. (However, the selection does only change in the active layer)
    639639     */
    640     private static final Collection<SelectionChangedListener> selListeners = new CopyOnWriteArrayList<>();
     640    private static final Collection<SelectionChangedListener> SEL_LISTENERS = new CopyOnWriteArrayList<>();
    641641
    642642    /**
     
    647647     */
    648648    public static void addSelectionListener(SelectionChangedListener listener) {
    649         ((CopyOnWriteArrayList<SelectionChangedListener>) selListeners).addIfAbsent(listener);
     649        ((CopyOnWriteArrayList<SelectionChangedListener>) SEL_LISTENERS).addIfAbsent(listener);
    650650    }
    651651
     
    657657     */
    658658    public static void removeSelectionListener(SelectionChangedListener listener) {
    659         selListeners.remove(listener);
     659        SEL_LISTENERS.remove(listener);
    660660    }
    661661
     
    671671
    672672    private static void fireDreprecatedSelectionChange(Collection<? extends OsmPrimitive> currentSelection) {
    673         for (SelectionChangedListener l : selListeners) {
     673        for (SelectionChangedListener l : SEL_LISTENERS) {
    674674            l.selectionChanged(currentSelection);
    675675        }
  • trunk/src/org/openstreetmap/josm/data/osm/QuadBuckets.java

    r12122 r12537  
    2323 */
    2424public class QuadBuckets<T extends OsmPrimitive> implements Collection<T> {
    25     private static final boolean consistency_testing = false;
     25    private static final boolean CONSISTENCY_TESTING = false;
    2626    private static final byte NW_INDEX = 1;
    2727    private static final byte NE_INDEX = 3;
     
    271271
    272272        void doAdd(T o) {
    273             if (consistency_testing) {
     273            if (CONSISTENCY_TESTING) {
    274274                if (o instanceof Node && !matches(o, this)) {
    275275                    o.getBBox().getIndex(level);
  • trunk/src/org/openstreetmap/josm/data/osm/User.java

    r11912 r12537  
    3434     * @see #getAnonymous()
    3535     */
    36     private static final User anonymous = createLocalUser(tr("<anonymous>"));
     36    private static final User ANONYMOUS = createLocalUser(tr("<anonymous>"));
    3737
    3838    private static long getNextLocalUid() {
     
    131131     */
    132132    public static User getAnonymous() {
    133         return anonymous;
     133        return ANONYMOUS;
    134134    }
    135135
  • trunk/src/org/openstreetmap/josm/data/osm/event/DatasetEventManager.java

    r11928 r12537  
    2929public class DatasetEventManager implements ActiveLayerChangeListener, Listener {
    3030
    31     private static final DatasetEventManager instance = new DatasetEventManager();
     31    private static final DatasetEventManager INSTANCE = new DatasetEventManager();
    3232
    3333    private final class EdtRunnable implements Runnable {
     
    139139     */
    140140    public static DatasetEventManager getInstance() {
    141         return instance;
     141        return INSTANCE;
    142142    }
    143143
  • trunk/src/org/openstreetmap/josm/data/osm/event/SelectionEventManager.java

    r12116 r12537  
    3232public class SelectionEventManager implements DataSelectionListener, ActiveLayerChangeListener {
    3333
    34     private static final SelectionEventManager instance = new SelectionEventManager();
     34    private static final SelectionEventManager INSTANCE = new SelectionEventManager();
    3535
    3636    /**
     
    3939     */
    4040    public static SelectionEventManager getInstance() {
    41         return instance;
     41        return INSTANCE;
    4242    }
    4343
  • trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/PaintColors.java

    r12376 r12537  
    9393    private static volatile Color backgroundColorCache;
    9494
    95     private static final MapPaintSylesUpdateListener styleOverrideListener = new MapPaintSylesUpdateListener() {
     95    private static final MapPaintSylesUpdateListener STYLE_OVERRIDE_LISTENER = new MapPaintSylesUpdateListener() {
    9696        //TODO: Listen to wireframe map mode changes.
    9797        @Override
     
    107107
    108108    static {
    109         MapPaintStyles.addMapPaintSylesUpdateListener(styleOverrideListener);
     109        MapPaintStyles.addMapPaintSylesUpdateListener(STYLE_OVERRIDE_LISTENER);
    110110    }
    111111
  • trunk/src/org/openstreetmap/josm/data/validation/OsmValidator.java

    r12390 r12537  
    7979    private static double griddetail;
    8080
    81     private static final Collection<String> ignoredErrors = new TreeSet<>();
     81    private static final Collection<String> IGNORED_ERRORS = new TreeSet<>();
    8282
    8383    /**
    8484     * All registered tests
    8585     */
    86     private static final Collection<Class<? extends Test>> allTests = new ArrayList<>();
    87     private static final Map<String, Test> allTestsMap = new HashMap<>();
     86    private static final Collection<Class<? extends Test>> ALL_TESTS = new ArrayList<>();
     87    private static final Map<String, Test> ALL_TESTS_MAP = new HashMap<>();
    8888
    8989    /**
     
    139139     */
    140140    public static void addTest(Class<? extends Test> testClass) {
    141         allTests.add(testClass);
     141        ALL_TESTS.add(testClass);
    142142        try {
    143             allTestsMap.put(testClass.getName(), testClass.getConstructor().newInstance());
     143            ALL_TESTS_MAP.put(testClass.getName(), testClass.getConstructor().newInstance());
    144144        } catch (ReflectiveOperationException e) {
    145145            Main.error(e);
     
    182182
    183183    private static void loadIgnoredErrors() {
    184         ignoredErrors.clear();
     184        IGNORED_ERRORS.clear();
    185185        if (ValidatorPreference.PREF_USE_IGNORE.get()) {
    186186            Path path = Paths.get(getValidatorDir()).resolve("ignorederrors");
    187187            if (path.toFile().exists()) {
    188188                try {
    189                     ignoredErrors.addAll(Files.readAllLines(path, StandardCharsets.UTF_8));
     189                    IGNORED_ERRORS.addAll(Files.readAllLines(path, StandardCharsets.UTF_8));
    190190                } catch (final FileNotFoundException e) {
    191191                    Main.debug(Main.getErrorMessage(e));
     
    204204     */
    205205    public static void addIgnoredError(String s) {
    206         ignoredErrors.add(s);
     206        IGNORED_ERRORS.add(s);
    207207    }
    208208
     
    213213     */
    214214    public static boolean hasIgnoredError(String s) {
    215         return ignoredErrors.contains(s);
     215        return IGNORED_ERRORS.contains(s);
    216216    }
    217217
     
    221221    public static void saveIgnoredErrors() {
    222222        try (PrintWriter out = new PrintWriter(new File(getValidatorDir(), "ignorederrors"), StandardCharsets.UTF_8.name())) {
    223             for (String e : ignoredErrors) {
     223            for (String e : IGNORED_ERRORS) {
    224224                out.println(e);
    225225            }
     
    254254     */
    255255    public static SortedMap<String, Test> getAllTestsMap() {
    256         applyPrefs(allTestsMap, false);
    257         applyPrefs(allTestsMap, true);
    258         return new TreeMap<>(allTestsMap);
     256        applyPrefs(ALL_TESTS_MAP, false);
     257        applyPrefs(ALL_TESTS_MAP, true);
     258        return new TreeMap<>(ALL_TESTS_MAP);
    259259    }
    260260
     
    271271            return null;
    272272        }
    273         return (T) allTestsMap.get(testClass.getName());
     273        return (T) ALL_TESTS_MAP.get(testClass.getName());
    274274    }
    275275
     
    318318     */
    319319    public static Collection<Class<? extends Test>> getAllAvailableTestClasses() {
    320         return Collections.unmodifiableCollection(allTests);
     320        return Collections.unmodifiableCollection(ALL_TESTS);
    321321    }
    322322
Note: See TracChangeset for help on using the changeset viewer.