Ignore:
Timestamp:
2019-01-20T06:34:14+01:00 (6 years ago)
Author:
gerdp
Message:

fix sonar issues, simplify code, improve readability

Location:
applications/editors/josm/plugins/o5m/src/org/openstreetmap/josm/plugins/o5m
Files:
1 deleted
2 edited

Legend:

Unmodified
Added
Removed
  • applications/editors/josm/plugins/o5m/src/org/openstreetmap/josm/plugins/o5m/io/O5mImporter.java

    r34820 r34842  
    11// License: GPL. For details, see LICENSE file.
    22package org.openstreetmap.josm.plugins.o5m.io;
     3
     4import static org.openstreetmap.josm.tools.I18n.tr;
    35
    46import java.io.IOException;
    57import java.io.InputStream;
    68
     9import org.openstreetmap.josm.actions.ExtensionFileFilter;
    710import org.openstreetmap.josm.data.osm.DataSet;
    811import org.openstreetmap.josm.gui.io.importexport.OsmImporter;
     
    1114import org.openstreetmap.josm.io.IllegalDataException;
    1215import org.openstreetmap.josm.io.CachedFile;
    13 import org.openstreetmap.josm.plugins.o5m.O5mConstants;
    1416
    1517/**
     
    1921 */
    2022public class O5mImporter extends OsmImporter {
    21 
     23    /**
     24     * File extension.
     25     */
     26    private static final String EXTENSION = "o5m";
     27   
    2228    public O5mImporter() {
    23         super(O5mConstants.FILE_FILTER);
     29        super(new ExtensionFileFilter(EXTENSION, EXTENSION,
     30                tr("OSM Server Files o5m compressed") + " (*."+EXTENSION+")"));
    2431    }
    2532
  • applications/editors/josm/plugins/o5m/src/org/openstreetmap/josm/plugins/o5m/io/O5mReader.java

    r34835 r34842  
    2121import org.openstreetmap.josm.data.osm.NodeData;
    2222import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
     23import org.openstreetmap.josm.data.osm.PrimitiveData;
    2324import org.openstreetmap.josm.data.osm.RelationData;
    2425import org.openstreetmap.josm.data.osm.RelationMemberData;
     
    4041 */
    4142public class O5mReader extends AbstractReader {
    42     private IllegalDataException exception = null;
     43    private IllegalDataException exception;
    4344    private boolean discourageUpload;
    4445   
     
    7778    private static final int MAX_STRING_PAIR_SIZE = 250 + 2;
    7879    private static final String[] REL_REF_TYPES = {"node", "way", "relation", "?"};
    79     private static final double FACTOR = 1d/1000000000; // used with 100*<Val>*FACTOR
     80    private static final double FACTOR = 1d/1_000_000_000; // used with 100*<Val>*FACTOR
    8081
    8182    private BufferedInputStream fis;
     
    8687
    8788    private byte[] ioBuf;
    88     private int ioPos;
     89    private int ioBufPos;
    8990    // the o5m string table
    9091    private String[][] stringTable;
     
    114115        this.cnvBuffer = new byte[4000]; // OSM data should not contain string pairs with length > 512
    115116        this.ioBuf = new byte[8192];
    116         this.ioPos = 0;
     117        this.ioBufPos = 0;
    117118        this.stringPair = new String[2];
    118119        this.lastRef = new long[3];
     
    166167                case TIMESTAMP_DATASET:
    167168                case HEADER_DATASET:
    168                     if (bytesToRead > ioBuf.length) {
    169                         ioBuf = new byte[bytesToRead+100];
    170                     }
    171                     int bytesRead = 0;
    172                     int neededBytes = bytesToRead;
    173                     while (neededBytes > 0) {
    174                         bytesRead += is.read(ioBuf, bytesRead, neededBytes);
    175                         neededBytes -= bytesRead;
    176                     }
    177                     ioPos = 0;
    178                     is = new ByteArrayInputStream(ioBuf, 0, bytesToRead);
     169                    is = fillByteArray();
    179170                    break;                   
    180171                default: break;   
     
    196187    }
    197188
     189    private InputStream fillByteArray() throws IOException {
     190        if (bytesToRead > ioBuf.length) {
     191            ioBuf = new byte[bytesToRead + 100];
     192        }
     193        int bytesRead = 0;
     194        int neededBytes = bytesToRead;
     195        while (neededBytes > 0) {
     196            bytesRead += is.read(ioBuf, bytesRead, neededBytes);
     197            neededBytes -= bytesRead;
     198        }
     199        ioBufPos = 0;
     200        return new ByteArrayInputStream(ioBuf, 0, bytesToRead);
     201    }
     202
    198203    /**
    199204     * read (and ignore) the file timestamp data set
     
    230235        } else {
    231236            Logging.error("Invalid Bounds: " + b);
     237        }
     238    }
     239
     240    private void setMeta(PrimitiveData pd) throws IllegalDataException {
     241        pd.setVersion(version == 0 ? 1 : version);
     242        checkChangesetId(lastChangeSet);
     243        pd.setChangesetId((int) lastChangeSet);
     244        // User id
     245        if (lastTs != 0) {
     246            checkTimestamp(lastTs);
     247            pd.setTimestamp(new Date(lastTs * 1000));
     248            if (osmUser != null)
     249                pd.setUser(osmUser);
    232250        }
    233251    }
     
    257275                discourageUpload = true;
    258276            NodeData nd = new NodeData(lastNodeId);
    259             nd.setVersion(version == 0 ? 1 : version);
    260277            nd.setCoor(new LatLon(flat, flon).getRoundedToOsmPrecision());
    261 
    262278            checkCoordinates(nd.getCoor());
    263             checkChangesetId(lastChangeSet);
    264             nd.setChangesetId((int) lastChangeSet);
    265             // User id
    266             if (lastTs != 0) {
    267                 checkTimestamp(lastTs);
    268                 nd.setTimestamp(new Date(lastTs * 1000));
    269                 if (osmUser != null)
    270                     nd.setUser(osmUser);
    271             }
     279            setMeta(nd);
     280
    272281            if (bytesToRead > 0) {
    273282                Map<String, String> keys = readTags();
     
    279288            exception = e;
    280289        }
    281 
    282290    }
    283291
     
    299307                discourageUpload = true;
    300308            final WayData wd = new WayData(lastWayId);
    301             wd.setVersion(version == 0 ? 1 : version);
    302             checkChangesetId(lastChangeSet);
    303             wd.setChangesetId((int) lastChangeSet);
    304             // User id
    305             if (lastTs != 0) {
    306                 checkTimestamp(lastTs);
    307                 wd.setTimestamp(new Date(lastTs * 1000));
    308                 if (osmUser != null)
    309                     wd.setUser(osmUser);
    310             }
     309            setMeta(wd);
    311310
    312311            long refSize = readUnsignedNum32();
     
    345344                discourageUpload = true;
    346345            final RelationData rel = new RelationData(lastRelId);
    347             rel.setVersion(version == 0 ? 1 : version);
    348             checkChangesetId(lastChangeSet);
    349             rel.setChangesetId((int) lastChangeSet);
    350             if (lastTs != 0) {
    351                 checkTimestamp(lastTs);
    352                 rel.setTimestamp(new Date(lastTs * 1000));
    353                 if (osmUser != null)
    354                     rel.setUser(osmUser);
    355             }
     346            setMeta(rel);
    356347
    357348            long refSize = readUnsignedNum32();
     
    447438                stringPair[0] = "";
    448439            else {
    449                 stringPair[0] = Long.toString(uidNum);
    450                 ioPos++; // skip terminating zero from uid
     440                stringPair[0] = Long.toUnsignedString(uidNum);
     441                ioBufPos++; // skip terminating zero from uid
    451442                --bytesToRead;
    452443            }
     
    455446            stringPair[1] = null;
    456447            while (stringPair[1] == null) {
    457                 final int b = ioBuf[ioPos++];
     448                final int b = ioBuf[ioBufPos++];
    458449                --bytesToRead;
    459450                cnvBuffer[buffPos++] = (byte) b;
     
    483474        int stringRef = readUnsignedNum32();
    484475        if (stringRef == 0) {
    485             refType = ioBuf[ioPos++] - 0x30;
     476            refType = ioBuf[ioBufPos++] - 0x30;
    486477            --bytesToRead;
    487478
     
    494485            stringPair[1] = null;
    495486            while (stringPair[1] == null) {
    496                 final int b = ioBuf[ioPos++];
     487                final int b = ioBuf[ioBufPos++];
    497488                --bytesToRead;
    498489                cnvBuffer[buffPos++] = (byte) b;
     
    528519            int start = 0;
    529520            while (cnt < 2) {
    530                 final int b = ioBuf[ioPos++];
     521                final int b = ioBuf[ioBufPos++];
    531522                --bytesToRead;
    532523                cnvBuffer[buffPos++] = (byte) b;
     
    571562     */
    572563    private int readSignedNum32() {
    573         int result;
    574         int b = ioBuf[ioPos++];
    575         --bytesToRead;
    576         result = b;
    577         if ((b & 0x80) == 0) {  // just one byte
    578             if ((b & 0x01) == 1)
    579                 return -1-(result >> 1);
    580             return result >> 1;
    581         }
    582         int sign = b & 0x01;
    583         result = (result & 0x7e) >> 1;
    584         int shift = 6;
    585         while (((b = ioBuf[ioPos++]) & 0x80) != 0) { // more bytes will follow
    586             --bytesToRead;
    587             result += (b & 0x7f) << shift;
    588             shift += 7;
    589         }
    590         --bytesToRead;
    591         result += b << shift;
    592         if (sign == 1) // negative
    593             return -1 - result;
    594         return result;
    595 
     564        return (int) readSignedNum64();
    596565    }
    597566
     
    602571    private long readSignedNum64() {
    603572        long result;
    604         int b = ioBuf[ioPos++];
     573        int b = ioBuf[ioBufPos++];
    605574        --bytesToRead;
    606575        result = b;
     
    613582        result = (result & 0x7e) >> 1;
    614583        int shift = 6;
    615         while (((b = ioBuf[ioPos++]) & 0x80) != 0) { // more bytes will follow
     584        while (((b = ioBuf[ioBufPos++]) & 0x80) != 0) { // more bytes will follow
    616585            --bytesToRead;
    617586            result += ((long) (b & 0x7f)) << shift;
     
    655624     */
    656625    private long readUnsignedNum64() {
    657         int b = ioBuf[ioPos++];
     626        int b = ioBuf[ioBufPos++];
    658627        --bytesToRead;
    659628        long result = b;
     
    663632        result &= 0x7f;
    664633        int shift = 7;
    665         while (((b = ioBuf[ioPos++]) & 0x80) != 0) { // more bytes will follow
     634        while (((b = ioBuf[ioBufPos++]) & 0x80) != 0) { // more bytes will follow
    666635            --bytesToRead;
    667636            result += ((long) (b & 0x7f)) << shift;
     
    675644    /**
    676645     * read a varying length unsigned number (see o5m definition)
    677      * is similar to the 64 bit version.
    678646     * @return the number as int
    679647     */
    680648    private int readUnsignedNum32() {
    681         int b = ioBuf[ioPos++];
    682         --bytesToRead;
    683         int result = b;
    684         if ((b & 0x80) == 0) {  // just one byte
    685             return result;
    686         }
    687         result &= 0x7f;
    688         int shift = 7;
    689         while (((b = ioBuf[ioPos++]) & 0x80) != 0) { // more bytes will follow
    690             --bytesToRead;
    691             result += (b & 0x7f) << shift;
    692             shift += 7;
    693         }
    694         --bytesToRead;
    695         result += b << shift;
    696         return result;
     649        return (int) readUnsignedNum64();
    697650    }
    698651
     
    700653     * Exception thrown after user cancellation.
    701654     */
    702     @SuppressWarnings("serial")
    703655    private static final class O5mParsingCancelException extends Exception implements ImportCancelException {
     656        private static final long serialVersionUID = 1L;
     657
    704658        O5mParsingCancelException(String msg) {
    705659            super(msg);
Note: See TracChangeset for help on using the changeset viewer.