Fixed minor JavaDoc issues

Author: rijnb

src/main/java/com/mapcode/Alphabet.java

@@ -23,7 +23,7 @@
 /**
  * This enum defines all alphabets supported for mapcodes. Note that an alphabet is different from a
  * language or locale. An alternative name for an alphabet is "script".
- * <p/>
+ *
  * Mapcodes can be safely converted between alphabets and fed to the mapcode decoder in the regular
  * ASCII Roman alphabet or any other.
  */

src/main/java/com/mapcode/Boundary.java

@@ -22,7 +22,7 @@
  * ----------------------------------------------------------------------------------------------
  * Package private implementation class. For internal use within the mapcode implementation only.
  * ----------------------------------------------------------------------------------------------
- * <p/>
+ *
  * This class handles territory rectangles for mapcodes.
  */
 class Boundary {
@@ -83,7 +83,7 @@ Boundary extendBoundary(final int latMicroDegExtension, final int lonMicroDegExt
     /**
      * Check if a point falls within a boundary. Note that the "min" values are inclusive for a boundary and
      * the "max" values are exclusive.\
-     * <p/>
+     *
      * Note: Points at the exact North pole with latitude 90 are never part of a boundary.
      *
      * @param p Point to check.

src/main/java/com/mapcode/Common.java

@@ -20,7 +20,7 @@
  * ----------------------------------------------------------------------------------------------
  * Package private implementation class. For internal use within the Mapcode implementation only.
  * ----------------------------------------------------------------------------------------------
- * <p/>
+ *
  * This class contains common data structures and methods used by the Mapcode implementation.
  */
 class Common {

src/main/java/com/mapcode/Data.java

@@ -22,7 +22,7 @@
  * ----------------------------------------------------------------------------------------------
  * Package private implementation class. For internal use within the Mapcode implementation only.
  * ----------------------------------------------------------------------------------------------
- * <p/>
+ *
  * This class the data class for Mapcode codex items.
  */
 class Data {

src/main/java/com/mapcode/DataAccess.java

@@ -27,7 +27,7 @@
  * ----------------------------------------------------------------------------------------------
  * Package private implementation class. For internal use within the Mapcode implementation only.
  * ----------------------------------------------------------------------------------------------
- * <p/>
+ *
  * This class contains the module that reads the Mapcode areas into memory and processes them.
  */
 class DataAccess {

src/main/java/com/mapcode/Mapcode.java

@@ -28,27 +28,27 @@
 /**
  * This class defines a single mapcode encoding result, including the alphanumeric code and the
  * territory definition.
- * <p/>
+ *
  * On terminology, mapcode territory and mapcode code:
- * <p/>
+ *
  * In written form. a mapcode is defined as an alphanumeric code, optionally preceded by a
  * territory code.
- * <p/>
+ *
  * For example: "NLD 49.4V" is a mapcode, but "49.4V" is a mapcode as well, The latter is called
  * a "local" mapcode, because it is not internationally unambiguous unless preceded by a territory
  * code.
- * <p/>
+ *
  * For "NLD 49.4V" the "NLD"-part is called "the territory" and the "49.4V"-part is called
  * "the code" (which are both part of "the mapcode").
- * <p/>
+ *
  * This distinction between "territory" and "code" in a mapcode is why the interface of this class
  * has been changed from version 1.50.0 to reflect this terminology.
- * <p/>
+ *
  * On alphabets:
- * <p/>
+ *
  * Mapcode codes can be represented in different alphabets. Note that an alphabet is something else
  * than a locale or a language. The supported alphabets for mapcodes are listed in {@link Alphabet}.
- * <p/>
+ *
  * Mapcode objects provide methods to obtain the mapcode code in a specific alphabet. By default,
  * the {@link Alphabet#ROMAN} is used.
  */
@@ -63,10 +63,10 @@ public final class Mapcode {
     /**
      * Create a mapcode object. Normally, mapcodes are created be encoding a lat/lon pair
      * using {@link MapcodeCodec#encode(double, double)} rather than creating them yourself.
-     * <p/>
+     *
      * Note that it is possible to create invalid mapcodes this way, which are syntactically
      * correct.
-     * <p/>
+     *
      * Note that the constructor will throw an {@link IllegalArgumentException} if the syntax of the mapcode
      * is not correct. The mapcode is not checked for validity, other than its syntax.
      *
@@ -116,7 +116,7 @@ else if (extensionLength > 8) {
     /**
      * Get the Mapcode string (without territory information) with standard precision.
      * The returned mapcode does not include the '-' separator and additional digits.
-     * <p/>
+     *
      * A mapcode defines an area of approximately 10 x 10 meters (100 m2) and will decode
      * to the center of that area. On average, the original coordinate will be 3.6 meters
      * from this center: the average inaccuracy of a mapcode.
@@ -137,15 +137,15 @@ public String getCode() {
     /**
      * Get the mapcode code (without territory information) with a specified precision.
      * The returned mapcode includes a '-' separator and additional digits for precisions 1 to 8.
-     * <p/>
+     *
      * The precision defines the size of a geographical area a single mapcode covers. This means It also defines
      * the maximum distance to the location, a (latitude, longitude) pair, that encoded to this mapcode.
-     * <p/>
+     *
      * Precision 0: area is approx 10 x 10 meters (100 m2); max. distance from original location less than 7.5 meters.
      * Precision 1: area is approx 3.33 m2; max. distance from original location less than 1.5 meters.
      * Precision 1: area is approx 0.11 m2; max. distance from original location less than 0.4 meters.
      * etc. (each level reduces the area by a factor of 30)
-     * <p/>
+     *
      * The accuracy is slightly better than the figures above, but these figures are safe assumptions.
      *
      * @param precision Precision. Range: 0..8.
@@ -176,7 +176,7 @@ public String getCode(final int precision) throws IllegalArgumentException {
      * Return the full international mapcode, including the full name of the territory and the mapcode code itself.
      * The format of the string is:
      * full-territory-name cde
-     * <p/>
+     *
      * Example:
      * Netherlands 49.4V           (regular code)
      * Netherlands 49.4V-K2        (high precision code)
@@ -211,7 +211,7 @@ public String getCodeWithTerritoryFullname() {
      * International codes use a territory code "AAA".
      * The format of the code is:
      * short-territory-name mapcode
-     * <p/>
+     *
      * Example:
      * NLD 49.4V                   (regular code)
      * NLD 49.4V-K2                (high-precision code)
@@ -282,7 +282,7 @@ public Territory getTerritory() {
     /**
      * This method return the mapcode type, given a mapcode string. If the mapcode string has an invalid
      * format, an exception is thrown.
-     * <p/>
+     *
      * Note that this method only checks the syntactic validity of the mapcode, the string format. It does not
      * check if the mapcode is really a valid mapcode representing a position on Earth.
      *
@@ -363,7 +363,7 @@ public static boolean containsTerritory(@Nonnull final String mapcode) throws Il
      * Get a safe maximum for the distance between a decoded mapcode and its original
      * location used for encoding the mapcode. The actual accuracy (resolution) of mapcodes is
      * better than this, but these are safe values to use under normal circumstances.
-     * <p/>
+     *
      * Do not make any other assumptions on these numbers than that mapcodes are never more off
      * by this distance.
      *

src/main/java/com/mapcode/MapcodeCodec.java

@@ -29,7 +29,7 @@
  * ----------------------------------------------------------------------------------------------
  * Mapcode public interface.
  * ----------------------------------------------------------------------------------------------
- * <p/>
+ *
  * This class is the external Java interface for encoding and decoding mapcodes.
  */
 public final class MapcodeCodec {
@@ -47,13 +47,13 @@ private MapcodeCodec() {
     /**
      * Encode a lat/lon pair to a mapcode with territory information. This produces a non-empty list of mapcode,
      * with at the very least 1 mapcodes for the lat/lon, which is the "International" mapcode.
-     * <p/>
+     *
      * The returned result list will always contain at least 1 mapcode, because every lat/lon pair can be encoded.
-     * <p/>
+     *
      * The list is ordered in such a way that the last result is the international code. However, you cannot assume
      * that the first result is the shortest mapcode. If you want to use the shortest mapcode, use
      * {@link #encodeToShortest(double, double, Territory)}.
-     * <p/>
+     *
      * The international code can be obtained from the list by using: "results.get(results.size() - 1)", or
      * you can use {@link #encodeToInternational(double, double)}, which is faster.
      *
@@ -78,9 +78,9 @@ public static List<Mapcode> encode(@Nonnull final Point point)
     /**
      * Encode a lat/lon pair to a mapcode with territory information, for a specific territory. This produces a
      * potentially empty list of mapcodes (empty if the lat/lon does not fall within the territory for mapcodes).
-     * <p/>
+     *
      * The returned result list will always contain at least 1 mapcode, because every lat/lon pair can be encoded.
-     * <p/>
+     *
      * The list is ordered in such a way that the last result is the international code. However, you cannot assume
      * that the first result is the shortest mapcode. If you want to use the shortest mapcode, use
      * {@link #encodeToShortest(double, double, Territory)}.
@@ -181,7 +181,7 @@ public static Mapcode encodeToInternational(@Nonnull final Point point)
     /**
      * Decode a mapcode to a Point. The decoding process may fail for local mapcodes,
      * because no territory context is supplied (world-wide).
-     * <p/>
+     *
      * The accepted format is:
      * {mapcode}
      * {territory-code} {mapcode}
@@ -202,11 +202,11 @@ public static Point decode(@Nonnull final String mapcode)
 
     /**
      * Decode a mapcode to a Point. A reference territory is supplied for disambiguation (only used if applicable).
-     * <p/>
+     *
      * The accepted format is:
      * {mapcode}
      * {territory-code} {mapcode}
-     * <p/>
+     *
      * Note that if a territory-code is supplied in the string, it takes preferences over the parameter.
      *
      * @param mapcode                 Mapcode.

src/main/java/com/mapcode/Point.java

@@ -24,7 +24,7 @@
 
 /**
  * This class defines a class for lat/lon points.
- * <p/>
+ *
  * Internally, the class implements a fixed-point representation where a coordinate is expressed in
  * "fractions", of 1/3.240,000,000,000th of a degree. A double (an IEEE 754-1985 binary64) is just
  * sufficient to represent coordinates between -180 and +180 degrees in such fractions.
@@ -49,7 +49,7 @@ public class Point {
     public static final double EARTH_CIRCUMFERENCE_Y = EARTH_RADIUS_Y_METERS * 2.0 * Math.PI;
 
     // Meters per degree latitude is fixed. For longitude: use factor * cos(midpoint of two degree latitudes).
-    public static final double METERS_PER_DEGREE_LAT         = EARTH_CIRCUMFERENCE_Y / 360.0;
+    public static final double METERS_PER_DEGREE_LAT = EARTH_CIRCUMFERENCE_Y / 360.0;
     public static final double METERS_PER_DEGREE_LON_EQUATOR = EARTH_CIRCUMFERENCE_X / 360.0; // * cos(deg(lat)).
 
     /**
@@ -66,6 +66,10 @@ public static Point fromDeg(final double latDeg, final double lonDeg) {
 
     /**
      * Public construction, from integer microdegrees (no loss of precision).
+     *
+     * @param latMicroDeg Latitude, in microdegrees.
+     * @param lonMicroDeg Longitude, in microdegrees.
+     * @return A defined point.
      */
     @Nonnull
     public static Point fromMicroDeg(final int latMicroDeg, final int lonMicroDeg) {
@@ -168,8 +172,7 @@ public static double distanceInMeters(@Nonnull final Point p1, @Nonnull final Po
         if (p1.getLonDeg() <= p2.getLonDeg()) {
             from = p1;
             to = p2;
-        }
-        else {
+        } else {
             from = p2;
             to = p1;
         }
@@ -225,10 +228,10 @@ public boolean equals(final Object obj) {
         }
         final Point that = (Point) obj;
         return (this.latMicroDeg == that.latMicroDeg) &&
-            (this.lonMicroDeg == that.lonMicroDeg) &&
-            (this.latFractionOnlyDeg == that.latFractionOnlyDeg) &&
-            (this.lonFractionOnlyDeg == that.lonFractionOnlyDeg) &&
-            (this.defined == that.defined);
+                (this.lonMicroDeg == that.lonMicroDeg) &&
+                (this.latFractionOnlyDeg == that.latFractionOnlyDeg) &&
+                (this.lonFractionOnlyDeg == that.lonFractionOnlyDeg) &&
+                (this.defined == that.defined);
     }
 
     /**
@@ -237,12 +240,12 @@ public boolean equals(final Object obj) {
      * -----------------------------------------------------------------------
      */
     // Constants to convert between Degrees, MicroDegrees and Fractions
-    static final double MICRODEG_TO_DEG_FACTOR           = 1000000.0;
-    static final double MAX_PRECISION_FACTOR             = 810000.0;
+    static final double MICRODEG_TO_DEG_FACTOR = 1000000.0;
+    static final double MAX_PRECISION_FACTOR = 810000.0;
     static final double LAT_MICRODEG_TO_FRACTIONS_FACTOR = MAX_PRECISION_FACTOR;
     static final double LON_MICRODEG_TO_FRACTIONS_FACTOR = MAX_PRECISION_FACTOR * 4;
-    static final double LAT_TO_FRACTIONS_FACTOR          = MICRODEG_TO_DEG_FACTOR * LAT_MICRODEG_TO_FRACTIONS_FACTOR;
-    static final double LON_TO_FRACTIONS_FACTOR          = MICRODEG_TO_DEG_FACTOR * LON_MICRODEG_TO_FRACTIONS_FACTOR;
+    static final double LAT_TO_FRACTIONS_FACTOR = MICRODEG_TO_DEG_FACTOR * LAT_MICRODEG_TO_FRACTIONS_FACTOR;
+    static final double LON_TO_FRACTIONS_FACTOR = MICRODEG_TO_DEG_FACTOR * LON_MICRODEG_TO_FRACTIONS_FACTOR;
 
     private int latMicroDeg;            // Whole nr of MICRODEG_TO_DEG_FACTOR.
     private int lonMicroDeg;            // Whole nr of MICRODEG_TO_DEG_FACTOR.
@@ -272,8 +275,7 @@ private Point(final double latDeg, final double lonDeg) {
         double lat = latDeg + 90;
         if (lat < 0) {
             lat = 0;
-        }
-        else if (lat > 180) {
+        } else if (lat > 180) {
             lat = 180;
         }
 
@@ -367,8 +369,7 @@ Point wrap() {
             lonMicroDeg %= 360000000;
             if (lonMicroDeg >= 180000000) {
                 lonMicroDeg -= 360000000;
-            }
-            else if (lonMicroDeg < -180000000) {
+            } else if (lonMicroDeg < -180000000) {
                 lonMicroDeg += 360000000;
             }
         }

src/main/java/com/mapcode/Territory.java

@@ -26,7 +26,7 @@
  * ----------------------------------------------------------------------------------------------
  * Mapcode public interface.
  * ----------------------------------------------------------------------------------------------
- * <p/>
+ *
  * This class defines the available territory codes as used by mapcode.
  */
 public enum Territory {
@@ -654,13 +654,13 @@ static Territory fromNumber(final int number) throws UnknownTerritoryException {
      * Get a territory from a mapcode territory abbreviation (or a territory name). Note that the provided abbreviation is NOT an
      * ISO code: it's a mapcode prefix. As local mapcodes for subdivisions have been optimized to prefer to use 2-character
      * subdivisions codes in local codes, subdivisions are preferred over countries in this case.
-     * <p/>
+     *
      * For example, fromString("AS") returns {@link Territory#IN_AS} rather than {@link Territory#ASM} and
      * fromString("BR") returns {@link Territory#IN_BR} rather than {@link Territory#BRA}.
-     * <p/>
+     *
      * This behavior is intentional as local mapcodes are designed to be as short as possible. A mapcode within
      * the Indian state Bihar should therefore be able to specified as "BR 49.46M3" rather "IN-BR 49.46M3".
-     * <p/>
+     *
      * Brazilian mapcodes, on the other hand, would be specified as "BRA BDHP.JK39-1D", using the ISO 3 letter code.
      *
      * @param alphaCode Territory name or alphanumeric code.

src/main/java/com/mapcode/UnknownMapcodeException.java

@@ -20,7 +20,7 @@
 
 /**
  * This checked exception is thrown for invalid mapcodes (which have the right syntax, are correctly formatted).
- * <p/>
+ *
  * Note that for syntactically incorrect mapcodes, normally {@link IllegalArgumentException}s are thrown,
  * not {@link UnknownMapcodeException}.
  */