Index: /applications/editors/josm/plugins/seachart/jbasemap/build.xml =================================================================== --- /applications/editors/josm/plugins/seachart/jbasemap/build.xml (revision 31846) +++ /applications/editors/josm/plugins/seachart/jbasemap/build.xml (revision 31846) @@ -0,0 +1,37 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Index: /applications/editors/josm/plugins/seachart/jbasemap/src/jbasemap/Jbasemap.java =================================================================== --- /applications/editors/josm/plugins/seachart/jbasemap/src/jbasemap/Jbasemap.java (revision 31846) +++ /applications/editors/josm/plugins/seachart/jbasemap/src/jbasemap/Jbasemap.java (revision 31846) @@ -0,0 +1,110 @@ +/* Copyright 2014 Malcolm Herring + * + * This is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, version 3 of the License. + * + * For a copy of the GNU General Public License, see . + */ + +package jbasemap; + +import java.awt.Color; +import java.awt.Rectangle; +import java.awt.geom.Point2D; +import java.io.BufferedReader; +import java.io.FileReader; +import java.io.IOException; + +import org.apache.batik.dom.GenericDOMImplementation; +import org.apache.batik.svggen.SVGGraphics2D; +import org.w3c.dom.DOMImplementation; +import org.w3c.dom.Document; + +import s57.S57map; +import s57.S57obj.Obj; +import s57.S57osm; +import s57.S57map.*; +import symbols.*; +import render.*; + +public class Jbasemap { + + static String src; + static String dst; + static Context context; + static S57map map; + + static class Context implements ChartContext { + + static double top = 0; + static double mile = 0; + + public Context () { + top = (1.0 - Math.log(Math.tan(map.bounds.maxlat) + 1.0 / Math.cos(map.bounds.maxlat)) / Math.PI) / 2.0 * 256.0 * 512.0; + mile = 256 / ((Math.toDegrees(map.bounds.maxlat) - Math.toDegrees(map.bounds.minlat)) * 60); + } + + public Point2D getPoint(Snode coord) { + double x = (Math.toDegrees(coord.lon) - Math.toDegrees(map.bounds.minlon)) * 256.0 * 256.0 / 180.0; + double y = ((1.0 - Math.log(Math.tan(coord.lat) + 1.0 / Math.cos(coord.lat)) / Math.PI) / 2.0 * 256.0 * 512.0) - top; + return new Point2D.Double(x, y); + } + + public double mile(Feature feature) { + return mile; + } + + public boolean clip() { + return true; + } + + public Color background() { + if (map.features.containsKey(Obj.COALNE)) { + return Symbols.Bwater; + } else { + return Symbols.Yland; + } + } + + public RuleSet ruleset() { + return RuleSet.BASE; + } + } + + public static void main(String[] args) throws IOException { + src = args[0]; + dst = args[1]; + try { + BufferedReader in = new BufferedReader(new FileReader(src)); + map = new S57map(false); + if (args.length == 4) { + map.bounds.maxlat = Math.atan(Math.sinh(Math.PI * (1 - 2 * Double.parseDouble(args[3]) / 512))) * 180.0 / Math.PI; + map.bounds.minlat = Math.atan(Math.sinh(Math.PI * (1 - 2 * (Double.parseDouble(args[3]) + 1) / 512))) * 180.0 / Math.PI; + map.bounds.minlon = Double.parseDouble(args[2]) / 512 * 360.0 - 180.0; + map.bounds.maxlon = (Double.parseDouble(args[2]) + 1) / 512 * 360.0 - 180.0; + } + try { + S57osm.OSMmap(in, map); + } catch (Exception e) { + System.err.println("Input data error"); + System.exit(-1); + } + in.close(); + } catch (IOException e) { + System.err.println("Input file: " + e.getMessage()); + System.exit(-1); + } + context = new Context(); + Rectangle rect = new Rectangle(256, 256); + DOMImplementation domImpl = GenericDOMImplementation.getDOMImplementation(); + Document document = domImpl.createDocument("http://www.w3.org/2000/svg", "svg", null); + SVGGraphics2D svgGenerator = new SVGGraphics2D(document); + svgGenerator.clearRect(rect.x, rect.y, rect.width, rect.height); + svgGenerator.setSVGCanvasSize(rect.getSize()); + svgGenerator.setClip(rect.x, rect.y, rect.width, rect.height); + Renderer.reRender(svgGenerator, rect, 9, 0.002, map, context); + svgGenerator.stream(dst); + System.exit(0); + } +} Index: /applications/editors/josm/plugins/seachart/jbasemap/src/render =================================================================== --- /applications/editors/josm/plugins/seachart/jbasemap/src/render (revision 31846) +++ /applications/editors/josm/plugins/seachart/jbasemap/src/render (revision 31846) @@ -0,0 +1,1 @@ +link ../../src/render Index: /applications/editors/josm/plugins/seachart/jbasemap/src/s57 =================================================================== --- /applications/editors/josm/plugins/seachart/jbasemap/src/s57 (revision 31846) +++ /applications/editors/josm/plugins/seachart/jbasemap/src/s57 (revision 31846) @@ -0,0 +1,1 @@ +link ../../src/s57 Index: /applications/editors/josm/plugins/seachart/jbasemap/src/symbols =================================================================== --- /applications/editors/josm/plugins/seachart/jbasemap/src/symbols (revision 31846) +++ /applications/editors/josm/plugins/seachart/jbasemap/src/symbols (revision 31846) @@ -0,0 +1,1 @@ +link ../../src/symbols Index: /applications/editors/josm/plugins/seachart/josmtos57/src/josmtos57/Josmtos57.java =================================================================== --- /applications/editors/josm/plugins/seachart/josmtos57/src/josmtos57/Josmtos57.java (revision 31845) +++ /applications/editors/josm/plugins/seachart/josmtos57/src/josmtos57/Josmtos57.java (revision 31846) @@ -29,4 +29,11 @@ */ + /* + * To do: + * 1. Geometry truncation at cell boundary. + * 2. Geometry validation/correction to comply with S57 limitations. + * 3. Improvements in mapping of OSM features to S57 objects. + */ + static byte[] header = { '0', '0', '2', '6', '2', '3', 'L', 'E', '1', ' ', '0', '9', '0', '0', '0', '7', '3', ' ', ' ', ' ', '6', '6', '0', '4', '0', '0', '0', '0', '0', '0', '0', '0', @@ -64,5 +71,5 @@ try { Scanner min = new Scanner(new FileInputStream(args[1])); - meta = new HashMap(); + meta = new HashMap<>(); meta.put("FILE", args[3]); while (min.hasNext()) { @@ -78,5 +85,10 @@ try { in = new BufferedReader(new FileReader(new File(args[0]))); - S57osm.OSMmap(in, map); + try { + S57osm.OSMmap(in, map); + } catch (Exception e) { + System.err.println("Input data error"); + System.exit(-1); + } in.close(); } catch (IOException e) { @@ -113,5 +125,5 @@ idx = header.length; int recs = 2; - fields = new ArrayList(); + fields = new ArrayList<>(); fields.add(new Fparams(S57field.CATD, new Object[]{ "CD", recs, args[3], "", "V01X01", "BIN", Math.toDegrees(map.bounds.minlat), Math.toDegrees(map.bounds.minlon), Math.toDegrees(map.bounds.maxlat), Math.toDegrees(map.bounds.maxlon), String.format("%08X", crc.getValue()), "" })); Index: /applications/editors/josm/plugins/seachart/jrender/src/jrender/Jrender.java =================================================================== --- /applications/editors/josm/plugins/seachart/jrender/src/jrender/Jrender.java (revision 31845) +++ /applications/editors/josm/plugins/seachart/jrender/src/jrender/Jrender.java (revision 31846) @@ -80,5 +80,5 @@ public RuleSet ruleset() { - return RuleSet.ALL; + return RuleSet.SEAMARK; } } @@ -105,5 +105,5 @@ Document document = domImpl.createDocument("http://www.w3.org/2000/svg", "svg", null); SVGGraphics2D svgGenerator = new SVGGraphics2D(document); - svgGenerator.setBackground(Symbols.Bwater); +// svgGenerator.setBackground(Symbols.Bwater); svgGenerator.clearRect(rect.x, rect.y, rect.width, rect.height); svgGenerator.setSVGCanvasSize(rect.getSize()); @@ -181,4 +181,5 @@ deletes = new HashMap(); BufferedReader in = new BufferedReader(new FileReader(srcdir + zoom + "-" + xtile + "-" + ytile + ".osm")); + map = new S57map(true); S57osm.OSMmap(in, map); in.close(); Index: /applications/editors/josm/plugins/seachart/src/render/Rules.java =================================================================== --- /applications/editors/josm/plugins/seachart/src/render/Rules.java (revision 31845) +++ /applications/editors/josm/plugins/seachart/src/render/Rules.java (revision 31846) @@ -218,4 +218,5 @@ if (testObject(Obj.DRGARE)) for (Feature f : objects) if (testFeature(f)) areas(); if (testObject(Obj.RESARE)) for (Feature f : objects) if (testFeature(f)) areas(); + if (testObject(Obj.PRCARE)) for (Feature f : objects) if (testFeature(f)) areas(); if (testObject(Obj.SPLARE)) for (Feature f : objects) if (testFeature(f)) areas(); if (testObject(Obj.SEAARE)) for (Feature f : objects) if (testFeature(f)) areas(); @@ -345,4 +346,9 @@ } break; + case PRCARE: + if (Renderer.zoom >= 12) { + Renderer.lineVector(feature, new LineStyle(Symbols.Mline, 10, new float[] { 40, 40 })); + } + break; case SEAARE: switch ((CatSEA) getAttEnum(feature, feature.type, 0, Att.CATSEA)) { Index: /applications/editors/josm/plugins/seachart/src/s57/S57att.java =================================================================== --- /applications/editors/josm/plugins/seachart/src/s57/S57att.java (revision 31845) +++ /applications/editors/josm/plugins/seachart/src/s57/S57att.java (revision 31846) @@ -28,6 +28,6 @@ DIRIMP, DISBK1, DISBK2, DISIPU, DISIPD, ELEVA1, ELEVA2, FNCTNM, WTWDIS, BUNVES, BNKWTW, COMCTN, HORCLL, HORCLW, TRSHGD, UNLOCD, HIGWAT, HIGNAM, LOWWAT, LOWNAM, MEAWAT, MEANAM, OTHWAT, OTHNAM, REFLEV, SDRLEV, VCRLEV, SCHREF, USESHP, CURVHW, CURVLW, CURVMW, CURVOW, APTREF, SHPTYP, UPDMSG, ADDMRK, CATNMK, CATBRT, CATBUN, - CATCCL, CATCOM, CATHBR, CATRFD, CATTML, CATGAG, CATVTR, CATTAB, CATEXS, CATWWM, LG_SPD, LG_SPR, LG_BME, LG_LGS, LG_DRT, LG_WDP, LG_WDU, LG_REL, LG_FNC, LG_DES, - LG_PBR, LC_CSI, LC_CSE, LC_ASI, LC_ASE, LC_CCI, LC_CCE, LC_BM1, LC_BM2, LC_LG1, LC_LG2, LC_DR1, LC_DR2, LC_SP1, LC_SP2, LC_WD1, LC_WD2, LITRAD, CATCVR, HUNITS + CATCCL, CATCOM, CATHBR, CATRFD, CATTML, CATGAG, CATVTR, CATTAB, CATEXS, LG_SPD, LG_SPR, LG_BME, LG_LGS, LG_DRT, LG_WDP, LG_WDU, LG_REL, LG_FNC, LG_DES, LG_PBR, + LC_CSI, LC_CSE, LC_ASI, LC_ASE, LC_CCI, LC_CCE, LC_BM1, LC_BM2, LC_LG1, LC_LG2, LC_DR1, LC_DR2, LC_SP1, LC_SP2, LC_WD1, LC_WD2, LITRAD, CATCVR, HUNITS } @@ -79,11 +79,11 @@ AttIENC.put(Att.CATTAB, 17092); AttIENC.put(Att.SCHREF, 17093); AttIENC.put(Att.USESHP, 17094); AttIENC.put(Att.CURVHW, 17095); AttIENC.put(Att.CURVLW, 17096); AttIENC.put(Att.CURVMW, 17097); AttIENC.put(Att.CURVOW, 17098); AttIENC.put(Att.APTREF, 17099); AttIENC.put(Att.CATEXS, 17100); AttIENC.put(Att.CATCBL, 17101); - AttIENC.put(Att.CATHLK, 17102); AttIENC.put(Att.HUNITS, 17103); AttIENC.put(Att.WATLEV, 17104); AttIENC.put(Att.CATWWM, 17112); AttIENC.put(Att.LG_SPD, 18001); - AttIENC.put(Att.LG_SPR, 18002); AttIENC.put(Att.LG_BME, 18003); AttIENC.put(Att.LG_LGS, 18004); AttIENC.put(Att.LG_DRT, 18005); AttIENC.put(Att.LG_WDP, 18006); - AttIENC.put(Att.LG_WDU, 18007); AttIENC.put(Att.LG_REL, 18008); AttIENC.put(Att.LG_FNC, 18009); AttIENC.put(Att.LG_DES, 18010); AttIENC.put(Att.LG_PBR, 18011); - AttIENC.put(Att.LC_CSI, 18012); AttIENC.put(Att.LC_CSE, 18013); AttIENC.put(Att.LC_ASI, 18014); AttIENC.put(Att.LC_ASE, 18015); AttIENC.put(Att.LC_CCI, 18016); - AttIENC.put(Att.LC_CCE, 18017); AttIENC.put(Att.LC_BM1, 18018); AttIENC.put(Att.LC_BM2, 18019); AttIENC.put(Att.LC_LG1, 18020); AttIENC.put(Att.LC_LG2, 18021); - AttIENC.put(Att.LC_DR1, 18022); AttIENC.put(Att.LC_DR2, 18023); AttIENC.put(Att.LC_SP1, 18024); AttIENC.put(Att.LC_SP2, 18025); AttIENC.put(Att.LC_WD1, 18026); - AttIENC.put(Att.LC_WD2, 18027); AttIENC.put(Att.SHPTYP, 33066); AttIENC.put(Att.UPDMSG, 40000); AttIENC.put(Att.BNKWTW, 17999); + AttIENC.put(Att.CATHLK, 17102); AttIENC.put(Att.HUNITS, 17103); AttIENC.put(Att.WATLEV, 17104); AttIENC.put(Att.LG_SPD, 18001); AttIENC.put(Att.LG_SPR, 18002); + AttIENC.put(Att.LG_BME, 18003); AttIENC.put(Att.LG_LGS, 18004); AttIENC.put(Att.LG_DRT, 18005); AttIENC.put(Att.LG_WDP, 18006); AttIENC.put(Att.LG_WDU, 18007); + AttIENC.put(Att.LG_REL, 18008); AttIENC.put(Att.LG_FNC, 18009); AttIENC.put(Att.LG_DES, 18010); AttIENC.put(Att.LG_PBR, 18011); AttIENC.put(Att.LC_CSI, 18012); + AttIENC.put(Att.LC_CSE, 18013); AttIENC.put(Att.LC_ASI, 18014); AttIENC.put(Att.LC_ASE, 18015); AttIENC.put(Att.LC_CCI, 18016); AttIENC.put(Att.LC_CCE, 18017); + AttIENC.put(Att.LC_BM1, 18018); AttIENC.put(Att.LC_BM2, 18019); AttIENC.put(Att.LC_LG1, 18020); AttIENC.put(Att.LC_LG2, 18021); AttIENC.put(Att.LC_DR1, 18022); + AttIENC.put(Att.LC_DR2, 18023); AttIENC.put(Att.LC_SP1, 18024); AttIENC.put(Att.LC_SP2, 18025); AttIENC.put(Att.LC_WD1, 18026); AttIENC.put(Att.LC_WD2, 18027); + AttIENC.put(Att.SHPTYP, 33066); AttIENC.put(Att.UPDMSG, 40000); AttIENC.put(Att.BNKWTW, 17999); } @@ -144,17 +144,17 @@ AttStr.put(Att.CATTAB, "operation"); AttStr.put(Att.SCHREF, "schedule"); AttStr.put(Att.USESHP, "use"); AttStr.put(Att.CURVHW, "high_velocity"); AttStr.put(Att.CURVLW, "low_velocity"); AttStr.put(Att.CURVMW, "mean_velocity"); AttStr.put(Att.CURVOW, "other_velocity"); AttStr.put(Att.APTREF, "passing_time"); - AttStr.put(Att.CATCOM, "category"); AttStr.put(Att.CATCVR, "category"); AttStr.put(Att.CATEXS, "category"); AttStr.put(Att.CATWWM, "category"); AttStr.put(Att.SHPTYP, "ship"); + AttStr.put(Att.CATCOM, "category"); AttStr.put(Att.CATCVR, "category"); AttStr.put(Att.CATEXS, "category"); AttStr.put(Att.SHPTYP, "ship"); AttStr.put(Att.UPDMSG, "message"); AttStr.put(Att.LITRAD, "radius"); } - private static final EnumMap Accuracy = new EnumMap(Obj.class); static { Accuracy.put(Obj.UNKOBJ, Att.HORACC); } - private static final EnumMap Addition = new EnumMap(Obj.class); static { Addition.put(Obj.UNKOBJ, Att.ADDMRK); } - private static final EnumMap Agency = new EnumMap(Obj.class); static { Agency.put(Obj.UNKOBJ, Att.AGENCY); } - private static final EnumMap Anomaly = new EnumMap(Obj.class); static { Anomaly.put(Obj.UNKOBJ, Att.VALLMA); } - private static final EnumMap Authority = new EnumMap(Obj.class); static { Authority.put(Obj.UNKOBJ, Att.SURATH); } - private static final EnumMap Availability = new EnumMap(Obj.class); static { Availability.put(Obj.UNKOBJ, Att.BUNVES); } - private static final EnumMap Bank = new EnumMap(Obj.class); static { Bank.put(Obj.UNKOBJ, Att.BNKWTW); } - private static final EnumMap Callsign = new EnumMap(Obj.class); static { Callsign.put(Obj.UNKOBJ, Att.CALSGN); } - private static final EnumMap Category = new EnumMap(Obj.class); static { + private static final EnumMap Accuracy = new EnumMap<>(Obj.class); static { Accuracy.put(Obj.UNKOBJ, Att.HORACC); } + private static final EnumMap Addition = new EnumMap<>(Obj.class); static { Addition.put(Obj.UNKOBJ, Att.ADDMRK); } + private static final EnumMap Agency = new EnumMap<>(Obj.class); static { Agency.put(Obj.UNKOBJ, Att.AGENCY); } + private static final EnumMap Anomaly = new EnumMap<>(Obj.class); static { Anomaly.put(Obj.UNKOBJ, Att.VALLMA); } + private static final EnumMap Authority = new EnumMap<>(Obj.class); static { Authority.put(Obj.UNKOBJ, Att.SURATH); } + private static final EnumMap Availability = new EnumMap<>(Obj.class); static { Availability.put(Obj.UNKOBJ, Att.BUNVES); } + private static final EnumMap Bank = new EnumMap<>(Obj.class); static { Bank.put(Obj.UNKOBJ, Att.BNKWTW); } + private static final EnumMap Callsign = new EnumMap<>(Obj.class); static { Callsign.put(Obj.UNKOBJ, Att.CALSGN); } + private static final EnumMap Category = new EnumMap<>(Obj.class); static { Category.put(Obj.ACHARE, Att.CATACH); Category.put(Obj.ACHBRT, Att.CATACH); Category.put(Obj.AIRARE, Att.CATAIR); Category.put(Obj.BCNCAR, Att.CATCAM); Category.put(Obj.BCNLAT, Att.CATLAM); Category.put(Obj.BCNSPP, Att.CATSPM); Category.put(Obj.BOYLAT, Att.CATLAM); Category.put(Obj.BOYINB, Att.CATINB); Category.put(Obj.BOYSPP, Att.CATSPM); @@ -179,95 +179,95 @@ } - private static final EnumMap Channel = new EnumMap(Obj.class); static { Channel.put(Obj.UNKOBJ, Att.COMCHA); } - private static final EnumMap Character = new EnumMap(Obj.class); static { Character.put(Obj.UNKOBJ, Att.LITCHR); } - private static final EnumMap Clearance_height = new EnumMap(Obj.class); static { Clearance_height.put(Obj.UNKOBJ, Att.VERCLR); } - private static final EnumMap Clearance_height_closed = new EnumMap(Obj.class); static { Clearance_height_closed.put(Obj.UNKOBJ, Att.VERCCL); } - private static final EnumMap Clearance_height_open = new EnumMap(Obj.class); static { Clearance_height_open.put(Obj.UNKOBJ, Att.VERCOP); } - private static final EnumMap Clearance_height_safe = new EnumMap(Obj.class); static { Clearance_height_safe.put(Obj.UNKOBJ, Att.VERCSA); } - private static final EnumMap Clearance_width = new EnumMap(Obj.class); static { Clearance_width.put(Obj.UNKOBJ, Att.HORCLR); } - private static final EnumMap Colour = new EnumMap(Obj.class); static { Colour.put(Obj.UNKOBJ, Att.COLOUR); } - private static final EnumMap Colour_pattern = new EnumMap(Obj.class); static { Colour_pattern.put(Obj.UNKOBJ, Att.COLPAT); } - private static final EnumMap Communication = new EnumMap(Obj.class); static { Communication.put(Obj.UNKOBJ, Att.COMCTN); } - private static final EnumMap Condition = new EnumMap(Obj.class); static { Condition.put(Obj.UNKOBJ, Att.CONDTN); } - private static final EnumMap Conspicuity = new EnumMap(Obj.class); static { Conspicuity.put(Obj.UNKOBJ, Att.CONVIS); } - private static final EnumMap Construction = new EnumMap(Obj.class); static { Construction.put(Obj.UNKOBJ, Att.NATCON); } - private static final EnumMap Danger_class = new EnumMap(Obj.class); static { Danger_class.put(Obj.UNKOBJ, Att.CLSDNG); } - private static final EnumMap Depth = new EnumMap(Obj.class); static { Depth.put(Obj.UNKOBJ, Att.VALDCO); Depth.put(Obj.SOUNDG, Att.VALSOU); } - private static final EnumMap Depth_buried = new EnumMap(Obj.class); static { Depth_buried.put(Obj.UNKOBJ, Att.BURDEP); } - private static final EnumMap Description = new EnumMap(Obj.class); static { Description.put(Obj.UNKOBJ, Att.TXTDSC); } - private static final EnumMap Distance = new EnumMap(Obj.class); static { Distance.put(Obj.UNKOBJ, Att.WTWDIS); } - private static final EnumMap Distance_down = new EnumMap(Obj.class); static { Distance_down.put(Obj.UNKOBJ, Att.DISIPD); } - private static final EnumMap Distance_end = new EnumMap(Obj.class); static { Distance_end.put(Obj.UNKOBJ, Att.DISBK2); } - private static final EnumMap Distance_start = new EnumMap(Obj.class); static { Distance_start.put(Obj.UNKOBJ, Att.DISBK1); } - private static final EnumMap Distance_up = new EnumMap(Obj.class); static { Distance_up.put(Obj.UNKOBJ, Att.DISIPU); } - private static final EnumMap Elevation = new EnumMap(Obj.class); static { Elevation.put(Obj.UNKOBJ, Att.ELEVAT); } - private static final EnumMap End_date = new EnumMap(Obj.class); static { End_date.put(Obj.UNKOBJ, Att.DATEND); } - private static final EnumMap End_time = new EnumMap(Obj.class); static { End_time.put(Obj.UNKOBJ, Att.TIMEND); } - private static final EnumMap Estimated_range = new EnumMap(Obj.class); static { Estimated_range.put(Obj.UNKOBJ, Att.ESTRNG); } - private static final EnumMap Exhibition = new EnumMap(Obj.class); static { Exhibition.put(Obj.UNKOBJ, Att.EXCLIT); } - private static final EnumMap Exposition = new EnumMap(Obj.class); static { Exposition.put(Obj.UNKOBJ, Att.EXPSOU); } - private static final EnumMap Factor = new EnumMap(Obj.class); static { Factor.put(Obj.UNKOBJ, Att.ICEFAC); } - private static final EnumMap Frequency = new EnumMap(Obj.class); static { Frequency.put(Obj.UNKOBJ, Att.SIGFRQ); } - private static final EnumMap Function = new EnumMap(Obj.class); static { Function.put(Obj.BUISGL, Att.FUNCTN); Function.put(Obj.LNDMRK, Att.FUNCTN); Function.put(Obj.NOTMRK, Att.FNCTNM); } - private static final EnumMap Generation = new EnumMap(Obj.class); static { Generation.put(Obj.UNKOBJ, Att.SIGGEN); } - private static final EnumMap Goods = new EnumMap(Obj.class); static { Goods.put(Obj.UNKOBJ, Att.TRSHGD); } - private static final EnumMap Gravity_reference = new EnumMap(Obj.class); static { Gravity_reference.put(Obj.UNKOBJ, Att.REFLEV); } - private static final EnumMap Group = new EnumMap(Obj.class); static { Group.put(Obj.UNKOBJ, Att.SIGGRP); } - private static final EnumMap Height = new EnumMap(Obj.class); static { Height.put(Obj.UNKOBJ, Att.HEIGHT); } - private static final EnumMap High_name = new EnumMap(Obj.class); static { High_name.put(Obj.UNKOBJ, Att.HIGNAM); } - private static final EnumMap High_value = new EnumMap(Obj.class); static { High_value.put(Obj.UNKOBJ, Att.HIGWAT); } - private static final EnumMap High_velocity = new EnumMap(Obj.class); static { High_velocity.put(Obj.UNKOBJ, Att.CURVHW); } - private static final EnumMap Horizontal_clearance_length = new EnumMap(Obj.class); static { Horizontal_clearance_length.put(Obj.UNKOBJ, Att.HORCLL); } - private static final EnumMap Horizontal_clearance_width = new EnumMap(Obj.class); static { Horizontal_clearance_width.put(Obj.UNKOBJ, Att.HORCLW); } - private static final EnumMap Horizontal_datum = new EnumMap(Obj.class); static { Horizontal_datum.put(Obj.UNKOBJ, Att.HORDAT); } - private static final EnumMap Impact = new EnumMap(Obj.class); static { Impact.put(Obj.UNKOBJ, Att.DIRIMP); } - private static final EnumMap Information = new EnumMap(Obj.class); static { Information.put(Obj.UNKOBJ, Att.INFORM); } - private static final EnumMap Jurisdiction = new EnumMap(Obj.class); static { Jurisdiction.put(Obj.UNKOBJ, Att.JRSDTN); } - private static final EnumMap Length = new EnumMap(Obj.class); static { Length.put(Obj.UNKOBJ, Att.HORLEN); } - private static final EnumMap Local_name = new EnumMap(Obj.class); static { Local_name.put(Obj.UNKOBJ, Att.OTHNAM); } - private static final EnumMap Local_value = new EnumMap(Obj.class); static { Local_value.put(Obj.UNKOBJ, Att.OTHWAT); } - private static final EnumMap Low_name = new EnumMap(Obj.class); static { Low_name.put(Obj.UNKOBJ, Att.LOWNAM); } - private static final EnumMap Low_value = new EnumMap(Obj.class); static { Low_value.put(Obj.UNKOBJ, Att.LOWWAT); } - private static final EnumMap Low_velocity = new EnumMap(Obj.class); static { Low_velocity.put(Obj.UNKOBJ, Att.CURVLW); } - private static final EnumMap Maximum_depth = new EnumMap(Obj.class); static { Maximum_depth.put(Obj.UNKOBJ, Att.DRVAL2); } - private static final EnumMap Maximum_elevation = new EnumMap(Obj.class); static { Maximum_elevation.put(Obj.UNKOBJ, Att.ELEVA2); } - private static final EnumMap Maximum_load = new EnumMap(Obj.class); static { Maximum_load.put(Obj.UNKOBJ, Att.LIFCAP); } - private static final EnumMap Maximum_range = new EnumMap(Obj.class); static { Maximum_range.put(Obj.UNKOBJ, Att.VALMXR); } - private static final EnumMap Maximum_sounding = new EnumMap(Obj.class); static { Maximum_sounding.put(Obj.UNKOBJ, Att.SDISMX); } - private static final EnumMap Mean_name = new EnumMap(Obj.class); static { Mean_name.put(Obj.UNKOBJ, Att.MEANAM); } - private static final EnumMap Mean_value = new EnumMap(Obj.class); static { Mean_value.put(Obj.UNKOBJ, Att.MEAWAT); } - private static final EnumMap Mean_velocity = new EnumMap(Obj.class); static { Mean_velocity.put(Obj.UNKOBJ, Att.CURVMW); } - private static final EnumMap Message = new EnumMap(Obj.class); static { Message.put(Obj.UNKOBJ, Att.UPDMSG); } - private static final EnumMap Minimum_depth = new EnumMap(Obj.class); static { Minimum_depth.put(Obj.UNKOBJ, Att.DRVAL1); } - private static final EnumMap Minimum_elevation = new EnumMap(Obj.class); static { Minimum_elevation.put(Obj.UNKOBJ, Att.ELEVA1); } - private static final EnumMap Minimum_sounding = new EnumMap(Obj.class); static { Minimum_sounding.put(Obj.UNKOBJ, Att.SDISMN); } - private static final EnumMap Multiple = new EnumMap(Obj.class); static { Multiple.put(Obj.UNKOBJ, Att.MLTYLT); } - private static final EnumMap Name = new EnumMap(Obj.class); static { Name.put(Obj.UNKOBJ, Att.OBJNAM); } - private static final EnumMap National_information = new EnumMap(Obj.class); static { National_information.put(Obj.UNKOBJ, Att.NINFOM); } - private static final EnumMap Nationality = new EnumMap(Obj.class); static { Nationality.put(Obj.UNKOBJ, Att.NATION); } - private static final EnumMap National_description = new EnumMap(Obj.class); static { National_description.put(Obj.UNKOBJ, Att.NTXTDS); } - private static final EnumMap National_name = new EnumMap(Obj.class); static { National_name.put(Obj.UNKOBJ, Att.NOBJNM); } - private static final EnumMap National_pilot_district = new EnumMap(Obj.class); static { National_pilot_district.put(Obj.UNKOBJ, Att.NPLDST); } - private static final EnumMap Nm_date = new EnumMap(Obj.class); static { Nm_date.put(Obj.UNKOBJ, Att.NMDATE); } - private static final EnumMap Other_velocity = new EnumMap(Obj.class); static { Other_velocity.put(Obj.UNKOBJ, Att.CURVOW); } - private static final EnumMap Operation = new EnumMap(Obj.class); static { Operation.put(Obj.UNKOBJ, Att.CATTAB); } - private static final EnumMap Orientation = new EnumMap(Obj.class); static { Orientation.put(Obj.UNKOBJ, Att.ORIENT); } - private static final EnumMap Passing_time = new EnumMap(Obj.class); static { Passing_time.put(Obj.UNKOBJ, Att.APTREF); } - private static final EnumMap Period = new EnumMap(Obj.class); static { Period.put(Obj.UNKOBJ, Att.SIGPER); } - private static final EnumMap Period_end = new EnumMap(Obj.class); static { Period_end.put(Obj.UNKOBJ, Att.PEREND); } - private static final EnumMap Period_start = new EnumMap(Obj.class); static { Period_start.put(Obj.UNKOBJ, Att.PERSTA); } - private static final EnumMap Pilot_district = new EnumMap(Obj.class); static { Pilot_district.put(Obj.UNKOBJ, Att.PILDST); } - private static final EnumMap Position_quality = new EnumMap(Obj.class); static { Position_quality.put(Obj.UNKOBJ, Att.QUAPOS); } - private static final EnumMap Positional_accuracy = new EnumMap(Obj.class); static { Positional_accuracy.put(Obj.UNKOBJ, Att.POSACC); } - private static final EnumMap Producing_country = new EnumMap(Obj.class); static { Producing_country.put(Obj.UNKOBJ, Att.PRCTRY); } - private static final EnumMap Product = new EnumMap(Obj.class); static { Product.put(Obj.UNKOBJ, Att.PRODCT); } - private static final EnumMap Quality = new EnumMap(Obj.class); static { Quality.put(Obj.UNKOBJ, Att.QUASOU); } - private static final EnumMap Radius = new EnumMap(Obj.class); static { Radius.put(Obj.UNKOBJ, Att.RADIUS); Radius.put(Obj.LIGHTS, Att.LITRAD); } - private static final EnumMap Range = new EnumMap(Obj.class); static { Range.put(Obj.UNKOBJ, Att.VALNMR); } - private static final EnumMap Reference = new EnumMap(Obj.class); static { Reference.put(Obj.UNKOBJ, Att.PUBREF); } - private static final EnumMap Reflectivity = new EnumMap(Obj.class); static { Reflectivity.put(Obj.UNKOBJ, Att.CONRAD); } - private static final EnumMap Restriction = new EnumMap(Obj.class); static { Restriction.put(Obj.UNKOBJ, Att.RESTRN); } - private static final EnumMap Schedule = new EnumMap(Obj.class); static { Schedule.put(Obj.UNKOBJ, Att.SCHREF); } - private static final EnumMap Shape = new EnumMap(Obj.class); static { Shape.put(Obj.BCNCAR, Att.BCNSHP); Shape.put(Obj.BCNISD, Att.BCNSHP); + private static final EnumMap Channel = new EnumMap<>(Obj.class); static { Channel.put(Obj.UNKOBJ, Att.COMCHA); } + private static final EnumMap Character = new EnumMap<>(Obj.class); static { Character.put(Obj.UNKOBJ, Att.LITCHR); } + private static final EnumMap Clearance_height = new EnumMap<>(Obj.class); static { Clearance_height.put(Obj.UNKOBJ, Att.VERCLR); } + private static final EnumMap Clearance_height_closed = new EnumMap<>(Obj.class); static { Clearance_height_closed.put(Obj.UNKOBJ, Att.VERCCL); } + private static final EnumMap Clearance_height_open = new EnumMap<>(Obj.class); static { Clearance_height_open.put(Obj.UNKOBJ, Att.VERCOP); } + private static final EnumMap Clearance_height_safe = new EnumMap<>(Obj.class); static { Clearance_height_safe.put(Obj.UNKOBJ, Att.VERCSA); } + private static final EnumMap Clearance_width = new EnumMap<>(Obj.class); static { Clearance_width.put(Obj.UNKOBJ, Att.HORCLR); } + private static final EnumMap Colour = new EnumMap<>(Obj.class); static { Colour.put(Obj.UNKOBJ, Att.COLOUR); } + private static final EnumMap Colour_pattern = new EnumMap<>(Obj.class); static { Colour_pattern.put(Obj.UNKOBJ, Att.COLPAT); } + private static final EnumMap Communication = new EnumMap<>(Obj.class); static { Communication.put(Obj.UNKOBJ, Att.COMCTN); } + private static final EnumMap Condition = new EnumMap<>(Obj.class); static { Condition.put(Obj.UNKOBJ, Att.CONDTN); } + private static final EnumMap Conspicuity = new EnumMap<>(Obj.class); static { Conspicuity.put(Obj.UNKOBJ, Att.CONVIS); } + private static final EnumMap Construction = new EnumMap<>(Obj.class); static { Construction.put(Obj.UNKOBJ, Att.NATCON); } + private static final EnumMap Danger_class = new EnumMap<>(Obj.class); static { Danger_class.put(Obj.UNKOBJ, Att.CLSDNG); } + private static final EnumMap Depth = new EnumMap<>(Obj.class); static { Depth.put(Obj.UNKOBJ, Att.VALDCO); Depth.put(Obj.SOUNDG, Att.VALSOU); } + private static final EnumMap Depth_buried = new EnumMap<>(Obj.class); static { Depth_buried.put(Obj.UNKOBJ, Att.BURDEP); } + private static final EnumMap Description = new EnumMap<>(Obj.class); static { Description.put(Obj.UNKOBJ, Att.TXTDSC); } + private static final EnumMap Distance = new EnumMap<>(Obj.class); static { Distance.put(Obj.UNKOBJ, Att.WTWDIS); } + private static final EnumMap Distance_down = new EnumMap<>(Obj.class); static { Distance_down.put(Obj.UNKOBJ, Att.DISIPD); } + private static final EnumMap Distance_end = new EnumMap<>(Obj.class); static { Distance_end.put(Obj.UNKOBJ, Att.DISBK2); } + private static final EnumMap Distance_start = new EnumMap<>(Obj.class); static { Distance_start.put(Obj.UNKOBJ, Att.DISBK1); } + private static final EnumMap Distance_up = new EnumMap<>(Obj.class); static { Distance_up.put(Obj.UNKOBJ, Att.DISIPU); } + private static final EnumMap Elevation = new EnumMap<>(Obj.class); static { Elevation.put(Obj.UNKOBJ, Att.ELEVAT); } + private static final EnumMap End_date = new EnumMap<>(Obj.class); static { End_date.put(Obj.UNKOBJ, Att.DATEND); } + private static final EnumMap End_time = new EnumMap<>(Obj.class); static { End_time.put(Obj.UNKOBJ, Att.TIMEND); } + private static final EnumMap Estimated_range = new EnumMap<>(Obj.class); static { Estimated_range.put(Obj.UNKOBJ, Att.ESTRNG); } + private static final EnumMap Exhibition = new EnumMap<>(Obj.class); static { Exhibition.put(Obj.UNKOBJ, Att.EXCLIT); } + private static final EnumMap Exposition = new EnumMap<>(Obj.class); static { Exposition.put(Obj.UNKOBJ, Att.EXPSOU); } + private static final EnumMap Factor = new EnumMap<>(Obj.class); static { Factor.put(Obj.UNKOBJ, Att.ICEFAC); } + private static final EnumMap Frequency = new EnumMap<>(Obj.class); static { Frequency.put(Obj.UNKOBJ, Att.SIGFRQ); } + private static final EnumMap Function = new EnumMap<>(Obj.class); static { Function.put(Obj.BUISGL, Att.FUNCTN); Function.put(Obj.LNDMRK, Att.FUNCTN); Function.put(Obj.NOTMRK, Att.FNCTNM); } + private static final EnumMap Generation = new EnumMap<>(Obj.class); static { Generation.put(Obj.UNKOBJ, Att.SIGGEN); } + private static final EnumMap Goods = new EnumMap<>(Obj.class); static { Goods.put(Obj.UNKOBJ, Att.TRSHGD); } + private static final EnumMap Gravity_reference = new EnumMap<>(Obj.class); static { Gravity_reference.put(Obj.UNKOBJ, Att.REFLEV); } + private static final EnumMap Group = new EnumMap<>(Obj.class); static { Group.put(Obj.UNKOBJ, Att.SIGGRP); } + private static final EnumMap Height = new EnumMap<>(Obj.class); static { Height.put(Obj.UNKOBJ, Att.HEIGHT); } + private static final EnumMap High_name = new EnumMap<>(Obj.class); static { High_name.put(Obj.UNKOBJ, Att.HIGNAM); } + private static final EnumMap High_value = new EnumMap<>(Obj.class); static { High_value.put(Obj.UNKOBJ, Att.HIGWAT); } + private static final EnumMap High_velocity = new EnumMap<>(Obj.class); static { High_velocity.put(Obj.UNKOBJ, Att.CURVHW); } + private static final EnumMap Horizontal_clearance_length = new EnumMap<>(Obj.class); static { Horizontal_clearance_length.put(Obj.UNKOBJ, Att.HORCLL); } + private static final EnumMap Horizontal_clearance_width = new EnumMap<>(Obj.class); static { Horizontal_clearance_width.put(Obj.UNKOBJ, Att.HORCLW); } + private static final EnumMap Horizontal_datum = new EnumMap<>(Obj.class); static { Horizontal_datum.put(Obj.UNKOBJ, Att.HORDAT); } + private static final EnumMap Impact = new EnumMap<>(Obj.class); static { Impact.put(Obj.UNKOBJ, Att.DIRIMP); } + private static final EnumMap Information = new EnumMap<>(Obj.class); static { Information.put(Obj.UNKOBJ, Att.INFORM); } + private static final EnumMap Jurisdiction = new EnumMap<>(Obj.class); static { Jurisdiction.put(Obj.UNKOBJ, Att.JRSDTN); } + private static final EnumMap Length = new EnumMap<>(Obj.class); static { Length.put(Obj.UNKOBJ, Att.HORLEN); } + private static final EnumMap Local_name = new EnumMap<>(Obj.class); static { Local_name.put(Obj.UNKOBJ, Att.OTHNAM); } + private static final EnumMap Local_value = new EnumMap<>(Obj.class); static { Local_value.put(Obj.UNKOBJ, Att.OTHWAT); } + private static final EnumMap Low_name = new EnumMap<>(Obj.class); static { Low_name.put(Obj.UNKOBJ, Att.LOWNAM); } + private static final EnumMap Low_value = new EnumMap<>(Obj.class); static { Low_value.put(Obj.UNKOBJ, Att.LOWWAT); } + private static final EnumMap Low_velocity = new EnumMap<>(Obj.class); static { Low_velocity.put(Obj.UNKOBJ, Att.CURVLW); } + private static final EnumMap Maximum_depth = new EnumMap<>(Obj.class); static { Maximum_depth.put(Obj.UNKOBJ, Att.DRVAL2); } + private static final EnumMap Maximum_elevation = new EnumMap<>(Obj.class); static { Maximum_elevation.put(Obj.UNKOBJ, Att.ELEVA2); } + private static final EnumMap Maximum_load = new EnumMap<>(Obj.class); static { Maximum_load.put(Obj.UNKOBJ, Att.LIFCAP); } + private static final EnumMap Maximum_range = new EnumMap<>(Obj.class); static { Maximum_range.put(Obj.UNKOBJ, Att.VALMXR); } + private static final EnumMap Maximum_sounding = new EnumMap<>(Obj.class); static { Maximum_sounding.put(Obj.UNKOBJ, Att.SDISMX); } + private static final EnumMap Mean_name = new EnumMap<>(Obj.class); static { Mean_name.put(Obj.UNKOBJ, Att.MEANAM); } + private static final EnumMap Mean_value = new EnumMap<>(Obj.class); static { Mean_value.put(Obj.UNKOBJ, Att.MEAWAT); } + private static final EnumMap Mean_velocity = new EnumMap<>(Obj.class); static { Mean_velocity.put(Obj.UNKOBJ, Att.CURVMW); } + private static final EnumMap Message = new EnumMap<>(Obj.class); static { Message.put(Obj.UNKOBJ, Att.UPDMSG); } + private static final EnumMap Minimum_depth = new EnumMap<>(Obj.class); static { Minimum_depth.put(Obj.UNKOBJ, Att.DRVAL1); } + private static final EnumMap Minimum_elevation = new EnumMap<>(Obj.class); static { Minimum_elevation.put(Obj.UNKOBJ, Att.ELEVA1); } + private static final EnumMap Minimum_sounding = new EnumMap<>(Obj.class); static { Minimum_sounding.put(Obj.UNKOBJ, Att.SDISMN); } + private static final EnumMap Multiple = new EnumMap<>(Obj.class); static { Multiple.put(Obj.UNKOBJ, Att.MLTYLT); } + private static final EnumMap Name = new EnumMap<>(Obj.class); static { Name.put(Obj.UNKOBJ, Att.OBJNAM); } + private static final EnumMap National_information = new EnumMap<>(Obj.class); static { National_information.put(Obj.UNKOBJ, Att.NINFOM); } + private static final EnumMap Nationality = new EnumMap<>(Obj.class); static { Nationality.put(Obj.UNKOBJ, Att.NATION); } + private static final EnumMap National_description = new EnumMap<>(Obj.class); static { National_description.put(Obj.UNKOBJ, Att.NTXTDS); } + private static final EnumMap National_name = new EnumMap<>(Obj.class); static { National_name.put(Obj.UNKOBJ, Att.NOBJNM); } + private static final EnumMap National_pilot_district = new EnumMap<>(Obj.class); static { National_pilot_district.put(Obj.UNKOBJ, Att.NPLDST); } + private static final EnumMap Nm_date = new EnumMap<>(Obj.class); static { Nm_date.put(Obj.UNKOBJ, Att.NMDATE); } + private static final EnumMap Other_velocity = new EnumMap<>(Obj.class); static { Other_velocity.put(Obj.UNKOBJ, Att.CURVOW); } + private static final EnumMap Operation = new EnumMap<>(Obj.class); static { Operation.put(Obj.UNKOBJ, Att.CATTAB); } + private static final EnumMap Orientation = new EnumMap<>(Obj.class); static { Orientation.put(Obj.UNKOBJ, Att.ORIENT); } + private static final EnumMap Passing_time = new EnumMap<>(Obj.class); static { Passing_time.put(Obj.UNKOBJ, Att.APTREF); } + private static final EnumMap Period = new EnumMap<>(Obj.class); static { Period.put(Obj.UNKOBJ, Att.SIGPER); } + private static final EnumMap Period_end = new EnumMap<>(Obj.class); static { Period_end.put(Obj.UNKOBJ, Att.PEREND); } + private static final EnumMap Period_start = new EnumMap<>(Obj.class); static { Period_start.put(Obj.UNKOBJ, Att.PERSTA); } + private static final EnumMap Pilot_district = new EnumMap<>(Obj.class); static { Pilot_district.put(Obj.UNKOBJ, Att.PILDST); } + private static final EnumMap Position_quality = new EnumMap<>(Obj.class); static { Position_quality.put(Obj.UNKOBJ, Att.QUAPOS); } + private static final EnumMap Positional_accuracy = new EnumMap<>(Obj.class); static { Positional_accuracy.put(Obj.UNKOBJ, Att.POSACC); } + private static final EnumMap Producing_country = new EnumMap<>(Obj.class); static { Producing_country.put(Obj.UNKOBJ, Att.PRCTRY); } + private static final EnumMap Product = new EnumMap<>(Obj.class); static { Product.put(Obj.UNKOBJ, Att.PRODCT); } + private static final EnumMap Quality = new EnumMap<>(Obj.class); static { Quality.put(Obj.UNKOBJ, Att.QUASOU); } + private static final EnumMap Radius = new EnumMap<>(Obj.class); static { Radius.put(Obj.UNKOBJ, Att.RADIUS); Radius.put(Obj.LIGHTS, Att.LITRAD); } + private static final EnumMap Range = new EnumMap<>(Obj.class); static { Range.put(Obj.UNKOBJ, Att.VALNMR); } + private static final EnumMap Reference = new EnumMap<>(Obj.class); static { Reference.put(Obj.UNKOBJ, Att.PUBREF); } + private static final EnumMap Reflectivity = new EnumMap<>(Obj.class); static { Reflectivity.put(Obj.UNKOBJ, Att.CONRAD); } + private static final EnumMap Restriction = new EnumMap<>(Obj.class); static { Restriction.put(Obj.UNKOBJ, Att.RESTRN); } + private static final EnumMap Schedule = new EnumMap<>(Obj.class); static { Schedule.put(Obj.UNKOBJ, Att.SCHREF); } + private static final EnumMap Shape = new EnumMap<>(Obj.class); static { Shape.put(Obj.BCNCAR, Att.BCNSHP); Shape.put(Obj.BCNISD, Att.BCNSHP); Shape.put(Obj.BCNLAT, Att.BCNSHP); Shape.put(Obj.BCNSAW, Att.BCNSHP); Shape.put(Obj.BCNSPP, Att.BCNSHP); Shape.put(Obj.BUISGL, Att.BUISHP); Shape.put(Obj.BOYCAR, Att.BOYSHP); Shape.put(Obj.BOYISD, Att.BOYSHP); Shape.put(Obj.BOYLAT, Att.BOYSHP); Shape.put(Obj.BOYSAW, Att.BOYSHP); Shape.put(Obj.BOYSPP, Att.BOYSHP); @@ -275,36 +275,36 @@ Shape.put(Obj.SILTNK, Att.BUISHP); } - private static final EnumMap Sector_end = new EnumMap(Obj.class); static { Sector_end.put(Obj.UNKOBJ, Att.SECTR2); } - private static final EnumMap Sector_start = new EnumMap(Obj.class); static { Sector_start.put(Obj.UNKOBJ, Att.SECTR1); } - private static final EnumMap Sequence = new EnumMap(Obj.class); static { Sequence.put(Obj.UNKOBJ, Att.SIGSEQ); } - private static final EnumMap Shift = new EnumMap(Obj.class); static { Shift.put(Obj.UNKOBJ, Att.SHIPAM); } - private static final EnumMap Ship = new EnumMap(Obj.class); static { Ship.put(Obj.UNKOBJ, Att.SHPTYP); } - private static final EnumMap Sounding_accuracy = new EnumMap(Obj.class); static { Sounding_accuracy.put(Obj.UNKOBJ, Att.SOUACC); } - private static final EnumMap Sounding_name = new EnumMap(Obj.class); static { Sounding_name.put(Obj.UNKOBJ, Att.SDRLEV); } - private static final EnumMap Start_date = new EnumMap(Obj.class); static { Start_date.put(Obj.UNKOBJ, Att.DATSTA); } - private static final EnumMap Start_time = new EnumMap(Obj.class); static { Start_time.put(Obj.UNKOBJ, Att.TIMSTA); } - private static final EnumMap Status = new EnumMap(Obj.class); static { Status.put(Obj.UNKOBJ, Att.STATUS); } - private static final EnumMap Surface = new EnumMap(Obj.class); static { Surface.put(Obj.UNKOBJ, Att.NATSUR); } - private static final EnumMap Surface_qualification = new EnumMap(Obj.class); static { Surface_qualification.put(Obj.UNKOBJ, Att.NATQUA); } - private static final EnumMap Survey = new EnumMap(Obj.class); static { Survey.put(Obj.UNKOBJ, Att.SURTYP); } - private static final EnumMap Survey_end = new EnumMap(Obj.class); static { Survey_end.put(Obj.UNKOBJ, Att.SUREND); } - private static final EnumMap Survey_start = new EnumMap(Obj.class); static { Survey_start.put(Obj.UNKOBJ, Att.SURSTA); } - private static final EnumMap System = new EnumMap(Obj.class); static { System.put(Obj.UNKOBJ, Att.MARSYS); } - private static final EnumMap Technique = new EnumMap(Obj.class); static { Technique.put(Obj.UNKOBJ, Att.TECSOU); } - private static final EnumMap Traffic_flow = new EnumMap(Obj.class); static { Traffic_flow.put(Obj.UNKOBJ, Att.TRAFIC); } - private static final EnumMap Units = new EnumMap(Obj.class); static { Units.put(Obj.UNKOBJ, Att.HUNITS); } - private static final EnumMap Use = new EnumMap(Obj.class); static { Use.put(Obj.UNKOBJ, Att.USESHP); } - private static final EnumMap Variation = new EnumMap(Obj.class); static { Variation.put(Obj.UNKOBJ, Att.VALMAG); } - private static final EnumMap Variation_change = new EnumMap(Obj.class); static { Variation_change.put(Obj.UNKOBJ, Att.VALACM); } - private static final EnumMap Velocity = new EnumMap(Obj.class); static { Velocity.put(Obj.UNKOBJ, Att.CURVEL); } - private static final EnumMap Vertical_accuracy = new EnumMap(Obj.class); static { Vertical_accuracy.put(Obj.UNKOBJ, Att.VERACC); } - private static final EnumMap Vertical_datum = new EnumMap(Obj.class); static { Vertical_datum.put(Obj.UNKOBJ, Att.VERDAT); } - private static final EnumMap Vertical_length = new EnumMap(Obj.class); static { Vertical_length.put(Obj.UNKOBJ, Att.VERLEN); } - private static final EnumMap Vertical_name = new EnumMap(Obj.class); static { Vertical_name.put(Obj.UNKOBJ, Att.VCRLEV); } - private static final EnumMap Visibility = new EnumMap(Obj.class); static { Visibility.put(Obj.UNKOBJ, Att.LITVIS); } - private static final EnumMap Water_level = new EnumMap(Obj.class); static { Water_level.put(Obj.UNKOBJ, Att.WATLEV); } - private static final EnumMap Wavelength = new EnumMap(Obj.class); static { Wavelength.put(Obj.UNKOBJ, Att.RADWAL); } - private static final EnumMap Width = new EnumMap(Obj.class); static { Width.put(Obj.UNKOBJ, Att.HORWID); } - private static final EnumMap Year = new EnumMap(Obj.class); static { Year.put(Obj.UNKOBJ, Att.RYRMGV); } + private static final EnumMap Sector_end = new EnumMap<>(Obj.class); static { Sector_end.put(Obj.UNKOBJ, Att.SECTR2); } + private static final EnumMap Sector_start = new EnumMap<>(Obj.class); static { Sector_start.put(Obj.UNKOBJ, Att.SECTR1); } + private static final EnumMap Sequence = new EnumMap<>(Obj.class); static { Sequence.put(Obj.UNKOBJ, Att.SIGSEQ); } + private static final EnumMap Shift = new EnumMap<>(Obj.class); static { Shift.put(Obj.UNKOBJ, Att.SHIPAM); } + private static final EnumMap Ship = new EnumMap<>(Obj.class); static { Ship.put(Obj.UNKOBJ, Att.SHPTYP); } + private static final EnumMap Sounding_accuracy = new EnumMap<>(Obj.class); static { Sounding_accuracy.put(Obj.UNKOBJ, Att.SOUACC); } + private static final EnumMap Sounding_name = new EnumMap<>(Obj.class); static { Sounding_name.put(Obj.UNKOBJ, Att.SDRLEV); } + private static final EnumMap Start_date = new EnumMap<>(Obj.class); static { Start_date.put(Obj.UNKOBJ, Att.DATSTA); } + private static final EnumMap Start_time = new EnumMap<>(Obj.class); static { Start_time.put(Obj.UNKOBJ, Att.TIMSTA); } + private static final EnumMap Status = new EnumMap<>(Obj.class); static { Status.put(Obj.UNKOBJ, Att.STATUS); } + private static final EnumMap Surface = new EnumMap<>(Obj.class); static { Surface.put(Obj.UNKOBJ, Att.NATSUR); } + private static final EnumMap Surface_qualification = new EnumMap<>(Obj.class); static { Surface_qualification.put(Obj.UNKOBJ, Att.NATQUA); } + private static final EnumMap Survey = new EnumMap<>(Obj.class); static { Survey.put(Obj.UNKOBJ, Att.SURTYP); } + private static final EnumMap Survey_end = new EnumMap<>(Obj.class); static { Survey_end.put(Obj.UNKOBJ, Att.SUREND); } + private static final EnumMap Survey_start = new EnumMap<>(Obj.class); static { Survey_start.put(Obj.UNKOBJ, Att.SURSTA); } + private static final EnumMap System = new EnumMap<>(Obj.class); static { System.put(Obj.UNKOBJ, Att.MARSYS); } + private static final EnumMap Technique = new EnumMap<>(Obj.class); static { Technique.put(Obj.UNKOBJ, Att.TECSOU); } + private static final EnumMap Traffic_flow = new EnumMap<>(Obj.class); static { Traffic_flow.put(Obj.UNKOBJ, Att.TRAFIC); } + private static final EnumMap Units = new EnumMap<>(Obj.class); static { Units.put(Obj.UNKOBJ, Att.HUNITS); } + private static final EnumMap Use = new EnumMap<>(Obj.class); static { Use.put(Obj.UNKOBJ, Att.USESHP); } + private static final EnumMap Variation = new EnumMap<>(Obj.class); static { Variation.put(Obj.UNKOBJ, Att.VALMAG); } + private static final EnumMap Variation_change = new EnumMap<>(Obj.class); static { Variation_change.put(Obj.UNKOBJ, Att.VALACM); } + private static final EnumMap Velocity = new EnumMap<>(Obj.class); static { Velocity.put(Obj.UNKOBJ, Att.CURVEL); } + private static final EnumMap Vertical_accuracy = new EnumMap<>(Obj.class); static { Vertical_accuracy.put(Obj.UNKOBJ, Att.VERACC); } + private static final EnumMap Vertical_datum = new EnumMap<>(Obj.class); static { Vertical_datum.put(Obj.UNKOBJ, Att.VERDAT); } + private static final EnumMap Vertical_length = new EnumMap<>(Obj.class); static { Vertical_length.put(Obj.UNKOBJ, Att.VERLEN); } + private static final EnumMap Vertical_name = new EnumMap<>(Obj.class); static { Vertical_name.put(Obj.UNKOBJ, Att.VCRLEV); } + private static final EnumMap Visibility = new EnumMap<>(Obj.class); static { Visibility.put(Obj.UNKOBJ, Att.LITVIS); } + private static final EnumMap Water_level = new EnumMap<>(Obj.class); static { Water_level.put(Obj.UNKOBJ, Att.WATLEV); } + private static final EnumMap Wavelength = new EnumMap<>(Obj.class); static { Wavelength.put(Obj.UNKOBJ, Att.RADWAL); } + private static final EnumMap Width = new EnumMap<>(Obj.class); static { Width.put(Obj.UNKOBJ, Att.HORWID); } + private static final EnumMap Year = new EnumMap<>(Obj.class); static { Year.put(Obj.UNKOBJ, Att.RYRMGV); } private static final HashMap> StrAtt = new HashMap>(); Index: /applications/editors/josm/plugins/seachart/src/s57/S57box.java =================================================================== --- /applications/editors/josm/plugins/seachart/src/s57/S57box.java (revision 31846) +++ /applications/editors/josm/plugins/seachart/src/s57/S57box.java (revision 31846) @@ -0,0 +1,238 @@ +/* Copyright 2014 Malcolm Herring + * + * This is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, version 3 of the License. + * + * For a copy of the GNU General Public License, see . + */ + +package s57; + +import java.util.ArrayList; + +import s57.S57map.*; +import s57.S57obj.*; + +public class S57box { //S57 bounding box truncation + + enum Ext {I, N, W, S, E } + + public static void bBox(S57map map) { + /* Truncations + * Points: delete point features outside BB + * Lines: Truncate edges at BB boundaries + * Areas: Truncate edges of outers & inners and add new border edges. Merge inners to outer where necessary + * Remove nodes outside BB + * Remove edges that are completely outside BB + */ + class Land { + long first; + Snode start; + Ext sbound; + long last; + Snode end; + Ext ebound; + Feature land; + + Land(Feature l) { + land = l; + first = last = 0; + start = end = null; + sbound = ebound = Ext.I; + } + } + if (map.features.get(Obj.COALNE) != null) { + ArrayList coasts = new ArrayList<>(); + ArrayList lands = new ArrayList<>(); + if (map.features.get(Obj.LNDARE) == null) { + map.features.put(Obj.LNDARE, new ArrayList()); + } + for (Feature feature : map.features.get(Obj.COALNE)) { + Feature land = map.new Feature(); + land.id = ++map.xref; + land.type = Obj.LNDARE; + land.reln = Rflag.MASTER; + land.objs.put(Obj.LNDARE, map.new ObjTab()); + land.objs.get(Obj.LNDARE).put(0, map.new AttMap()); + if (feature.geom.prim == Pflag.AREA) { + land.geom = feature.geom; + map.features.get(Obj.LNDARE).add(land); + } else if (feature.geom.prim == Pflag.LINE) { + land.geom.prim = Pflag.LINE; + land.geom.elems.addAll(feature.geom.elems); + coasts.add(land); + } + } + while (coasts.size() > 0) { + Feature land = coasts.remove(0); + Edge fedge = map.edges.get(land.geom.elems.get(0).id); + long first = fedge.first; + long last = map.edges.get(land.geom.elems.get(land.geom.elems.size() - 1).id).last; + if (coasts.size() > 0) { + boolean added = true; + while (added) { + added = false; + for (int i = 0; i < coasts.size(); i++) { + Feature coast = coasts.get(i); + Edge edge = map.edges.get(coast.geom.elems.get(0).id); + if (edge.first == last) { + land.geom.elems.add(coast.geom.elems.get(0)); + last = edge.last; + coasts.remove(i--); + added = true; + } else if (edge.last == first) { + land.geom.elems.add(0, coast.geom.elems.get(0)); + first = edge.first; + coasts.remove(i--); + added = true; + } + } + } + } + lands.add(new Land(land)); + } + ArrayList islands = new ArrayList<>(); + for (Land land : lands) { + map.sortGeom(land.land); + if (land.land.geom.prim == Pflag.AREA) { + islands.add(land); + map.features.get(Obj.LNDARE).add(land.land); + } + } + for (Land island : islands) { + lands.remove(island); + } + for (Land land : lands) { + GeomIterator git = map.new GeomIterator(land.land.geom); + Snode prev = null; + Ext bprev = Ext.I; + Ext ext; + land.ebound = land.sbound = Ext.I; + while (git.hasComp()) { + git.nextComp(); + while (git.hasEdge()) { + git.nextEdge(); + while (git.hasNode()) { + long ref = git.nextRef(false); + Snode node = map.nodes.get(ref); + if (node == null) + continue; + if (land.first == 0) { + land.first = ref; + } + if (prev == null) { + prev = node; + } + if ((node.lat >= map.bounds.maxlat) && (node.lon < map.bounds.maxlon)) { + ext = Ext.N; + } else if (node.lon <= map.bounds.minlon) { + ext = Ext.W; + } else if (node.lat <= map.bounds.minlat) { + ext = Ext.S; + } else if (node.lon >= map.bounds.maxlon) { + ext = Ext.E; + } else { + ext = Ext.I; + } + if (ext == Ext.I) { + if (land.start == null) { + land.start = prev; + land.sbound = bprev; + } + land.end = null; + land.ebound = Ext.I; + } else { + if ((land.start != null) && (land.end == null)) { + land.end = node; + land.ebound = ext; + } + } + prev = node; + bprev = ext; + land.last = ref; + } + } + } + } + islands = new ArrayList<>(); + for (Land land : lands) { + if ((land.sbound == Ext.I) || (land.ebound == Ext.I)) { + islands.add(land); + } + } + for (Land island : islands) { + lands.remove(island); + } + while (lands.size() > 0) { + Land land = lands.get(0); + Edge nedge = map.new Edge(); + nedge.first = land.last; + Ext bound = land.ebound; + Snode last = land.end; + double delta = Math.PI; + int idx = -1; + Land next = null; + while (idx < 0) { + for (int i = 0; i < lands.size(); i++) { + next = lands.get(i); + if (next.sbound == bound) { + double diff = -Math.PI; + switch (bound) { + case N: + diff = last.lon - next.start.lon; + break; + case W: + diff = last.lat - next.start.lat; + break; + case S: + diff = next.start.lon - last.lon; + break; + case E: + diff = next.start.lat - last.lat; + break; + default: + continue; + } + if ((diff >= 0.0) && (diff < delta)) { + delta = diff; + idx = i; + } + } + } + if (idx < 0) { + long ref = (long) bound.ordinal(); + last = map.nodes.get(ref); + nedge.nodes.add(ref); + ref = ref < 4 ? ++ref : 1; + for (Ext e : Ext.values()) { + if (ref == e.ordinal()) { + bound = e; + break; + } + } + } + } + next = lands.get(idx); + nedge.last = next.first; + map.edges.put(++map.xref, nedge); + land.land.geom.elems.add(map.new Prim(map.xref)); + if (next != land) { + land.land.geom.elems.addAll(next.land.geom.elems); + land.ebound = next.ebound; + land.end = next.end; + land.last = next.last; + lands.remove(idx); + } + map.sortGeom(land.land); + if (land.land.geom.prim == Pflag.AREA) { + map.features.get(Obj.LNDARE).add(land.land); + lands.remove(land); + } + } + } + return; + + } + +} Index: /applications/editors/josm/plugins/seachart/src/s57/S57dat.java =================================================================== --- /applications/editors/josm/plugins/seachart/src/s57/S57dat.java (revision 31845) +++ /applications/editors/josm/plugins/seachart/src/s57/S57dat.java (revision 31846) @@ -13,4 +13,7 @@ import java.util.*; +import s57.S57map.*; +import s57.S57obj.*; + public class S57dat { // S57 ENC file fields lookup tables & methods @@ -29,5 +32,5 @@ VPUI, VPIX, NVPT, TOPI, CCUI, CCIX, CCNC, YCOO, XCOO, VE3D, ATYP, SURF, ORDR, RESO, STPT, CTPT, ENPT, CDPM, CDPR } - private static final EnumMap convs = new EnumMap(S57subf.class); + private static final EnumMap convs = new EnumMap<>(S57subf.class); static { convs.put(S57subf.I8RN, new S57conv(5,2)); @@ -80,50 +83,50 @@ FRID, FOID, LNAM, ATTF, NATF, FFPC, FFPT, FSPC, FSPT, VRID, ATTV, VRPC, VRPT, SGCC, SG2D, SG3D, ARCC, AR2D, EL2D, CT2D } - private static ArrayList S57i8ri = new ArrayList(Arrays.asList(S57subf.I8RN)); - private static ArrayList S57dsid = new ArrayList(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.EXPP, S57subf.INTU, S57subf.DSNM, S57subf.EDTN, S57subf.UPDN, + private static ArrayList S57i8ri = new ArrayList<>(Arrays.asList(S57subf.I8RN)); + private static ArrayList S57dsid = new ArrayList<>(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.EXPP, S57subf.INTU, S57subf.DSNM, S57subf.EDTN, S57subf.UPDN, S57subf.UADT, S57subf.ISDT, S57subf.STED, S57subf.PRSP, S57subf.PSDN, S57subf.PRED, S57subf.PROF, S57subf.AGEN, S57subf.COMT)); - private static ArrayList S57dssi = new ArrayList(Arrays.asList(S57subf.DSTR, S57subf.AALL, S57subf.NALL, S57subf.NOMR, S57subf.NOCR, S57subf.NOGR, S57subf.NOLR, + private static ArrayList S57dssi = new ArrayList<>(Arrays.asList(S57subf.DSTR, S57subf.AALL, S57subf.NALL, S57subf.NOMR, S57subf.NOCR, S57subf.NOGR, S57subf.NOLR, S57subf.NOIN, S57subf.NOCN, S57subf.NOED, S57subf.NOFA )); - private static ArrayList S57dspm = new ArrayList(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.HDAT, S57subf.VDAT, S57subf.SDAT, S57subf.CSCL, S57subf.DUNI, + private static ArrayList S57dspm = new ArrayList<>(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.HDAT, S57subf.VDAT, S57subf.SDAT, S57subf.CSCL, S57subf.DUNI, S57subf.HUNI, S57subf.PUNI, S57subf.COUN, S57subf.COMF, S57subf.SOMF, S57subf.COMT )); - private static ArrayList S57dspr = new ArrayList(Arrays.asList(S57subf.PROJ, S57subf.PRP1, S57subf.PRP2, S57subf.PRP3, S57subf.PRP4, S57subf.FEAS, S57subf.FNOR, + private static ArrayList S57dspr = new ArrayList<>(Arrays.asList(S57subf.PROJ, S57subf.PRP1, S57subf.PRP2, S57subf.PRP3, S57subf.PRP4, S57subf.FEAS, S57subf.FNOR, S57subf.FPMF, S57subf.COMT )); - private static ArrayList S57dsrc = new ArrayList(Arrays.asList(S57subf.RPID, S57subf.RYCO, S57subf.RXCO, S57subf.CURP, S57subf.FPMF, S57subf.RXVL, S57subf.RYVL, + private static ArrayList S57dsrc = new ArrayList<>(Arrays.asList(S57subf.RPID, S57subf.RYCO, S57subf.RXCO, S57subf.CURP, S57subf.FPMF, S57subf.RXVL, S57subf.RYVL, S57subf.COMT )); - private static ArrayList S57dsht = new ArrayList(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.PRCO, S57subf.ESDT, S57subf.LSDT, S57subf.DCRT, S57subf.CODT, S57subf.COMT )); - private static ArrayList S57dsac = new ArrayList(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.PACC, S57subf.HACC, S57subf.SACC, S57subf.FPMF, S57subf.COMT )); - private static ArrayList S57catd = new ArrayList(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.FILE, S57subf.LFIL, S57subf.VOLM, S57subf.IMPL, S57subf.SLAT, + private static ArrayList S57dsht = new ArrayList<>(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.PRCO, S57subf.ESDT, S57subf.LSDT, S57subf.DCRT, S57subf.CODT, S57subf.COMT )); + private static ArrayList S57dsac = new ArrayList<>(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.PACC, S57subf.HACC, S57subf.SACC, S57subf.FPMF, S57subf.COMT )); + private static ArrayList S57catd = new ArrayList<>(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.FILE, S57subf.LFIL, S57subf.VOLM, S57subf.IMPL, S57subf.SLAT, S57subf.WLON, S57subf.NLAT, S57subf.ELON, S57subf.CRCS, S57subf.COMT )); - private static ArrayList S57catx = new ArrayList(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.NAM1, S57subf.NAM2, S57subf.COMT )); - private static ArrayList S57dddf = new ArrayList(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.OORA, S57subf.OAAC, S57subf.OACO, S57subf.OALL, S57subf.OATY, + private static ArrayList S57catx = new ArrayList<>(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.NAM1, S57subf.NAM2, S57subf.COMT )); + private static ArrayList S57dddf = new ArrayList<>(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.OORA, S57subf.OAAC, S57subf.OACO, S57subf.OALL, S57subf.OATY, S57subf.DEFN, S57subf.AUTH, S57subf.COMT )); - private static ArrayList S57dddr = new ArrayList(Arrays.asList(S57subf.RFTP, S57subf.RFVL )); - private static ArrayList S57dddi = new ArrayList(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.ATLB, S57subf.ATDO, S57subf.ADMU, S57subf.ADFT, S57subf.AUTH, S57subf.COMT )); - private static ArrayList S57ddom = new ArrayList(Arrays.asList(S57subf.RAVA, S57subf.DVAL, S57subf.DVSD, S57subf.DEFN, S57subf.AUTH )); - private static ArrayList S57ddrf = new ArrayList(Arrays.asList(S57subf.RFTP, S57subf.RFVL )); - private static ArrayList S57ddsi = new ArrayList(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.OBLB )); - private static ArrayList S57ddsc = new ArrayList(Arrays.asList(S57subf.ATLB, S57subf.ASET, S57subf.AUTH )); - private static ArrayList S57frid = new ArrayList(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.PRIM, S57subf.GRUP, S57subf.OBJL, S57subf.RVER, S57subf.RUIN )); - private static ArrayList S57foid = new ArrayList(Arrays.asList(S57subf.AGEN, S57subf.FIDN, S57subf.FIDS )); - private static ArrayList S57lnam = new ArrayList(Arrays.asList(S57subf.LNAM)); - private static ArrayList S57attf = new ArrayList(Arrays.asList(S57subf.ATTL, S57subf.ATVL )); - private static ArrayList S57natf = new ArrayList(Arrays.asList(S57subf.ATTL, S57subf.ATVL )); - private static ArrayList S57ffpc = new ArrayList(Arrays.asList(S57subf.FFUI, S57subf.FFIX, S57subf.NFPT )); - private static ArrayList S57ffpt = new ArrayList(Arrays.asList(S57subf.LNAM, S57subf.RIND, S57subf.COMT )); - private static ArrayList S57fspc = new ArrayList(Arrays.asList(S57subf.FSUI, S57subf.FSIX, S57subf.NSPT )); - private static ArrayList S57fspt = new ArrayList(Arrays.asList(S57subf.NAME, S57subf.ORNT, S57subf.USAG, S57subf.MASK )); - private static ArrayList S57vrid = new ArrayList(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.RVER, S57subf.RUIN )); - private static ArrayList S57attv = new ArrayList(Arrays.asList(S57subf.ATTL, S57subf.ATVL )); - private static ArrayList S57vrpc = new ArrayList(Arrays.asList(S57subf.VPUI, S57subf.VPIX, S57subf.NVPT )); - private static ArrayList S57vrpt = new ArrayList(Arrays.asList(S57subf.NAME, S57subf.ORNT, S57subf.USAG, S57subf.TOPI, S57subf.MASK )); - private static ArrayList S57sgcc = new ArrayList(Arrays.asList(S57subf.CCUI, S57subf.CCIX, S57subf.CCNC )); - private static ArrayList S57sg2d = new ArrayList(Arrays.asList(S57subf.YCOO, S57subf.XCOO )); - private static ArrayList S57sg3d = new ArrayList(Arrays.asList(S57subf.YCOO, S57subf.XCOO, S57subf.VE3D )); - private static ArrayList S57arcc = new ArrayList(Arrays.asList(S57subf.ATYP, S57subf.SURF, S57subf.ORDR, S57subf.RESO, S57subf.FPMF )); - private static ArrayList S57ar2d = new ArrayList(Arrays.asList(S57subf.STPT, S57subf.CTPT, S57subf.ENPT, S57subf.YCOO, S57subf.XCOO )); - private static ArrayList S57el2d = new ArrayList(Arrays.asList(S57subf.STPT, S57subf.CTPT, S57subf.ENPT, S57subf.CDPM, S57subf.CDPR, S57subf.YCOO, S57subf.XCOO )); - private static ArrayList S57ct2d = new ArrayList(Arrays.asList(S57subf.YCOO, S57subf.XCOO )); - - private static final EnumMap> fields = new EnumMap>(S57field.class); + private static ArrayList S57dddr = new ArrayList<>(Arrays.asList(S57subf.RFTP, S57subf.RFVL )); + private static ArrayList S57dddi = new ArrayList<>(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.ATLB, S57subf.ATDO, S57subf.ADMU, S57subf.ADFT, S57subf.AUTH, S57subf.COMT )); + private static ArrayList S57ddom = new ArrayList<>(Arrays.asList(S57subf.RAVA, S57subf.DVAL, S57subf.DVSD, S57subf.DEFN, S57subf.AUTH )); + private static ArrayList S57ddrf = new ArrayList<>(Arrays.asList(S57subf.RFTP, S57subf.RFVL )); + private static ArrayList S57ddsi = new ArrayList<>(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.OBLB )); + private static ArrayList S57ddsc = new ArrayList<>(Arrays.asList(S57subf.ATLB, S57subf.ASET, S57subf.AUTH )); + private static ArrayList S57frid = new ArrayList<>(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.PRIM, S57subf.GRUP, S57subf.OBJL, S57subf.RVER, S57subf.RUIN )); + private static ArrayList S57foid = new ArrayList<>(Arrays.asList(S57subf.AGEN, S57subf.FIDN, S57subf.FIDS )); + private static ArrayList S57lnam = new ArrayList<>(Arrays.asList(S57subf.LNAM)); + private static ArrayList S57attf = new ArrayList<>(Arrays.asList(S57subf.ATTL, S57subf.ATVL )); + private static ArrayList S57natf = new ArrayList<>(Arrays.asList(S57subf.ATTL, S57subf.ATVL )); + private static ArrayList S57ffpc = new ArrayList<>(Arrays.asList(S57subf.FFUI, S57subf.FFIX, S57subf.NFPT )); + private static ArrayList S57ffpt = new ArrayList<>(Arrays.asList(S57subf.LNAM, S57subf.RIND, S57subf.COMT )); + private static ArrayList S57fspc = new ArrayList<>(Arrays.asList(S57subf.FSUI, S57subf.FSIX, S57subf.NSPT )); + private static ArrayList S57fspt = new ArrayList<>(Arrays.asList(S57subf.NAME, S57subf.ORNT, S57subf.USAG, S57subf.MASK )); + private static ArrayList S57vrid = new ArrayList<>(Arrays.asList(S57subf.RCNM, S57subf.RCID, S57subf.RVER, S57subf.RUIN )); + private static ArrayList S57attv = new ArrayList<>(Arrays.asList(S57subf.ATTL, S57subf.ATVL )); + private static ArrayList S57vrpc = new ArrayList<>(Arrays.asList(S57subf.VPUI, S57subf.VPIX, S57subf.NVPT )); + private static ArrayList S57vrpt = new ArrayList<>(Arrays.asList(S57subf.NAME, S57subf.ORNT, S57subf.USAG, S57subf.TOPI, S57subf.MASK )); + private static ArrayList S57sgcc = new ArrayList<>(Arrays.asList(S57subf.CCUI, S57subf.CCIX, S57subf.CCNC )); + private static ArrayList S57sg2d = new ArrayList<>(Arrays.asList(S57subf.YCOO, S57subf.XCOO )); + private static ArrayList S57sg3d = new ArrayList<>(Arrays.asList(S57subf.YCOO, S57subf.XCOO, S57subf.VE3D )); + private static ArrayList S57arcc = new ArrayList<>(Arrays.asList(S57subf.ATYP, S57subf.SURF, S57subf.ORDR, S57subf.RESO, S57subf.FPMF )); + private static ArrayList S57ar2d = new ArrayList<>(Arrays.asList(S57subf.STPT, S57subf.CTPT, S57subf.ENPT, S57subf.YCOO, S57subf.XCOO )); + private static ArrayList S57el2d = new ArrayList<>(Arrays.asList(S57subf.STPT, S57subf.CTPT, S57subf.ENPT, S57subf.CDPM, S57subf.CDPR, S57subf.YCOO, S57subf.XCOO )); + private static ArrayList S57ct2d = new ArrayList<>(Arrays.asList(S57subf.YCOO, S57subf.XCOO )); + + private static final EnumMap> fields = new EnumMap<>(S57field.class); static { fields.put(S57field.I8RI, S57i8ri); @@ -338,5 +341,5 @@ public static byte[] encRecord(int i8rn, ArrayList fparams) { - ArrayList index = new ArrayList(); + ArrayList index = new ArrayList<>(); int offset = 3; int maxlen = 3; @@ -393,3 +396,89 @@ } + enum Prims { N, P, L, A, PA, PL, LA, PLA } + private static final EnumMap S57prims = new EnumMap<>(Obj.class); + static { + S57prims.put(Obj.UNKOBJ, Prims.PLA); S57prims.put(Obj.M_COVR, Prims.A); S57prims.put(Obj.M_NSYS, Prims.A); S57prims.put(Obj.AIRARE, Prims.PA); + S57prims.put(Obj.ACHBRT, Prims.PA); S57prims.put(Obj.ACHARE, Prims.PA); S57prims.put(Obj.BCNCAR, Prims.P); S57prims.put(Obj.BCNISD, Prims.P); + S57prims.put(Obj.BCNLAT, Prims.P); S57prims.put(Obj.BCNSAW, Prims.P); S57prims.put(Obj.BCNSPP, Prims.P); S57prims.put(Obj.BERTHS, Prims.PLA); + S57prims.put(Obj.BRIDGE, Prims.PLA); S57prims.put(Obj.BUISGL, Prims.PA); S57prims.put(Obj.BUAARE, Prims.PA); S57prims.put(Obj.BOYCAR, Prims.P); + S57prims.put(Obj.BOYINB, Prims.P); S57prims.put(Obj.BOYISD, Prims.P); S57prims.put(Obj.BOYLAT, Prims.P); S57prims.put(Obj.BOYSAW, Prims.P); + S57prims.put(Obj.BOYSPP, Prims.P); S57prims.put(Obj.CBLARE, Prims.A); S57prims.put(Obj.CBLOHD, Prims.L); S57prims.put(Obj.CBLSUB, Prims.L); + S57prims.put(Obj.CANALS, Prims.A); S57prims.put(Obj.CTSARE, Prims.PA); S57prims.put(Obj.CAUSWY, Prims.LA); S57prims.put(Obj.CTNARE, Prims.PA); + S57prims.put(Obj.CHKPNT, Prims.PA); S57prims.put(Obj.CGUSTA, Prims.P); S57prims.put(Obj.COALNE, Prims.L); S57prims.put(Obj.CONZNE, Prims.A); + S57prims.put(Obj.COSARE, Prims.A); S57prims.put(Obj.CTRPNT, Prims.P); S57prims.put(Obj.CONVYR, Prims.LA); S57prims.put(Obj.CRANES, Prims.PA); + S57prims.put(Obj.CURENT, Prims.P); S57prims.put(Obj.CUSZNE, Prims.A); S57prims.put(Obj.DAMCON, Prims.LA); S57prims.put(Obj.DAYMAR, Prims.P); + S57prims.put(Obj.DWRTCL, Prims.L); S57prims.put(Obj.DWRTPT, Prims.A); S57prims.put(Obj.DEPARE, Prims.A); S57prims.put(Obj.DEPCNT, Prims.L); + S57prims.put(Obj.DISMAR, Prims.P); S57prims.put(Obj.DOCARE, Prims.A); S57prims.put(Obj.DRGARE, Prims.A); S57prims.put(Obj.DRYDOC, Prims.A); + S57prims.put(Obj.DMPGRD, Prims.PA); S57prims.put(Obj.DYKCON, Prims.L); S57prims.put(Obj.EXEZNE, Prims.A); S57prims.put(Obj.FAIRWY, Prims.A); + S57prims.put(Obj.FNCLNE, Prims.L); S57prims.put(Obj.FERYRT, Prims.LA); S57prims.put(Obj.FSHZNE, Prims.A); S57prims.put(Obj.FSHFAC, Prims.PLA); + S57prims.put(Obj.FSHGRD, Prims.A); S57prims.put(Obj.FLODOC, Prims.A); S57prims.put(Obj.FOGSIG, Prims.P); S57prims.put(Obj.FORSTC, Prims.PLA); + S57prims.put(Obj.FRPARE, Prims.A); S57prims.put(Obj.GATCON, Prims.PLA); S57prims.put(Obj.GRIDRN, Prims.PA); S57prims.put(Obj.HRBARE, Prims.A); + S57prims.put(Obj.HRBFAC, Prims.PA); S57prims.put(Obj.HULKES, Prims.PA); S57prims.put(Obj.ICEARE, Prims.A); S57prims.put(Obj.ICNARE, Prims.PA); + S57prims.put(Obj.ISTZNE, Prims.A); S57prims.put(Obj.LAKARE, Prims.A); S57prims.put(Obj.LNDARE, Prims.PLA); S57prims.put(Obj.LNDELV, Prims.PL); + S57prims.put(Obj.LNDRGN, Prims.PA); S57prims.put(Obj.LNDMRK, Prims.PLA); S57prims.put(Obj.LIGHTS, Prims.P); S57prims.put(Obj.LITFLT, Prims.P); + S57prims.put(Obj.LITVES, Prims.P); S57prims.put(Obj.LOCMAG, Prims.PLA); S57prims.put(Obj.LOKBSN, Prims.A); S57prims.put(Obj.LOGPON, Prims.PA); + S57prims.put(Obj.MAGVAR, Prims.PLA); S57prims.put(Obj.MARCUL, Prims.PLA); S57prims.put(Obj.MIPARE, Prims.PA); S57prims.put(Obj.MORFAC, Prims.PLA); + S57prims.put(Obj.MPAARE, Prims.PA); S57prims.put(Obj.NAVLNE, Prims.L); S57prims.put(Obj.OBSTRN, Prims.PLA); S57prims.put(Obj.OFSPLF, Prims.PA); + S57prims.put(Obj.OSPARE, Prims.A); S57prims.put(Obj.OILBAR, Prims.L); S57prims.put(Obj.PILPNT, Prims.P); S57prims.put(Obj.PILBOP, Prims.PA); + S57prims.put(Obj.PIPARE, Prims.PA); S57prims.put(Obj.PIPOHD, Prims.L); S57prims.put(Obj.PIPSOL, Prims.PL); S57prims.put(Obj.PONTON, Prims.LA); + S57prims.put(Obj.PRCARE, Prims.PA); S57prims.put(Obj.PRDARE, Prims.PA); S57prims.put(Obj.PYLONS, Prims.PA); S57prims.put(Obj.RADLNE, Prims.L); + S57prims.put(Obj.RADRNG, Prims.A); S57prims.put(Obj.RADRFL, Prims.P); S57prims.put(Obj.RADSTA, Prims.P); S57prims.put(Obj.RTPBCN, Prims.P); + S57prims.put(Obj.RDOCAL, Prims.PL); S57prims.put(Obj.RDOSTA, Prims.P); S57prims.put(Obj.RAILWY, Prims.L); S57prims.put(Obj.RAPIDS, Prims.PLA); + S57prims.put(Obj.RCRTCL, Prims.L); S57prims.put(Obj.RECTRC, Prims.LA); S57prims.put(Obj.RCTLPT, Prims.PA); S57prims.put(Obj.RSCSTA, Prims.P); + S57prims.put(Obj.RESARE, Prims.A); S57prims.put(Obj.RETRFL, Prims.P); S57prims.put(Obj.RIVERS, Prims.LA); S57prims.put(Obj.ROADWY, Prims.PLA); + S57prims.put(Obj.RUNWAY, Prims.PLA); S57prims.put(Obj.SNDWAV, Prims.PLA); S57prims.put(Obj.SEAARE, Prims.PA); S57prims.put(Obj.SPLARE, Prims.PA); + S57prims.put(Obj.SBDARE, Prims.PLA); S57prims.put(Obj.SLCONS, Prims.PLA); S57prims.put(Obj.SISTAT, Prims.P); S57prims.put(Obj.SISTAW, Prims.P); + S57prims.put(Obj.SILTNK, Prims.PA); S57prims.put(Obj.SLOTOP, Prims.L); S57prims.put(Obj.SLOGRD, Prims.PA); S57prims.put(Obj.SMCFAC, Prims.PA); + S57prims.put(Obj.SOUNDG, Prims.P); S57prims.put(Obj.SPRING, Prims.P); S57prims.put(Obj.STSLNE, Prims.L); S57prims.put(Obj.SUBTLN, Prims.A); + S57prims.put(Obj.SWPARE, Prims.A); S57prims.put(Obj.TESARE, Prims.A); S57prims.put(Obj.TS_PRH, Prims.PA); S57prims.put(Obj.TS_PNH, Prims.PA); + S57prims.put(Obj.TS_PAD, Prims.PA); S57prims.put(Obj.TS_TIS, Prims.PA); S57prims.put(Obj.T_HMON, Prims.PA); S57prims.put(Obj.T_NHMN, Prims.PA); + S57prims.put(Obj.T_TIMS, Prims.PA); S57prims.put(Obj.TIDEWY, Prims.LA); S57prims.put(Obj.TOPMAR, Prims.P); S57prims.put(Obj.TSELNE, Prims.LA); + S57prims.put(Obj.TSSBND, Prims.L); S57prims.put(Obj.TSSCRS, Prims.A); S57prims.put(Obj.TSSLPT, Prims.A); S57prims.put(Obj.TSSRON, Prims.A); + S57prims.put(Obj.TSEZNE, Prims.A); S57prims.put(Obj.TUNNEL, Prims.LA); S57prims.put(Obj.TWRTPT, Prims.A); S57prims.put(Obj.UWTROC, Prims.P); + S57prims.put(Obj.UNSARE, Prims.A); S57prims.put(Obj.VEGATN, Prims.PLA); S57prims.put(Obj.WATTUR, Prims.PLA); S57prims.put(Obj.WATFAL, Prims.PL); + S57prims.put(Obj.WEDKLP, Prims.PA); S57prims.put(Obj.WRECKS, Prims.PA); S57prims.put(Obj.TS_FEB, Prims.PA); + S57prims.put(Obj.NOTMRK, Prims.P); S57prims.put(Obj.WTWAXS, Prims.L); S57prims.put(Obj.WTWPRF, Prims.L); S57prims.put(Obj.BUNSTA, Prims.PA); + S57prims.put(Obj.COMARE, Prims.A); S57prims.put(Obj.HRBBSN, Prims.A); S57prims.put(Obj.LKBSPT, Prims.A); S57prims.put(Obj.PRTARE, Prims.A); + S57prims.put(Obj.REFDMP, Prims.P); S57prims.put(Obj.TERMNL, Prims.PA); S57prims.put(Obj.TRNBSN, Prims.PA); S57prims.put(Obj.WTWARE, Prims.A); + S57prims.put(Obj.WTWGAG, Prims.PA); S57prims.put(Obj.TISDGE, Prims.N); S57prims.put(Obj.VEHTRF, Prims.PA); S57prims.put(Obj.EXCNST, Prims.PA); + S57prims.put(Obj.LG_SDM, Prims.A); S57prims.put(Obj.LG_VSP, Prims.A); S57prims.put(Obj.LITMAJ, Prims.P); S57prims.put(Obj.LITMIN, Prims.P); + } + + public static void S57geoms(S57map map) { + for (ArrayList list : map.features.values()) { + for (Feature feature : list) { + switch (S57prims.get(feature.type)) { + case N: + break; + case P: + if (feature.geom.prim != Pflag.POINT) { +// Snode node = feature.geom.centre; +// node.flg = Nflag.ISOL; +// map.nodes.put(++map.xref, node); +// feature.geom = map.new Geom(Pflag.POINT); +// feature.geom.centre = node; +// feature.geom.elems.add(map.new Prim(map.xref)); + } + break; + case L: + break; + case A: + break; + case PA: + break; + case PL: + break; + case LA: + if (feature.geom.prim == Pflag.POINT) { +// list.remove(feature); + } + break; + case PLA: + // No changes needed + break; + } + } + } + } } Index: /applications/editors/josm/plugins/seachart/src/s57/S57enc.java =================================================================== --- /applications/editors/josm/plugins/seachart/src/s57/S57enc.java (revision 31845) +++ /applications/editors/josm/plugins/seachart/src/s57/S57enc.java (revision 31846) @@ -108,10 +108,16 @@ static final double SOMF=10; - static int intu = 4; + static String file = "0S000000.000"; + static int intu = 0; + static String code = "0S"; static int agen = 3878; static int cscl = 10000; + static int vdat = 23; + static int duni = 1; + static int huni = 1; static int idx; static int recs; + static int isols; static int conns; @@ -129,20 +135,55 @@ public static int encodeChart(S57map map, HashMap meta, byte[] buf) throws IndexOutOfBoundsException, UnsupportedEncodingException { + for (Entry entry : meta.entrySet()) { + try { + switch (entry.getKey()) { + case "FILE": + file = entry.getValue(); + break; + case "INTU": + intu = Integer.parseInt(entry.getValue()); + break; + case "AGEN": + String[] tokens = entry.getValue().split("/"); + code = tokens[0]; + agen = Integer.parseInt(tokens[1]); + break; + case "VDAT": + vdat = Integer.parseInt(entry.getValue()); + break; + case "CSCL": + cscl = Integer.parseInt(entry.getValue()); + break; + case "DUNI": + duni = Integer.parseInt(entry.getValue()); + break; + case "HUNI": + huni = Integer.parseInt(entry.getValue()); + break; + } + } catch (Exception e) { + System.err.println("Meta data (" + entry.getKey() + "=" + entry.getValue() + "):" + e.getMessage()); + System.exit(-1); + } + } + //M_COVR & MNSYS in BB if not in map if (!map.features.containsKey(Obj.M_COVR)) { S57osm.OSMmeta(map); } + + S57dat.S57geoms(map); byte[] record; ArrayList fields; + isols = conns = metas = geos = edges = 0; String date = new SimpleDateFormat("yyyyMMdd").format(Calendar.getInstance().getTime()); - ArrayList ds = new ArrayList(); - ds.add(new Fparams(S57field.DSID, new Object[] { 10, 1, 1, intu, "0S000000.000", 1, 0, date, date, "03.1", 1, "ENC", "2.0", 1, agen, "Generated by OpenSeaMap.org" })); - ds.add(new Fparams(S57field.DSSI, new Object[] { 2, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0 })); - ArrayList dp = new ArrayList(); - dp.add(new Fparams(S57field.DSPM, new Object[] { 20, 2, 2, 23, 23, cscl, 1, 1, 1, 1, 10000000, 10, "" })); - - isols = conns = metas = geos = edges = 0; + ArrayList ds = new ArrayList<>(); + ds.add(new Fparams(S57field.DSID, new Object[] { 10, 1, 1, intu, file, "1", "0", date, date, "03.1", 1, "ENC", "2.0", 1, agen, "Generated by OpenSeaMap.org" })); + ds.add(new Fparams(S57field.DSSI, new Object[] { 2, 1, 2, metas, 0, geos, 0, isols, conns, edges, 0 })); + ArrayList dp = new ArrayList<>(); + dp.add(new Fparams(S57field.DSPM, new Object[] { 20, 2, 2, vdat, vdat, cscl, duni, huni, 1, 1, 10000000, 10, "" })); + System.arraycopy(header, 0, buf, 0, header.length); idx = header.length; @@ -166,5 +207,5 @@ } if (depths.length > 0) { - fields = new ArrayList(); + fields = new ArrayList<>(); fields.add(new Fparams(S57field.VRID, new Object[] { 110, -2, 1, 1 })); fields.add(new Fparams(S57field.SG3D, depths)); @@ -179,5 +220,5 @@ S57map.Snode node = entry.getValue(); if (node.flg == Nflag.ISOL) { - fields = new ArrayList(); + fields = new ArrayList<>(); fields.add(new Fparams(S57field.VRID, new Object[] { 110, hash(entry.getKey()), 1, 1 })); fields.add(new Fparams(S57field.SG2D, new Object[] { (Math.toDegrees(node.lat) * COMF), (Math.toDegrees(node.lon) * COMF) })); @@ -193,5 +234,5 @@ S57map.Snode node = entry.getValue(); if (node.flg == Nflag.CONN) { - fields = new ArrayList(); + fields = new ArrayList<>(); fields.add(new Fparams(S57field.VRID, new Object[] { 120, hash(entry.getKey()), 1, 1 })); fields.add(new Fparams(S57field.SG2D, new Object[] { (Math.toDegrees(node.lat) * COMF), (Math.toDegrees(node.lon) * COMF) })); @@ -206,5 +247,5 @@ for (Map.Entry entry : map.edges.entrySet()) { S57map.Edge edge = entry.getValue(); - fields = new ArrayList(); + fields = new ArrayList<>(); fields.add(new Fparams(S57field.VRID, new Object[] { 130, hash(entry.getKey()), 1, 1 })); fields.add(new Fparams(S57field.VRPT, new Object[] { (((hash(edge.first) & 0xffffffff) << 8) + 120l), 255, 255, 1, 255, (((hash(edge.last) & 0xffffffff) << 8) + 120l), 255, 255, 2, 255 })); @@ -240,11 +281,7 @@ int grup = ((obj == Obj.DEPARE) || (obj == Obj.DRGARE) || (obj == Obj.FLODOC) || (obj == Obj.HULKES) || (obj == Obj.LNDARE) || (obj == Obj.PONTON) || (obj == Obj.UNSARE)) ? 1 : 2; - ArrayList geom = new ArrayList(); + ArrayList geom = new ArrayList<>(); int outers = 0; -try{ outers = (feature.geom.prim == Pflag.POINT) ? 1 : feature.geom.comps.get(0).size; -} catch (IndexOutOfBoundsException e) { - int x=0; -} for (Prim elem : feature.geom.elems) { if (feature.geom.prim == Pflag.POINT) { @@ -259,6 +296,6 @@ } - ArrayList> objects = new ArrayList>(); - ArrayList slaves = new ArrayList(); + ArrayList> objects = new ArrayList<>(); + ArrayList slaves = new ArrayList<>(); long slaveid = feature.id + 0x0100000000000000l; for (Entry objs : feature.objs.entrySet()) { @@ -266,5 +303,5 @@ boolean master = true; for (Entry object : objs.getValue().entrySet()) { - ArrayList objatts = new ArrayList(); + ArrayList objatts = new ArrayList<>(); master = (feature.type == objobj) && ((object.getKey() == 0) || (object.getKey() == 1)); long id = hash(master ? feature.id : slaveid); @@ -308,5 +345,5 @@ if (!slaves.isEmpty()) { - ArrayList refs = new ArrayList(); + ArrayList refs = new ArrayList<>(); Object[] params = new Object[0]; while (!slaves.isEmpty()) { @@ -335,6 +372,6 @@ // Re-write DSID/DSSI with final totals - ds = new ArrayList(); - ds.add(new Fparams(S57field.DSID, new Object[] { 10, 1, 1, intu, "0S000000.000", 1, 0, date, date, "03.1", 1, "ENC", "2.0", 1, agen, "Generated by OpenSeaMap.org" })); + ds = new ArrayList<>(); + ds.add(new Fparams(S57field.DSID, new Object[] { 10, 1, 1, intu, file, "1", "0", date, date, "03.1", 1, "ENC", "2.0", 1, agen, "Generated by OpenSeaMap.org" })); ds.add(new Fparams(S57field.DSSI, new Object[] { 2, 1, 2, metas, 0, geos, 0, isols, conns, edges, 0 })); record = S57dat.encRecord(1, ds); Index: /applications/editors/josm/plugins/seachart/src/s57/S57map.java =================================================================== --- /applications/editors/josm/plugins/seachart/src/s57/S57map.java (revision 31845) +++ /applications/editors/josm/plugins/seachart/src/s57/S57map.java (revision 31846) @@ -153,15 +153,19 @@ public boolean forward; // Direction of vector used (LINEs & AREAs) public boolean outer; // Exterior/Interior boundary (AREAs) + public boolean trunc; // Cell limit truncation public Prim() { - id = 0; forward = true; outer = true; + id = 0; forward = true; outer = true; trunc = false; } public Prim(long i) { - id = i; forward = true; outer = true; + id = i; forward = true; outer = true; trunc = false; } public Prim(long i, boolean o) { - id = i; forward = true; outer = o; + id = i; forward = true; outer = o; trunc = false; } public Prim(long i, boolean f, boolean o) { - id = i; forward = f; outer = o; + id = i; forward = f; outer = o; trunc = false; + } + public Prim(long i, boolean f, boolean o, boolean t) { + id = i; forward = f; outer = o; trunc = t; } } @@ -191,7 +195,7 @@ public Geom(Pflag p) { prim = p; - elems = new ArrayList(); + elems = new ArrayList<>(); outers = inners = 0; - comps = new ArrayList(); + comps = new ArrayList<>(); area = 0; length = 0; @@ -548,213 +552,10 @@ } - enum Ext {I, N, W, S, E } - public void mapDone() { - class Land { - long first; - Snode start; - Ext sbound; - long last; - Snode end; - Ext ebound; - Feature land; - Land (Feature l) { - land = l; - first = last = 0; - start = end = null; - sbound = ebound = Ext.I; - } - } - if (features.get(Obj.COALNE) != null) { - ArrayList coasts = new ArrayList(); - ArrayList lands = new ArrayList(); - if (features.get(Obj.LNDARE) == null) { - features.put(Obj.LNDARE, new ArrayList()); - } - for (Feature feature : features.get(Obj.COALNE)) { - Feature land = new Feature(); - land.id = ++xref; - land.type = Obj.LNDARE; - land.reln = Rflag.MASTER; - land.objs.put(Obj.LNDARE, new ObjTab()); - land.objs.get(Obj.LNDARE).put(0, new AttMap()); - if (feature.geom.prim == Pflag.AREA) { - land.geom = feature.geom; - features.get(Obj.LNDARE).add(land); - } else if (feature.geom.prim == Pflag.LINE) { - land.geom.prim = Pflag.LINE; - land.geom.elems.addAll(feature.geom.elems); - coasts.add(land); - } - } - while (coasts.size() > 0) { - Feature land = coasts.remove(0); - Edge fedge = edges.get(land.geom.elems.get(0).id); - long first = fedge.first; - long last = edges.get(land.geom.elems.get(land.geom.elems.size() - 1).id).last; - if (coasts.size() > 0) { - boolean added = true; - while (added) { - added = false; - for (int i = 0; i < coasts.size(); i++) { - Feature coast = coasts.get(i); - Edge edge = edges.get(coast.geom.elems.get(0).id); - if (edge.first == last) { - land.geom.elems.add(coast.geom.elems.get(0)); - last = edge.last; - coasts.remove(i--); - added = true; - } else if (edge.last == first) { - land.geom.elems.add(0, coast.geom.elems.get(0)); - first = edge.first; - coasts.remove(i--); - added = true; - } - } - } - } - lands.add(new Land(land)); - } - ArrayList islands = new ArrayList(); - for (Land land : lands) { - sortGeom(land.land); - if (land.land.geom.prim == Pflag.AREA) { - islands.add(land); - features.get(Obj.LNDARE).add(land.land); - } - } - for (Land island : islands) { - lands.remove(island); - } - for (Land land : lands) { - GeomIterator git = new GeomIterator(land.land.geom); - Snode prev = null; - Ext bprev = Ext.I; - Ext ext; - land.ebound = land.sbound = Ext.I; - while (git.hasComp()) { - git.nextComp(); - while (git.hasEdge()) { - git.nextEdge(); - while (git.hasNode()) { - long ref = git.nextRef(false); - Snode node = nodes.get(ref); - if (node == null) continue; - if (land.first == 0) { - land.first = ref; - } - if (prev == null) { - prev = node; - } - if ((node.lat >= bounds.maxlat) && (node.lon < bounds.maxlon)) { - ext = Ext.N; - } else if (node.lon <= bounds.minlon) { - ext = Ext.W; - } else if (node.lat <= bounds.minlat) { - ext = Ext.S; - } else if (node.lon >= bounds.maxlon) { - ext = Ext.E; - } else { - ext = Ext.I; - } - if (ext == Ext.I) { - if (land.start == null) { - land.start = prev; - land.sbound = bprev; - } - land.end = null; - land.ebound = Ext.I; - } else { - if ((land.start != null) && (land.end == null)) { - land.end = node; - land.ebound = ext; - } - } - prev = node; - bprev = ext; - land.last = ref; - } - } - } - } - islands = new ArrayList(); - for (Land land : lands) { - if ((land.sbound == Ext.I) || (land.ebound == Ext.I)) { - islands.add(land); - } - } - for (Land island : islands) { - lands.remove(island); - } - while (lands.size() > 0) { - Land land = lands.get(0); - Edge nedge = new Edge(); - nedge.first = land.last; - Ext bound = land.ebound; - Snode last = land.end; - double delta = Math.PI; - int idx = -1; - Land next = null; - while (idx < 0) { - for (int i = 0; i < lands.size(); i++) { - next = lands.get(i); - if (next.sbound == bound) { - double diff = -Math.PI; - switch (bound) { - case N: - diff = last.lon - next.start.lon; - break; - case W: - diff = last.lat - next.start.lat; - break; - case S: - diff = next.start.lon - last.lon; - break; - case E: - diff = next.start.lat - last.lat; - break; - default: - continue; - } - if ((diff >= 0.0) && (diff < delta)) { - delta = diff; - idx = i; - } - } - } - if (idx < 0) { - long ref = (long)bound.ordinal(); - last = nodes.get(ref); - nedge.nodes.add(ref); - ref = ref < 4 ? ++ref : 1; - for (Ext e : Ext.values()) { - if (ref == e.ordinal()) { - bound = e; - break; - } - } - } - } - next = lands.get(idx); - nedge.last = next.first; - edges.put(++xref, nedge); - land.land.geom.elems.add(new Prim(xref)); - if (next != land) { - land.land.geom.elems.addAll(next.land.geom.elems); - land.ebound = next.ebound; - land.end = next.end; - land.last = next.last; - lands.remove(idx); - } - sortGeom(land.land); - if (land.land.geom.prim == Pflag.AREA) { - features.get(Obj.LNDARE).add(land.land); - lands.remove(land); - } - } - } - return; - } - + if (!sea) { + S57box.bBox(this); + } + } + // Utility methods @@ -836,5 +637,5 @@ if (ie == 0) feature.geom.area = Math.abs(area) * 3444 * 3444; if (((ie == 0) && (area < 0.0)) || ((ie > 0) && (area >= 0.0))) { - ArrayList tmp = new ArrayList(); + ArrayList tmp = new ArrayList<>(); for (int i = 0; i < feature.geom.comps.get(ic).size; i++) { Prim p = feature.geom.elems.remove(ie); Index: /applications/editors/josm/plugins/seachart/src/s57/S57obj.java =================================================================== --- /applications/editors/josm/plugins/seachart/src/s57/S57obj.java (revision 31845) +++ /applications/editors/josm/plugins/seachart/src/s57/S57obj.java (revision 31846) @@ -29,5 +29,5 @@ } - private static final EnumMap ObjS57 = new EnumMap(Obj.class); + private static final EnumMap ObjS57 = new EnumMap<>(Obj.class); static { ObjS57.put(Obj.UNKOBJ,0); @@ -66,5 +66,5 @@ } - private static final EnumMap ObjIENC = new EnumMap(Obj.class); + private static final EnumMap ObjIENC = new EnumMap<>(Obj.class); static { ObjIENC.put(Obj.UNKOBJ, 0); @@ -81,5 +81,5 @@ } - private static final EnumMap ObjStr = new EnumMap(Obj.class); + private static final EnumMap ObjStr = new EnumMap<>(Obj.class); static { ObjStr.put(Obj.UNKOBJ, ""); ObjStr.put(Obj.AIRARE, "airfield"); ObjStr.put(Obj.ACHBRT, "anchor_berth"); ObjStr.put(Obj.ACHARE, "anchorage"); @@ -130,5 +130,5 @@ } - private static final HashMap StrObj = new HashMap(); + private static final HashMap StrObj = new HashMap<>(); static { for (Map.Entry entry : ObjStr.entrySet()) { Index: /applications/editors/josm/plugins/seachart/src/s57/S57osm.java =================================================================== --- /applications/editors/josm/plugins/seachart/src/s57/S57osm.java (revision 31845) +++ /applications/editors/josm/plugins/seachart/src/s57/S57osm.java (revision 31846) @@ -11,8 +11,6 @@ import java.io.BufferedReader; -import java.io.IOException; import java.util.*; -import s57.S57map.Feature; import s57.S57obj.*; import s57.S57att.*; @@ -21,54 +19,4 @@ public class S57osm { // OSM to S57 Object/Attribute and Object/Primitive conversions - enum Prims { N, P, L, A, PA, PL, LA, PLA } - private static final EnumMap S57prims = new EnumMap(Obj.class); - static { - S57prims.put(Obj.UNKOBJ, Prims.PLA); S57prims.put(Obj.M_COVR, Prims.A); S57prims.put(Obj.M_NSYS, Prims.A); S57prims.put(Obj.AIRARE, Prims.PA); - S57prims.put(Obj.ACHBRT, Prims.PA); S57prims.put(Obj.ACHARE, Prims.PA); S57prims.put(Obj.BCNCAR, Prims.P); S57prims.put(Obj.BCNISD, Prims.P); - S57prims.put(Obj.BCNLAT, Prims.P); S57prims.put(Obj.BCNSAW, Prims.P); S57prims.put(Obj.BCNSPP, Prims.P); S57prims.put(Obj.BERTHS, Prims.PLA); - S57prims.put(Obj.BRIDGE, Prims.PLA); S57prims.put(Obj.BUISGL, Prims.PA); S57prims.put(Obj.BUAARE, Prims.PA); S57prims.put(Obj.BOYCAR, Prims.P); - S57prims.put(Obj.BOYINB, Prims.P); S57prims.put(Obj.BOYISD, Prims.P); S57prims.put(Obj.BOYLAT, Prims.P); S57prims.put(Obj.BOYSAW, Prims.P); - S57prims.put(Obj.BOYSPP, Prims.P); S57prims.put(Obj.CBLARE, Prims.A); S57prims.put(Obj.CBLOHD, Prims.L); S57prims.put(Obj.CBLSUB, Prims.L); - S57prims.put(Obj.CANALS, Prims.A); S57prims.put(Obj.CTSARE, Prims.PA); S57prims.put(Obj.CAUSWY, Prims.LA); S57prims.put(Obj.CTNARE, Prims.PA); - S57prims.put(Obj.CHKPNT, Prims.PA); S57prims.put(Obj.CGUSTA, Prims.P); S57prims.put(Obj.COALNE, Prims.L); S57prims.put(Obj.CONZNE, Prims.A); - S57prims.put(Obj.COSARE, Prims.A); S57prims.put(Obj.CTRPNT, Prims.P); S57prims.put(Obj.CONVYR, Prims.LA); S57prims.put(Obj.CRANES, Prims.PA); - S57prims.put(Obj.CURENT, Prims.P); S57prims.put(Obj.CUSZNE, Prims.A); S57prims.put(Obj.DAMCON, Prims.LA); S57prims.put(Obj.DAYMAR, Prims.P); - S57prims.put(Obj.DWRTCL, Prims.L); S57prims.put(Obj.DWRTPT, Prims.A); S57prims.put(Obj.DEPARE, Prims.A); S57prims.put(Obj.DEPCNT, Prims.L); - S57prims.put(Obj.DISMAR, Prims.P); S57prims.put(Obj.DOCARE, Prims.A); S57prims.put(Obj.DRGARE, Prims.A); S57prims.put(Obj.DRYDOC, Prims.A); - S57prims.put(Obj.DMPGRD, Prims.PA); S57prims.put(Obj.DYKCON, Prims.L); S57prims.put(Obj.EXEZNE, Prims.A); S57prims.put(Obj.FAIRWY, Prims.A); - S57prims.put(Obj.FNCLNE, Prims.L); S57prims.put(Obj.FERYRT, Prims.LA); S57prims.put(Obj.FSHZNE, Prims.A); S57prims.put(Obj.FSHFAC, Prims.PLA); - S57prims.put(Obj.FSHGRD, Prims.A); S57prims.put(Obj.FLODOC, Prims.A); S57prims.put(Obj.FOGSIG, Prims.P); S57prims.put(Obj.FORSTC, Prims.PLA); - S57prims.put(Obj.FRPARE, Prims.A); S57prims.put(Obj.GATCON, Prims.PLA); S57prims.put(Obj.GRIDRN, Prims.PA); S57prims.put(Obj.HRBARE, Prims.A); - S57prims.put(Obj.HRBFAC, Prims.PA); S57prims.put(Obj.HULKES, Prims.PA); S57prims.put(Obj.ICEARE, Prims.A); S57prims.put(Obj.ICNARE, Prims.PA); - S57prims.put(Obj.ISTZNE, Prims.A); S57prims.put(Obj.LAKARE, Prims.A); S57prims.put(Obj.LNDARE, Prims.PLA); S57prims.put(Obj.LNDELV, Prims.PL); - S57prims.put(Obj.LNDRGN, Prims.PA); S57prims.put(Obj.LNDMRK, Prims.PLA); S57prims.put(Obj.LIGHTS, Prims.P); S57prims.put(Obj.LITFLT, Prims.P); - S57prims.put(Obj.LITVES, Prims.P); S57prims.put(Obj.LOCMAG, Prims.PLA); S57prims.put(Obj.LOKBSN, Prims.A); S57prims.put(Obj.LOGPON, Prims.PA); - S57prims.put(Obj.MAGVAR, Prims.PLA); S57prims.put(Obj.MARCUL, Prims.PLA); S57prims.put(Obj.MIPARE, Prims.PA); S57prims.put(Obj.MORFAC, Prims.PLA); - S57prims.put(Obj.MPAARE, Prims.PA); S57prims.put(Obj.NAVLNE, Prims.L); S57prims.put(Obj.OBSTRN, Prims.PLA); S57prims.put(Obj.OFSPLF, Prims.PA); - S57prims.put(Obj.OSPARE, Prims.A); S57prims.put(Obj.OILBAR, Prims.L); S57prims.put(Obj.PILPNT, Prims.P); S57prims.put(Obj.PILBOP, Prims.PA); - S57prims.put(Obj.PIPARE, Prims.PA); S57prims.put(Obj.PIPOHD, Prims.L); S57prims.put(Obj.PIPSOL, Prims.PL); S57prims.put(Obj.PONTON, Prims.LA); - S57prims.put(Obj.PRCARE, Prims.PA); S57prims.put(Obj.PRDARE, Prims.PA); S57prims.put(Obj.PYLONS, Prims.PA); S57prims.put(Obj.RADLNE, Prims.L); - S57prims.put(Obj.RADRNG, Prims.A); S57prims.put(Obj.RADRFL, Prims.P); S57prims.put(Obj.RADSTA, Prims.P); S57prims.put(Obj.RTPBCN, Prims.P); - S57prims.put(Obj.RDOCAL, Prims.PL); S57prims.put(Obj.RDOSTA, Prims.P); S57prims.put(Obj.RAILWY, Prims.L); S57prims.put(Obj.RAPIDS, Prims.PLA); - S57prims.put(Obj.RCRTCL, Prims.L); S57prims.put(Obj.RECTRC, Prims.LA); S57prims.put(Obj.RCTLPT, Prims.PA); S57prims.put(Obj.RSCSTA, Prims.P); - S57prims.put(Obj.RESARE, Prims.A); S57prims.put(Obj.RETRFL, Prims.P); S57prims.put(Obj.RIVERS, Prims.LA); S57prims.put(Obj.ROADWY, Prims.PLA); - S57prims.put(Obj.RUNWAY, Prims.PLA); S57prims.put(Obj.SNDWAV, Prims.PLA); S57prims.put(Obj.SEAARE, Prims.PA); S57prims.put(Obj.SPLARE, Prims.PA); - S57prims.put(Obj.SBDARE, Prims.PLA); S57prims.put(Obj.SLCONS, Prims.PLA); S57prims.put(Obj.SISTAT, Prims.P); S57prims.put(Obj.SISTAW, Prims.P); - S57prims.put(Obj.SILTNK, Prims.PA); S57prims.put(Obj.SLOTOP, Prims.L); S57prims.put(Obj.SLOGRD, Prims.PA); S57prims.put(Obj.SMCFAC, Prims.PA); - S57prims.put(Obj.SOUNDG, Prims.P); S57prims.put(Obj.SPRING, Prims.P); S57prims.put(Obj.STSLNE, Prims.L); S57prims.put(Obj.SUBTLN, Prims.A); - S57prims.put(Obj.SWPARE, Prims.A); S57prims.put(Obj.TESARE, Prims.A); S57prims.put(Obj.TS_PRH, Prims.PA); S57prims.put(Obj.TS_PNH, Prims.PA); - S57prims.put(Obj.TS_PAD, Prims.PA); S57prims.put(Obj.TS_TIS, Prims.PA); S57prims.put(Obj.T_HMON, Prims.PA); S57prims.put(Obj.T_NHMN, Prims.PA); - S57prims.put(Obj.T_TIMS, Prims.PA); S57prims.put(Obj.TIDEWY, Prims.LA); S57prims.put(Obj.TOPMAR, Prims.P); S57prims.put(Obj.TSELNE, Prims.LA); - S57prims.put(Obj.TSSBND, Prims.L); S57prims.put(Obj.TSSCRS, Prims.A); S57prims.put(Obj.TSSLPT, Prims.A); S57prims.put(Obj.TSSRON, Prims.A); - S57prims.put(Obj.TSEZNE, Prims.A); S57prims.put(Obj.TUNNEL, Prims.LA); S57prims.put(Obj.TWRTPT, Prims.A); S57prims.put(Obj.UWTROC, Prims.P); - S57prims.put(Obj.UNSARE, Prims.A); S57prims.put(Obj.VEGATN, Prims.PLA); S57prims.put(Obj.WATTUR, Prims.PLA); S57prims.put(Obj.WATFAL, Prims.PL); - S57prims.put(Obj.WEDKLP, Prims.PA); S57prims.put(Obj.WRECKS, Prims.PA); S57prims.put(Obj.TS_FEB, Prims.PA); - S57prims.put(Obj.NOTMRK, Prims.P); S57prims.put(Obj.WTWAXS, Prims.L); S57prims.put(Obj.WTWPRF, Prims.L); S57prims.put(Obj.BUNSTA, Prims.PA); - S57prims.put(Obj.COMARE, Prims.A); S57prims.put(Obj.HRBBSN, Prims.A); S57prims.put(Obj.LKBSPT, Prims.A); S57prims.put(Obj.PRTARE, Prims.A); - S57prims.put(Obj.REFDMP, Prims.P); S57prims.put(Obj.TERMNL, Prims.PA); S57prims.put(Obj.TRNBSN, Prims.PA); S57prims.put(Obj.WTWARE, Prims.A); - S57prims.put(Obj.WTWGAG, Prims.PA); S57prims.put(Obj.TISDGE, Prims.N); S57prims.put(Obj.VEHTRF, Prims.PA); S57prims.put(Obj.EXCNST, Prims.PA); - S57prims.put(Obj.LG_SDM, Prims.A); S57prims.put(Obj.LG_VSP, Prims.A); - } - static class KeyVal { Obj obj; @@ -84,5 +32,5 @@ } - private static final HashMap> OSMtags = new HashMap>(); + private static final HashMap> OSMtags = new HashMap<>(); static { OSMtags.put("natural=coastline", new KeyVal<>(Obj.COALNE, Att.UNKATT, null, null)); OSMtags.put("natural=water", new KeyVal<>(Obj.LAKARE, Att.UNKATT, null, null)); @@ -114,5 +62,5 @@ } - public static void OSMmap(BufferedReader in, S57map map) throws IOException { + public static void OSMmap(BufferedReader in, S57map map) throws Exception { String k = ""; String v = ""; @@ -271,17 +219,3 @@ } - public static void OSMgeom(Feature feature, S57map map) { - switch (S57prims.get(feature.type)) { - case N: - case P: - case L: - case A: - case PA: - case PL: - case LA: - case PLA: - } - } - - } Index: /applications/editors/josm/plugins/seachart/src/s57/S57val.java =================================================================== --- /applications/editors/josm/plugins/seachart/src/s57/S57val.java (revision 31845) +++ /applications/editors/josm/plugins/seachart/src/s57/S57val.java (revision 31846) @@ -43,5 +43,5 @@ public enum BcnSHP { BCN_UNKN, BCN_STAK, BCN_WTHY, BCN_TOWR, BCN_LATT, BCN_PILE, BCN_CARN, BCN_BUOY, BCN_POLE, BCN_PRCH, BCN_POST } - private static final EnumMap Bcnshp = new EnumMap(BcnSHP.class); static { Bcnshp.put(BcnSHP.BCN_UNKN, new S57enum(0, "")); + private static final EnumMap Bcnshp = new EnumMap<>(BcnSHP.class); static { Bcnshp.put(BcnSHP.BCN_UNKN, new S57enum(0, "")); Bcnshp.put(BcnSHP.BCN_STAK, new S57enum(1, "stake")); Bcnshp.put(BcnSHP.BCN_WTHY, new S57enum(2, "withy")); Bcnshp.put(BcnSHP.BCN_TOWR, new S57enum(3, "tower")); Bcnshp.put(BcnSHP.BCN_LATT, new S57enum(4, "lattice")); Bcnshp.put(BcnSHP.BCN_PILE, new S57enum(5, "pile")); Bcnshp.put(BcnSHP.BCN_CARN, new S57enum(6, "cairn")); @@ -50,10 +50,10 @@ } public enum BuiSHP { BUI_UNKN, BUI_HIRS, BUI_PYRD, BUI_CYLR, BUI_SPHR, BUI_CUBE } - private static final EnumMap Buishp = new EnumMap(BuiSHP.class); static { Buishp.put(BuiSHP.BUI_UNKN, new S57enum(0, "")); + private static final EnumMap Buishp = new EnumMap<>(BuiSHP.class); static { Buishp.put(BuiSHP.BUI_UNKN, new S57enum(0, "")); Buishp.put(BuiSHP.BUI_HIRS, new S57enum(5, "high-rise")); Buishp.put(BuiSHP.BUI_PYRD, new S57enum(6, "pyramid")); Buishp.put(BuiSHP.BUI_CYLR, new S57enum(7, "cylindrical")); Buishp.put(BuiSHP.BUI_SPHR, new S57enum(8, "spherical")); Buishp.put(BuiSHP.BUI_CUBE, new S57enum(9, "cubic")); } public enum BoySHP { BOY_UNKN, BOY_CONE, BOY_CAN, BOY_SPHR, BOY_PILR, BOY_SPAR, BOY_BARL, BOY_SUPR, BOY_ICE } - private static final EnumMap Boyshp = new EnumMap(BoySHP.class); static { Boyshp.put(BoySHP.BOY_UNKN, new S57enum(0, "")); + private static final EnumMap Boyshp = new EnumMap<>(BoySHP.class); static { Boyshp.put(BoySHP.BOY_UNKN, new S57enum(0, "")); Boyshp.put(BoySHP.BOY_CONE, new S57enum(1, "conical")); Boyshp.put(BoySHP.BOY_CAN, new S57enum(2, "can")); Boyshp.put(BoySHP.BOY_SPHR, new S57enum(3, "spherical")); Boyshp.put(BoySHP.BOY_PILR, new S57enum(4, "pillar")); Boyshp.put(BoySHP.BOY_SPAR, new S57enum(5, "spar")); Boyshp.put(BoySHP.BOY_BARL, new S57enum(6, "barrel")); @@ -61,5 +61,5 @@ } public enum CatAIR { AIR_UNKN, AIR_MILA, AIR_CIVA, AIR_MILH, AIR_CIVH, AIR_GLDR, AIR_SMLP, AIR_EMRG } - private static final EnumMap Catair = new EnumMap(CatAIR.class); static { Catair.put(CatAIR.AIR_UNKN, new S57enum(0, "")); + private static final EnumMap Catair = new EnumMap<>(CatAIR.class); static { Catair.put(CatAIR.AIR_UNKN, new S57enum(0, "")); Catair.put(CatAIR.AIR_MILA, new S57enum(1, "military")); Catair.put(CatAIR.AIR_CIVA, new S57enum(2, "civil")); Catair.put(CatAIR.AIR_MILH, new S57enum(3, "military_heliport")); Catair.put(CatAIR.AIR_CIVH, new S57enum(4, "civil_heliport")); Catair.put(CatAIR.AIR_GLDR, new S57enum(5, "glider")); Catair.put(CatAIR.AIR_SMLP, new S57enum(6, "small_planes")); @@ -67,5 +67,5 @@ } public enum CatACH { ACH_UNKN, ACH_UNRD, ACH_DEEP, ACH_TANK, ACH_EXPL, ACH_QUAR, ACH_SEAP, ACH_SMCF, ACH_SMCM, ACH_H24P, ACH_LTPD, ACH_NPSH, ACH_DRYC, ACH_RAFT } - private static final EnumMap Catach = new EnumMap(CatACH.class); static {Catach.put(CatACH.ACH_UNKN, new S57enum(0, "")); + private static final EnumMap Catach = new EnumMap<>(CatACH.class); static {Catach.put(CatACH.ACH_UNKN, new S57enum(0, "")); Catach.put(CatACH.ACH_UNRD, new S57enum(1, "unrestricted")); Catach.put(CatACH.ACH_DEEP, new S57enum(2, "deep_water")); Catach.put(CatACH.ACH_TANK, new S57enum(3, "tanker")); Catach.put(CatACH.ACH_EXPL, new S57enum(4, "explosives")); Catach.put(CatACH.ACH_QUAR, new S57enum(5, "quarantine")); Catach.put(CatACH.ACH_SEAP, new S57enum(6, "seaplane")); @@ -75,5 +75,5 @@ } public enum CatBRG { BRG_UNKN, BRG_FIXD, BRG_OPEN, BRG_SWNG, BRG_LIFT, BRG_BASC, BRG_PONT, BRG_DRAW, BRG_TRNS, BRG_FOOT, BRG_VIAD, BRG_AQUA, BRG_SUSP } - private static final EnumMap Catbrg = new EnumMap(CatBRG.class); static {Catbrg.put(CatBRG.BRG_UNKN, new S57enum(0, "")); + private static final EnumMap Catbrg = new EnumMap<>(CatBRG.class); static {Catbrg.put(CatBRG.BRG_UNKN, new S57enum(0, "")); Catbrg.put(CatBRG.BRG_FIXD, new S57enum(1, "fixed")); Catbrg.put(CatBRG.BRG_OPEN, new S57enum(2, "opening")); Catbrg.put(CatBRG.BRG_SWNG, new S57enum(3, "swing")); Catbrg.put(CatBRG.BRG_LIFT, new S57enum(4, "lifting")); Catbrg.put(CatBRG.BRG_BASC, new S57enum(5, "bascule")); Catbrg.put(CatBRG.BRG_PONT, new S57enum(6, "pontoon")); @@ -82,10 +82,10 @@ } public enum CatBUA { BUA_UNKN, BUA_URBN, BUA_STTL, BUA_VLLG, BUA_TOWN, BUA_CITY, BUA_HOLV } - private static final EnumMap Catbua = new EnumMap(CatBUA.class); static { Catbua.put(CatBUA.BUA_UNKN, new S57enum(0, "")); + private static final EnumMap Catbua = new EnumMap<>(CatBUA.class); static { Catbua.put(CatBUA.BUA_UNKN, new S57enum(0, "")); Catbua.put(CatBUA.BUA_URBN, new S57enum(1, "urban")); Catbua.put(CatBUA.BUA_STTL, new S57enum(2, "settlement")); Catbua.put(CatBUA.BUA_VLLG, new S57enum(3, "village")); Catbua.put(CatBUA.BUA_TOWN, new S57enum(4, "town")); Catbua.put(CatBUA.BUA_CITY, new S57enum(5, "city")); Catbua.put(CatBUA.BUA_HOLV, new S57enum(6, "holiday_village")); } public enum CatCBL { CBL_UNKN, CBL_POWR, CBL_TRNS, CBL_TELE, CBL_TGPH, CBL_MOOR, CBL_OPTC, CBL_FERY } - private static final EnumMap Catcbl = new EnumMap(CatCBL.class); static {Catcbl.put(CatCBL.CBL_UNKN, new S57enum(0, "")); + private static final EnumMap Catcbl = new EnumMap<>(CatCBL.class); static {Catcbl.put(CatCBL.CBL_UNKN, new S57enum(0, "")); Catcbl.put(CatCBL.CBL_POWR, new S57enum(1, "power")); Catcbl.put(CatCBL.CBL_TRNS, new S57enum(3, "transmission")); Catcbl.put(CatCBL.CBL_TELE, new S57enum(4, "telephone")); Catcbl.put(CatCBL.CBL_TGPH, new S57enum(5, "telegraph")); Catcbl.put(CatCBL.CBL_MOOR, new S57enum(6, "mooring")); Catcbl.put(CatCBL.CBL_OPTC, new S57enum(7, "optical")); @@ -93,18 +93,18 @@ } public enum CatCAN { CAN_UNKN, CAN_TRNS, CAN_DRNG, CAN_IRGN } - private static final EnumMap Catcan = new EnumMap(CatCAN.class); static { Catcan.put(CatCAN.CAN_UNKN, new S57enum(0, "")); + private static final EnumMap Catcan = new EnumMap<>(CatCAN.class); static { Catcan.put(CatCAN.CAN_UNKN, new S57enum(0, "")); Catcan.put(CatCAN.CAN_TRNS, new S57enum(1, "transportation")); Catcan.put(CatCAN.CAN_DRNG, new S57enum(2, "drainage")); Catcan.put(CatCAN.CAN_IRGN, new S57enum(3, "irrigation")); } public enum CatCAM { CAM_UNKN, CAM_NORTH, CAM_EAST, CAM_SOUTH, CAM_WEST } - private static final EnumMap Catcam = new EnumMap(CatCAM.class); static { Catcam.put(CatCAM.CAM_UNKN, new S57enum(0, "")); + private static final EnumMap Catcam = new EnumMap<>(CatCAM.class); static { Catcam.put(CatCAM.CAM_UNKN, new S57enum(0, "")); Catcam.put(CatCAM.CAM_NORTH, new S57enum(1, "north")); Catcam.put(CatCAM.CAM_EAST, new S57enum(2, "east")); Catcam.put(CatCAM.CAM_SOUTH, new S57enum(3, "south")); Catcam.put(CatCAM.CAM_WEST, new S57enum(4, "west")); } public enum CatCHP { CHP_UNKN, CHP_CSTM, CHP_BRDR } - private static final EnumMap Catchp = new EnumMap(CatCHP.class); static { Catchp.put(CatCHP.CHP_UNKN, new S57enum(0, "")); + private static final EnumMap Catchp = new EnumMap<>(CatCHP.class); static { Catchp.put(CatCHP.CHP_UNKN, new S57enum(0, "")); Catchp.put(CatCHP.CHP_CSTM, new S57enum(1, "customs")); Catchp.put(CatCHP.CHP_BRDR, new S57enum(2, "border")); } public enum CatCOA { COA_UNKN, COA_STEP, COA_FLAT, COA_SAND, COA_STON, COA_SHNG, COA_GLCR, COA_MNGV, COA_MRSH, COA_CRRF, COA_ICE, COA_SHEL } - private static final EnumMap Catcoa = new EnumMap(CatCOA.class); static { Catcoa.put(CatCOA.COA_UNKN, new S57enum(0, "")); + private static final EnumMap Catcoa = new EnumMap<>(CatCOA.class); static { Catcoa.put(CatCOA.COA_UNKN, new S57enum(0, "")); Catcoa.put(CatCOA.COA_STEP, new S57enum(1, "steep")); Catcoa.put(CatCOA.COA_FLAT, new S57enum(2, "flat")); Catcoa.put(CatCOA.COA_SAND, new S57enum(3, "sandy")); Catcoa.put(CatCOA.COA_STON, new S57enum(4, "stony")); Catcoa.put(CatCOA.COA_SHNG, new S57enum(5, "shingly")); Catcoa.put(CatCOA.COA_GLCR, new S57enum(6, "glacier")); @@ -113,5 +113,5 @@ } public enum CatCTR { CTR_UNKN, CTR_TRGN, CTR_OBSV, CTR_FIXD, CTR_BMRK, CTR_BDRY, CTR_HORM, CTR_HORS } - private static final EnumMap Catctr = new EnumMap(CatCTR.class); static { Catctr.put(CatCTR.CTR_UNKN, new S57enum(0, "")); + private static final EnumMap Catctr = new EnumMap<>(CatCTR.class); static { Catctr.put(CatCTR.CTR_UNKN, new S57enum(0, "")); Catctr.put(CatCTR.CTR_TRGN, new S57enum(1, "triangulation")); Catctr.put(CatCTR.CTR_OBSV, new S57enum(2, "observation")); Catctr.put(CatCTR.CTR_FIXD, new S57enum(3, "fixed")); Catctr.put(CatCTR.CTR_BMRK, new S57enum(4, "benchmark")); Catctr.put(CatCTR.CTR_BDRY, new S57enum(5, "boundary")); Catctr.put(CatCTR.CTR_HORM, new S57enum(6, "horizontal_main")); @@ -119,47 +119,47 @@ } public enum CatCON { CON_UNKN, CAT_AERL, CAT_BELT } - private static final EnumMap Catcon = new EnumMap(CatCON.class); static { Catcon.put(CatCON.CON_UNKN, new S57enum(0, "")); + private static final EnumMap Catcon = new EnumMap<>(CatCON.class); static { Catcon.put(CatCON.CON_UNKN, new S57enum(0, "")); Catcon.put(CatCON.CAT_AERL, new S57enum(1, "aerial")); Catcon.put(CatCON.CAT_BELT, new S57enum(2, "belt")); } public enum CatCRN { CRN_UNKN, CRN_NONS, CRN_CONT, CRN_SHRL, CRN_TRAV, CRN_AFRM } - private static final EnumMap Catcrn = new EnumMap(CatCRN.class); static { Catcrn.put(CatCRN.CRN_UNKN, new S57enum(0, "")); + private static final EnumMap Catcrn = new EnumMap<>(CatCRN.class); static { Catcrn.put(CatCRN.CRN_UNKN, new S57enum(0, "")); Catcrn.put(CatCRN.CRN_NONS, new S57enum(1, "non-specific")); Catcrn.put(CatCRN.CRN_CONT, new S57enum(2, "container")); Catcrn.put(CatCRN.CRN_SHRL, new S57enum(3, "sheerlegs")); Catcrn.put(CatCRN.CRN_TRAV, new S57enum(4, "travelling")); Catcrn.put(CatCRN.CRN_AFRM , new S57enum(5, "a-frame")); } public enum CatDAM { DAM_UNKN, DAM_WEIR, DAM_DAM, DAM_FLDB } - private static final EnumMap Catdam = new EnumMap(CatDAM.class); static { Catdam.put(CatDAM.DAM_UNKN, new S57enum(0, "")); + private static final EnumMap Catdam = new EnumMap<>(CatDAM.class); static { Catdam.put(CatDAM.DAM_UNKN, new S57enum(0, "")); Catdam.put(CatDAM.DAM_WEIR, new S57enum(1, "weir")); Catdam.put(CatDAM.DAM_DAM, new S57enum(2, "dam")); Catdam.put(CatDAM.DAM_FLDB, new S57enum(3, "flood_barrage")); } public enum CatDIS { DIS_UNKN, DIS_NONI, DIS_POLE, DIS_BORD, DIS_UKSH } - private static final EnumMap Catdis = new EnumMap(CatDIS.class); static { Catdis.put(CatDIS.DIS_UNKN, new S57enum(0, "")); + private static final EnumMap Catdis = new EnumMap<>(CatDIS.class); static { Catdis.put(CatDIS.DIS_UNKN, new S57enum(0, "")); Catdis.put(CatDIS.DIS_NONI, new S57enum(1, "not_installed")); Catdis.put(CatDIS.DIS_POLE, new S57enum(2, "pole")); Catdis.put(CatDIS.DIS_BORD, new S57enum(3, "board")); Catdis.put(CatDIS.DIS_UKSH, new S57enum(4, "unknown_shape")); } public enum CatDOC { DOC_UNKN, DOC_TIDL, DOC_NTDL } - private static final EnumMap Catdoc = new EnumMap(CatDOC.class); static { Catdoc.put(CatDOC.DOC_UNKN, new S57enum(0, "")); + private static final EnumMap Catdoc = new EnumMap<>(CatDOC.class); static { Catdoc.put(CatDOC.DOC_UNKN, new S57enum(0, "")); Catdoc.put(CatDOC.DOC_TIDL, new S57enum(1, "tidal")); Catdoc.put(CatDOC.DOC_NTDL, new S57enum(2, "non-tidal")); } public enum CatDPG { DPG_UNKN, DPG_GENL, DPG_CHEM, DPG_NCLR, DPG_EXPL, DPG_SPIL, DPG_VSSL } - private static final EnumMap Catdpg = new EnumMap(CatDPG.class); static { Catdpg.put(CatDPG.DPG_UNKN, new S57enum(0, "")); + private static final EnumMap Catdpg = new EnumMap<>(CatDPG.class); static { Catdpg.put(CatDPG.DPG_UNKN, new S57enum(0, "")); Catdpg.put(CatDPG.DPG_GENL, new S57enum(1, "general")); Catdpg.put(CatDPG.DPG_CHEM, new S57enum(2, "chemical")); Catdpg.put(CatDPG.DPG_NCLR, new S57enum(3, "nuclear")); Catdpg.put(CatDPG.DPG_EXPL, new S57enum(4, "explosives")); Catdpg.put(CatDPG.DPG_SPIL, new S57enum(5, "spoil")); Catdpg.put(CatDPG.DPG_VSSL, new S57enum(6, "vessel")); } public enum CatFNC { FNC_UNKN, FNC_FENC, FNC_MUIR, FNC_HEDG, FNC_WALL } - private static final EnumMap Catfnc = new EnumMap(CatFNC.class); static { Catfnc.put(CatFNC.FNC_UNKN, new S57enum(0, "")); + private static final EnumMap Catfnc = new EnumMap<>(CatFNC.class); static { Catfnc.put(CatFNC.FNC_UNKN, new S57enum(0, "")); Catfnc.put(CatFNC.FNC_FENC, new S57enum(1, "fence")); Catfnc.put(CatFNC.FNC_MUIR, new S57enum(2, "muir")); Catfnc.put(CatFNC.FNC_HEDG, new S57enum(3, "hedge")); Catfnc.put(CatFNC.FNC_WALL, new S57enum(4, "wall")); } public enum CatFRY { FRY_UNKN, FRY_FREE, FRY_CABL, FRY_ICE, FRY_SWWR } - private static final EnumMap Catfry = new EnumMap(CatFRY.class); static { Catfry.put(CatFRY.FRY_UNKN, new S57enum(0, "")); + private static final EnumMap Catfry = new EnumMap<>(CatFRY.class); static { Catfry.put(CatFRY.FRY_UNKN, new S57enum(0, "")); Catfry.put(CatFRY.FRY_FREE, new S57enum(1, "free")); Catfry.put(CatFRY.FRY_CABL, new S57enum(2, "cable")); Catfry.put(CatFRY.FRY_ICE, new S57enum(3, "ice")); Catfry.put(CatFRY.FRY_SWWR, new S57enum(4, "swinging_wire")); } public enum CatFIF { FIF_UNKN, FIF_STAK, FIF_TRAP, FIF_WEIR, FIF_TUNY } - private static final EnumMap Catfif = new EnumMap(CatFIF.class); static { Catfif.put(CatFIF.FIF_UNKN, new S57enum(0, "")); + private static final EnumMap Catfif = new EnumMap<>(CatFIF.class); static { Catfif.put(CatFIF.FIF_UNKN, new S57enum(0, "")); Catfif.put(CatFIF.FIF_STAK, new S57enum(1, "stake")); Catfif.put(CatFIF.FIF_TRAP, new S57enum(2, "trap")); Catfif.put(CatFIF.FIF_WEIR, new S57enum(3, "weir")); Catfif.put(CatFIF.FIF_TUNY, new S57enum(4, "tunny")); } public enum CatFOG { FOG_UNKN, FOG_EXPL, FOG_DIA, FOG_SIRN, FOG_NAUT, FOG_REED, FOG_TYPH, FOG_BELL, FOG_WHIS, FOG_GONG, FOG_HORN } - private static final EnumMap Catfog = new EnumMap(CatFOG.class); static {Catfog.put(CatFOG.FOG_UNKN, new S57enum(0, "")); + private static final EnumMap Catfog = new EnumMap<>(CatFOG.class); static {Catfog.put(CatFOG.FOG_UNKN, new S57enum(0, "")); Catfog.put(CatFOG.FOG_EXPL, new S57enum(1, "explosive")); Catfog.put(CatFOG.FOG_DIA, new S57enum(2, "diaphone")); Catfog.put(CatFOG.FOG_SIRN, new S57enum(3, "siren")); Catfog.put(CatFOG.FOG_NAUT, new S57enum(4, "nautophone")); Catfog.put(CatFOG.FOG_REED, new S57enum(5, "reed")); @@ -168,10 +168,10 @@ } public enum CatFOR { FOR_UNKN, FOR_CSTL, FOR_FORT, FOR_BTTY, FOR_BKHS, FOR_MTWR, FOR_RDBT } - private static final EnumMap Catfor = new EnumMap(CatFOR.class); static { Catfor.put(CatFOR.FOR_UNKN, new S57enum(0, "")); + private static final EnumMap Catfor = new EnumMap<>(CatFOR.class); static { Catfor.put(CatFOR.FOR_UNKN, new S57enum(0, "")); Catfor.put(CatFOR.FOR_CSTL, new S57enum(1, "castle")); Catfor.put(CatFOR.FOR_FORT, new S57enum(2, "fort")); Catfor.put(CatFOR.FOR_BTTY, new S57enum(3, "battery")); Catfor.put(CatFOR.FOR_BKHS, new S57enum(4, "blockhouse")); Catfor.put(CatFOR.FOR_MTWR, new S57enum(5, "martello_tower")); Catfor.put(CatFOR.FOR_RDBT, new S57enum(6, "redoubt")); } public enum CatGAT { GAT_UNKN, GAT_GNRL, GAT_FLBG, GAT_CSSN, GAT_LOCK, GAT_DYKE, GAT_SLUC } - private static final EnumMap Catgat = new EnumMap(CatGAT.class); static { Catgat.put(CatGAT.GAT_UNKN, new S57enum(0, "")); + private static final EnumMap Catgat = new EnumMap<>(CatGAT.class); static { Catgat.put(CatGAT.GAT_UNKN, new S57enum(0, "")); Catgat.put(CatGAT.GAT_GNRL, new S57enum(1, "general")); Catgat.put(CatGAT.GAT_FLBG, new S57enum(2, "flood_barrage")); Catgat.put(CatGAT.GAT_CSSN, new S57enum(3, "caisson")); Catgat.put(CatGAT.GAT_LOCK, new S57enum(4, "lock")); Catgat.put(CatGAT.GAT_DYKE, new S57enum(5, "dyke")); Catgat.put(CatGAT.GAT_SLUC, new S57enum(6, "sluice")); @@ -179,5 +179,5 @@ public enum CatHAF { HAF_UNKN, HAF_RORO, HAF_TMBR, HAF_FERY, HAF_FISH, HAF_MRNA, HAF_NAVL, HAF_TNKR, HAF_PSGR, HAF_YARD, HAF_CNTR, HAF_BULK, HAF_SYNC, HAF_STCR, HAF_LUVB, HAF_REPR, HAF_QUAR, HAF_SPLN, HAF_CARG, HAF_OFFS, HAF_SSUP, HAF_MANF } - private static final EnumMap Cathaf = new EnumMap(CatHAF.class); static { Cathaf.put(CatHAF.HAF_UNKN, new S57enum(0, "")); + private static final EnumMap Cathaf = new EnumMap<>(CatHAF.class); static { Cathaf.put(CatHAF.HAF_UNKN, new S57enum(0, "")); Cathaf.put(CatHAF.HAF_RORO, new S57enum(1, "roro")); Cathaf.put(CatHAF.HAF_FERY, new S57enum(3, "ferry")); Cathaf.put(CatHAF.HAF_FISH, new S57enum(4, "fishing")); Cathaf.put(CatHAF.HAF_MRNA, new S57enum(5, "marina")); Cathaf.put(CatHAF.HAF_NAVL, new S57enum(6, "naval")); Cathaf.put(CatHAF.HAF_TNKR, new S57enum(7, "tanker")); @@ -190,10 +190,10 @@ } public enum CatHLK { HLK_UNKN, HLK_REST, HLK_HIST, HLK_MUSM, HLK_ACCM, HLK_BWTR, HLK_CSNO } - private static final EnumMap Cathlk = new EnumMap(CatHLK.class); static { Cathlk.put(CatHLK.HLK_UNKN, new S57enum(0, "")); + private static final EnumMap Cathlk = new EnumMap<>(CatHLK.class); static { Cathlk.put(CatHLK.HLK_UNKN, new S57enum(0, "")); Cathlk.put(CatHLK.HLK_REST, new S57enum(1, "floating_restaurant")); Cathlk.put(CatHLK.HLK_HIST, new S57enum(2, "historic")); Cathlk.put(CatHLK.HLK_MUSM, new S57enum(3, "museum")); Cathlk.put(CatHLK.HLK_ACCM, new S57enum(4, "accommodation")); Cathlk.put(CatHLK.HLK_BWTR, new S57enum(5, "floating_breakwater")); Cathlk.put(CatHLK.HLK_CSNO, new S57enum(6, "casino_boat")); } public enum CatICE { ICE_UNKN, ICE_FAST, ICE_SEA, ICE_GRLR, ICE_PANK, ICE_GLAS, ICE_PEAK, ICE_PACK, ICE_POLR } - private static final EnumMap Catice = new EnumMap(CatICE.class); static { Catice.put(CatICE.ICE_UNKN, new S57enum(0, "")); + private static final EnumMap Catice = new EnumMap<>(CatICE.class); static { Catice.put(CatICE.ICE_UNKN, new S57enum(0, "")); Catice.put(CatICE.ICE_FAST, new S57enum(1, "fast")); Catice.put(CatICE.ICE_SEA, new S57enum(2, "sea")); Catice.put(CatICE.ICE_GRLR, new S57enum(3, "growler")); Catice.put(CatICE.ICE_PANK, new S57enum(4, "pancake")); Catice.put(CatICE.ICE_GLAS, new S57enum(5, "glacier")); Catice.put(CatICE.ICE_PEAK, new S57enum(6, "peak")); @@ -201,11 +201,10 @@ } public enum CatINB { INB_UNKN, INB_CALM, INB_SBM } - private static final EnumMap Catinb = new EnumMap(CatINB.class); static { Catinb.put(CatINB.INB_UNKN, new S57enum(0, "")); + private static final EnumMap Catinb = new EnumMap<>(CatINB.class); static { Catinb.put(CatINB.INB_UNKN, new S57enum(0, "")); Catinb.put(CatINB.INB_CALM, new S57enum(1, "calm")); Catinb.put(CatINB.INB_SBM, new S57enum(2, "sbm")); } public enum CatLND { LND_UNKN, LND_FEN, LND_MRSH, LND_BOG, LND_HTHL, LND_MNTN, LND_LOWL, LND_CNYN, LND_PDDY, LND_AGRI, LND_SVNA, LND_PARK, LND_SWMP, LND_LSLD, LND_LAVA, - LND_SLTP, LND_MORN, LND_CRTR, LND_CAVE, LND_PINCL, LND_CAY - } - private static final EnumMap Catlnd = new EnumMap(CatLND.class); static { Catlnd.put(CatLND.LND_UNKN, new S57enum(0, "")); + LND_SLTP, LND_MORN, LND_CRTR, LND_CAVE, LND_PINCL, LND_CAY } + private static final EnumMap Catlnd = new EnumMap<>(CatLND.class); static { Catlnd.put(CatLND.LND_UNKN, new S57enum(0, "")); Catlnd.put(CatLND.LND_FEN, new S57enum(1, "fen")); Catlnd.put(CatLND.LND_MRSH, new S57enum(2, "marsh")); Catlnd.put(CatLND.LND_BOG, new S57enum(3, "bog")); Catlnd.put(CatLND.LND_HTHL, new S57enum(4, "heathland")); Catlnd.put(CatLND.LND_MNTN, new S57enum(5, "mountain")); Catlnd.put(CatLND.LND_LOWL, new S57enum(6, "lowlands")); @@ -218,5 +217,5 @@ public enum CatLMK { LMK_UNKN, LMK_CARN, LMK_CMTY, LMK_CHMY, LMK_DISH, LMK_FLAG, LMK_FLAR, LMK_MAST, LMK_WNDS, LMK_MNMT, LMK_CLMN, LMK_MEML, LMK_OBLK, LMK_STAT, LMK_CROS, LMK_DOME, LMK_RADR, LMK_TOWR, LMK_WNDM, LMK_WNDG, LMK_SPIR, LMK_BLDR, LMK_MNRT, LMK_WTRT } - private static final EnumMap Catlmk = new EnumMap(CatLMK.class); static {Catlmk.put(CatLMK.LMK_UNKN, new S57enum(0, "")); + private static final EnumMap Catlmk = new EnumMap<>(CatLMK.class); static {Catlmk.put(CatLMK.LMK_UNKN, new S57enum(0, "")); Catlmk.put(CatLMK.LMK_CARN, new S57enum(1, "cairn")); Catlmk.put(CatLMK.LMK_CMTY, new S57enum(2, "cemetery")); Catlmk.put(CatLMK.LMK_CHMY, new S57enum(3, "chimney")); Catlmk.put(CatLMK.LMK_DISH, new S57enum(4, "dish_aerial")); Catlmk.put(CatLMK.LMK_FLAG, new S57enum(5, "flagstaff")); Catlmk.put(CatLMK.LMK_FLAR, new S57enum(6, "flare_stack")); @@ -229,5 +228,5 @@ public enum CatLAM { LAM_UNKN, LAM_PORT, LAM_STBD, LAM_PCST, LAM_PCPT, LAM_WWLT, LAM_WWRT, LAM_CHLT, LAM_CHRT, LAM_WWSN, LAM_CHSN, LAM_CHRB, LAM_CHLB, LAM_CRRT, LAM_CRLT, LAM_DRLT, LAM_DRRT, LAM_TOLT, LAM_TPRT, LAM_JBRT, LAM_JNLT, LAM_HBRT, LAM_HBLT, LAM_BRGP } - private static final EnumMap Catlam = new EnumMap(CatLAM.class); static { Catlam.put(CatLAM.LAM_UNKN, new S57enum(0, "")); + private static final EnumMap Catlam = new EnumMap<>(CatLAM.class); static { Catlam.put(CatLAM.LAM_UNKN, new S57enum(0, "")); Catlam.put(CatLAM.LAM_PORT, new S57enum(1, "port")); Catlam.put(CatLAM.LAM_STBD, new S57enum(2, "starboard")); Catlam.put(CatLAM.LAM_PCST, new S57enum(3, "preferred_channel_starboard")); Catlam.put(CatLAM.LAM_PCPT, new S57enum(4, "preferred_channel_port")); Catlam.put(CatLAM.LAM_WWRT, new S57enum(5, "waterway_right")); Catlam.put(CatLAM.LAM_WWLT, new S57enum(6, "waterway_left")); @@ -240,5 +239,5 @@ } public enum CatLIT { LIT_UNKN, LIT_DIR, LIT_LEAD, LIT_AERO, LIT_AIR, LIT_FOG, LIT_FLDL, LIT_STRP, LIT_SUBS, LIT_SPOT, LIT_FRNT, LIT_REAR, LIT_LOWR, LIT_UPPR, LIT_MOIR, LIT_EMRG, LIT_BRNG, LIT_HORI, LIT_VERT } - private static final EnumMap Catlit = new EnumMap(CatLIT.class); static { Catlit.put(CatLIT.LIT_UNKN, new S57enum(0, "")); + private static final EnumMap Catlit = new EnumMap<>(CatLIT.class); static { Catlit.put(CatLIT.LIT_UNKN, new S57enum(0, "")); Catlit.put(CatLIT.LIT_DIR, new S57enum(1, "directional")); Catlit.put(CatLIT.LIT_LEAD, new S57enum(4, "leading")); Catlit.put(CatLIT.LIT_AERO, new S57enum(5, "aero")); Catlit.put(CatLIT.LIT_AIR, new S57enum(6, "air_obstruction")); Catlit.put(CatLIT.LIT_FOG, new S57enum(7, "fog_detector")); Catlit.put(CatLIT.LIT_FLDL, new S57enum(8, "floodlight")); @@ -249,15 +248,15 @@ } public enum CatMFA { MFA_UNKN, MFA_CRST, MFA_OYMS, MFA_FISH, MFA_SEAW, MFA_PRLC } - private static final EnumMap Catmfa = new EnumMap(CatMFA.class); static { Catmfa.put(CatMFA.MFA_UNKN, new S57enum(0, "")); + private static final EnumMap Catmfa = new EnumMap<>(CatMFA.class); static { Catmfa.put(CatMFA.MFA_UNKN, new S57enum(0, "")); Catmfa.put(CatMFA.MFA_CRST, new S57enum(1, "crustaceans")); Catmfa.put(CatMFA.MFA_OYMS, new S57enum(2, "oysters_mussels")); Catmfa.put(CatMFA.MFA_FISH, new S57enum(3, "fish")); Catmfa.put(CatMFA.MFA_SEAW, new S57enum(4, "seaweed")); Catmfa.put(CatMFA.MFA_PRLC, new S57enum(5, "pearl_culture")); } public enum CatMPA { MPA_UNKN, MPA_PRCT, MPA_TRPD, MPA_SUBM, MPA_FIRG, MPA_MINL, MPA_SMLA } - private static final EnumMap Catmpa = new EnumMap(CatMPA.class); static { Catmpa.put(CatMPA.MPA_UNKN, new S57enum(0, "")); + private static final EnumMap Catmpa = new EnumMap<>(CatMPA.class); static { Catmpa.put(CatMPA.MPA_UNKN, new S57enum(0, "")); Catmpa.put(CatMPA.MPA_PRCT, new S57enum(1, "practice")); Catmpa.put(CatMPA.MPA_TRPD, new S57enum(2, "torpedo")); Catmpa.put(CatMPA.MPA_SUBM, new S57enum(3, "submarine")); Catmpa.put(CatMPA.MPA_FIRG, new S57enum(4, "firing")); Catmpa.put(CatMPA.MPA_MINL, new S57enum(5, "mine-laying")); Catmpa.put(CatMPA.MPA_SMLA, new S57enum(6, "small_arms")); } public enum CatMOR { MOR_UNKN, MOR_DLPN, MOR_DDPN, MOR_BLRD, MOR_WALL, MOR_PILE, MOR_CHAN, MOR_BUOY, MOR_SHRP, MOR_AUTO, MOR_POST, MOR_WIRE, MOR_CABL } - private static final EnumMap Catmor = new EnumMap(CatMOR.class); static { Catmor.put(CatMOR.MOR_UNKN, new S57enum(0, "")); + private static final EnumMap Catmor = new EnumMap<>(CatMOR.class); static { Catmor.put(CatMOR.MOR_UNKN, new S57enum(0, "")); Catmor.put(CatMOR.MOR_DLPN, new S57enum(1, "dolphin")); Catmor.put(CatMOR.MOR_DDPN, new S57enum(2, "deviation_dolphin")); Catmor.put(CatMOR.MOR_BLRD, new S57enum(3, "bollard")); Catmor.put(CatMOR.MOR_WALL, new S57enum(4, "wall")); Catmor.put(CatMOR.MOR_PILE, new S57enum(5, "pile")); Catmor.put(CatMOR.MOR_CHAN, new S57enum(6, "chain")); @@ -266,9 +265,9 @@ } public enum CatNAV { NAV_UNKN, NAV_CLRG, NAV_TRST, NAV_LDNG } - private static final EnumMap Catnav = new EnumMap(CatNAV.class); static { Catnav.put(CatNAV.NAV_UNKN, new S57enum(0, "")); + private static final EnumMap Catnav = new EnumMap<>(CatNAV.class); static { Catnav.put(CatNAV.NAV_UNKN, new S57enum(0, "")); Catnav.put(CatNAV.NAV_CLRG, new S57enum(1, "clearing")); Catnav.put(CatNAV.NAV_TRST, new S57enum(2, "transit")); Catnav.put(CatNAV.NAV_LDNG, new S57enum(3, "leading")); } public enum CatOBS { OBS_UNKN, OBS_STMP, OBS_WELH, OBS_DIFF, OBS_CRIB, OBS_FHVN, OBS_FLAR, OBS_FLGD, OBS_ICEB, OBS_GTKL, OBS_BOOM } - private static final EnumMap Catobs = new EnumMap(CatOBS.class); static { Catobs.put(CatOBS.OBS_UNKN, new S57enum(0, "")); + private static final EnumMap Catobs = new EnumMap<>(CatOBS.class); static { Catobs.put(CatOBS.OBS_UNKN, new S57enum(0, "")); Catobs.put(CatOBS.OBS_STMP, new S57enum(1, "stump")); Catobs.put(CatOBS.OBS_WELH, new S57enum(2, "wellhead")); Catobs.put(CatOBS.OBS_DIFF, new S57enum(3, "diffuser")); Catobs.put(CatOBS.OBS_CRIB, new S57enum(4, "crib")); Catobs.put(CatOBS.OBS_FHVN, new S57enum(5, "fish_haven")); Catobs.put(CatOBS.OBS_FLAR, new S57enum(6, "foul_area")); @@ -277,5 +276,5 @@ } public enum CatOFP { OFP_UNKN, OFP_OIL, OFP_PROD, OFP_OBS, OFP_ALP, OFP_SALM, OFP_MOOR, OFP_AISL, OFP_FPSO, OFP_ACCN, OFP_NCCB } - private static final EnumMap Catofp = new EnumMap(CatOFP.class); static { Catofp.put(CatOFP.OFP_UNKN, new S57enum(0, "")); + private static final EnumMap Catofp = new EnumMap<>(CatOFP.class); static { Catofp.put(CatOFP.OFP_UNKN, new S57enum(0, "")); Catofp.put(CatOFP.OFP_OIL, new S57enum(1, "oil")); Catofp.put(CatOFP.OFP_PROD, new S57enum(2, "production")); Catofp.put(CatOFP.OFP_OBS, new S57enum(3, "observation")); Catofp.put(CatOFP.OFP_ALP, new S57enum(4, "alp")); Catofp.put(CatOFP.OFP_SALM, new S57enum(5, "salm")); Catofp.put(CatOFP.OFP_MOOR, new S57enum(6, "mooring")); @@ -284,23 +283,23 @@ } public enum CatOLB { OLB_UNKN, OLB_RETN, OLB_FLTG } - private static final EnumMap Catolb = new EnumMap(CatOLB.class); static { Catolb.put(CatOLB.OLB_UNKN, new S57enum(0, "")); + private static final EnumMap Catolb = new EnumMap<>(CatOLB.class); static { Catolb.put(CatOLB.OLB_UNKN, new S57enum(0, "")); Catolb.put(CatOLB.OLB_RETN, new S57enum(1, "retention")); Catolb.put(CatOLB.OLB_FLTG, new S57enum(2, "floating")); } public enum CatPLE { PLE_UNKN, PLE_STAK, PLE_SNAG, PLE_POST, PLE_TRIP } - private static final EnumMap Catple = new EnumMap(CatPLE.class); static { Catple.put(CatPLE.PLE_UNKN, new S57enum(0, "")); + private static final EnumMap Catple = new EnumMap<>(CatPLE.class); static { Catple.put(CatPLE.PLE_UNKN, new S57enum(0, "")); Catple.put(CatPLE.PLE_STAK, new S57enum(1, "stake")); Catple.put(CatPLE.PLE_SNAG, new S57enum(2, "snag")); Catple.put(CatPLE.PLE_POST, new S57enum(3, "post")); Catple.put(CatPLE.PLE_TRIP, new S57enum(4, "tripodal")); } public enum CatPIL { PIL_UNKN, PIL_CVSL, PIL_HELI, PIL_SHOR } - private static final EnumMap Catpil = new EnumMap(CatPIL.class); static { Catpil.put(CatPIL.PIL_UNKN, new S57enum(0, "")); + private static final EnumMap Catpil = new EnumMap<>(CatPIL.class); static { Catpil.put(CatPIL.PIL_UNKN, new S57enum(0, "")); Catpil.put(CatPIL.PIL_CVSL, new S57enum(1, "cruising_vessel")); Catpil.put(CatPIL.PIL_HELI, new S57enum(2, "helicopter")); Catpil.put(CatPIL.PIL_SHOR, new S57enum(3, "from_shore")); } public enum CatPIP { PIP_UNKN, PIP_OFAL, PIP_ITAK, PIP_SEWR, PIP_BBLR, PIP_SPPL } - private static final EnumMap Catpip = new EnumMap(CatPIP.class); static { Catpip.put(CatPIP.PIP_UNKN, new S57enum(0, "")); + private static final EnumMap Catpip = new EnumMap<>(CatPIP.class); static { Catpip.put(CatPIP.PIP_UNKN, new S57enum(0, "")); Catpip.put(CatPIP.PIP_OFAL, new S57enum(2, "outfall")); Catpip.put(CatPIP.PIP_ITAK, new S57enum(3, "intake")); Catpip.put(CatPIP.PIP_SEWR, new S57enum(4, "sewer")); Catpip.put(CatPIP.PIP_BBLR, new S57enum(5, "bubbler")); Catpip.put(CatPIP.PIP_SPPL, new S57enum(6, "supply")); } public enum CatPRA { PRA_UNKN, PRA_QRRY, PRA_MINE, PRA_STPL, PRA_PSTN, PRA_RFNY, PRA_TYRD, PRA_FACT, PRA_TFRM, PRA_WFRM, PRA_SLAG, PRA_CURF, PRA_OILF, PRA_GASF, PRA_WAVE } - private static final EnumMap Catpra = new EnumMap(CatPRA.class); static { Catpra.put(CatPRA.PRA_UNKN, new S57enum(0, "")); + private static final EnumMap Catpra = new EnumMap<>(CatPRA.class); static { Catpra.put(CatPRA.PRA_UNKN, new S57enum(0, "")); Catpra.put(CatPRA.PRA_QRRY, new S57enum(1, "quarry")); Catpra.put(CatPRA.PRA_MINE, new S57enum(2, "mine")); Catpra.put(CatPRA.PRA_STPL, new S57enum(3, "stockpile")); Catpra.put(CatPRA.PRA_PSTN, new S57enum(4, "power_station")); Catpra.put(CatPRA.PRA_RFNY, new S57enum(5, "refinery")); Catpra.put(CatPRA.PRA_TYRD, new S57enum(6, "timber_yard")); @@ -310,19 +309,19 @@ } public enum CatPYL { PYL_UNKN, PYL_POWR, PYL_TELE, PYL_AERL, PYL_BRDG, PYL_PIER } - private static final EnumMap Catpyl = new EnumMap(CatPYL.class); static { Catpyl.put(CatPYL.PYL_UNKN, new S57enum(0, "")); + private static final EnumMap Catpyl = new EnumMap<>(CatPYL.class); static { Catpyl.put(CatPYL.PYL_UNKN, new S57enum(0, "")); Catpyl.put(CatPYL.PYL_POWR, new S57enum(1, "power")); Catpyl.put(CatPYL.PYL_TELE, new S57enum(2, "telecom")); Catpyl.put(CatPYL.PYL_AERL, new S57enum(3, "aerial")); Catpyl.put(CatPYL.PYL_BRDG, new S57enum(4, "bridge")); Catpyl.put(CatPYL.PYL_PIER, new S57enum(5, "bridge_pier")); } public enum CatRAS { RAS_UNKN, RAS_SURV, RAS_COST } - private static final EnumMap Catras = new EnumMap(CatRAS.class); static { Catras.put(CatRAS.RAS_UNKN, new S57enum(0, "")); + private static final EnumMap Catras = new EnumMap<>(CatRAS.class); static { Catras.put(CatRAS.RAS_UNKN, new S57enum(0, "")); Catras.put(CatRAS.RAS_SURV, new S57enum(1, "surveillance")); Catras.put(CatRAS.RAS_COST, new S57enum(2, "coast")); } public enum CatRTB { RTB_UNKN, RTB_RAMK, RTB_RACN, RTB_LDG } - private static final EnumMap Catrtb = new EnumMap(CatRTB.class); static {Catrtb.put(CatRTB.RTB_UNKN, new S57enum(0, "")); + private static final EnumMap Catrtb = new EnumMap<>(CatRTB.class); static {Catrtb.put(CatRTB.RTB_UNKN, new S57enum(0, "")); Catrtb.put(CatRTB.RTB_RAMK, new S57enum(1, "ramark")); Catrtb.put(CatRTB.RTB_RACN, new S57enum(2, "racon")); Catrtb.put(CatRTB.RTB_LDG, new S57enum(3, "leading")); } public enum CatROS { ROS_UNKN, ROS_OMNI, ROS_DIRL, ROS_ROTP, ROS_CNSL, ROS_RDF, ROS_QTA, ROS_AERO, ROS_DECA, ROS_LORN, ROS_DGPS, ROS_TORN, ROS_OMGA, ROS_SYLD, ROS_CHKA, ROS_PCOM, ROS_COMB, ROS_FACS, ROS_TIME, ROS_PAIS, ROS_SAIS, ROS_VAIS, ROS_VANC, ROS_VASC, ROS_VAEC, ROS_VAWC, ROS_VAPL, ROS_VASL, ROS_VAID, ROS_VASW, ROS_VASP, ROS_VAWK } - private static final EnumMap Catros = new EnumMap(CatROS.class); static { Catros.put(CatROS.ROS_UNKN, new S57enum(0, "")); + private static final EnumMap Catros = new EnumMap<>(CatROS.class); static { Catros.put(CatROS.ROS_UNKN, new S57enum(0, "")); Catros.put(CatROS.ROS_OMNI, new S57enum(1, "omnidirectional")); Catros.put(CatROS.ROS_DIRL, new S57enum(2, "directional")); Catros.put(CatROS.ROS_ROTP, new S57enum(3, "rotating_pattern")); Catros.put(CatROS.ROS_CNSL, new S57enum(4, "consol")); Catros.put(CatROS.ROS_RDF, new S57enum(5, "rdf")); Catros.put(CatROS.ROS_QTA, new S57enum(6, "qtg")); @@ -339,5 +338,5 @@ } public enum CatRSC { RSC_UNKN, RSC_LIFB, RSC_ROKT, RSC_LBRK, RSC_RFSW, RSC_RFIT, RSC_LBOM, RSC_RDIO, RSC_FSTA, RSC_SPLN, RSC_ACFT, RSC_STUG } - private static final EnumMap Catrsc = new EnumMap(CatRSC.class); static { Catrsc.put(CatRSC.RSC_UNKN, new S57enum(0, "")); + private static final EnumMap Catrsc = new EnumMap<>(CatRSC.class); static { Catrsc.put(CatRSC.RSC_UNKN, new S57enum(0, "")); Catrsc.put(CatRSC.RSC_LIFB, new S57enum(1, "lifeboat")); Catrsc.put(CatRSC.RSC_ROKT, new S57enum(2, "rocket")); Catrsc.put(CatRSC.RSC_LBRK, new S57enum(3, "lifeboat_rocket")); Catrsc.put(CatRSC.RSC_RFSW, new S57enum(4, "refuge_shipwrecked")); Catrsc.put(CatRSC.RSC_RFIT, new S57enum(5, "refuge_intertidal")); Catrsc.put(CatRSC.RSC_LBOM, new S57enum(6, "lifeboat_on_mooring")); @@ -347,5 +346,5 @@ public enum CatREA { REA_UNKN, REA_SFTY, REA_NANC, REA_NFSH, REA_NATR, REA_BRDS, REA_GRSV, REA_SEAL, REA_DEGR, REA_MILY, REA_HIST, REA_INST, REA_NASF, REA_STRD, REA_MINE, REA_NDIV, REA_TBAV, REA_PROH, REA_SWIM, REA_WAIT, REA_RSCH, REA_DREG, REA_FSNC, REA_ERES, REA_NWAK, REA_SWNG, REA_WSKI, REA_ESSA, REA_PSSA } - private static final EnumMap Catrea = new EnumMap(CatREA.class); static { Catrea.put(CatREA.REA_UNKN, new S57enum(0, "")); + private static final EnumMap Catrea = new EnumMap<>(CatREA.class); static { Catrea.put(CatREA.REA_UNKN, new S57enum(0, "")); Catrea.put(CatREA.REA_SFTY, new S57enum(1, "safety")); Catrea.put(CatREA.REA_NANC, new S57enum(2, "no_anchoring")); Catrea.put(CatREA.REA_NFSH, new S57enum(3, "no_fishing")); Catrea.put(CatREA.REA_NATR, new S57enum(4, "nature_reserve")); Catrea.put(CatREA.REA_BRDS, new S57enum(5, "bird_sanctuary")); Catrea.put(CatREA.REA_GRSV, new S57enum(6, "game_reserve")); @@ -360,5 +359,5 @@ } public enum CatROD { ROD_UNKN, ROD_MWAY, ROD_MAJR, ROD_MINR, ROD_TRAK, ROD_MAJS, ROD_MINS, ROD_CRSG, ROD_PATH } - private static final EnumMap Catrod = new EnumMap(CatROD.class); static { Catrod.put(CatROD.ROD_UNKN, new S57enum(0, "")); + private static final EnumMap Catrod = new EnumMap<>(CatROD.class); static { Catrod.put(CatROD.ROD_UNKN, new S57enum(0, "")); Catrod.put(CatROD.ROD_MWAY, new S57enum(1, "motorway")); Catrod.put(CatROD.ROD_MAJR, new S57enum(2, "major_road")); Catrod.put(CatROD.ROD_MINR, new S57enum(3, "minor_road")); Catrod.put(CatROD.ROD_TRAK, new S57enum(4, "track")); Catrod.put(CatROD.ROD_MAJS, new S57enum(5, "major_street")); Catrod.put(CatROD.ROD_MINS, new S57enum(6, "minor_street")); @@ -366,5 +365,5 @@ } public enum CatRUN { RUN_UNKN, RUN_AERP, RUN_HELI } - private static final EnumMap Catrun = new EnumMap(CatRUN.class); static { Catrun.put(CatRUN.RUN_UNKN, new S57enum(0, "")); + private static final EnumMap Catrun = new EnumMap<>(CatRUN.class); static { Catrun.put(CatRUN.RUN_UNKN, new S57enum(0, "")); Catrun.put(CatRUN.RUN_AERP, new S57enum(1, "aeroplane")); Catrun.put(CatRUN.RUN_HELI, new S57enum(2, "helicopter")); } @@ -373,5 +372,5 @@ SEA_ESCT, SEA_FAN, SEA_FZON, SEA_GAP, SEA_GUYT, SEA_HILL, SEA_HOLE, SEA_LEVE, SEA_MVLY, SEA_MOAT, SEA_MTNS, SEA_PEAK, SEA_PVNC, SEA_RISE, SEA_SCNL, SEA_SCHN, SEA_SEDG, SEA_SILL, SEA_SLOP, SEA_TRRC, SEA_VLLY, SEA_CANL, SEA_LAKE, SEA_RIVR, SEA_RECH } - private static final EnumMap Catsea = new EnumMap(CatSEA.class); static { Catsea.put(CatSEA.SEA_UNKN, new S57enum(0, "")); + private static final EnumMap Catsea = new EnumMap<>(CatSEA.class); static { Catsea.put(CatSEA.SEA_UNKN, new S57enum(0, "")); Catsea.put(CatSEA.SEA_GENL, new S57enum(1, "general")); Catsea.put(CatSEA.SEA_GAT, new S57enum(2, "gat")); Catsea.put(CatSEA.SEA_BANK, new S57enum(3, "bank")); Catsea.put(CatSEA.SEA_DEEP, new S57enum(4, "deep")); Catsea.put(CatSEA.SEA_BAY, new S57enum(5, "bay")); Catsea.put(CatSEA.SEA_TRCH, new S57enum(6, "trench")); @@ -395,5 +394,5 @@ public enum CatSLC { SLC_UNKN, SLC_BWTR, SLC_GRYN, SLC_MOLE, SLC_PIER, SLC_PPER, SLC_WHRF, SLC_TWAL, SLC_RPRP, SLC_RVMT, SLC_SWAL, SLC_LSTP, SLC_RAMP, SLC_SWAY, SLC_FNDR, SLC_SFWF, SLC_OFWF, SLC_LRMP, SLC_LWAL, SLC_ICEB } - private static final EnumMap Catslc = new EnumMap(CatSLC.class); static { Catslc.put(CatSLC.SLC_UNKN, new S57enum(0, "")); + private static final EnumMap Catslc = new EnumMap<>(CatSLC.class); static { Catslc.put(CatSLC.SLC_UNKN, new S57enum(0, "")); Catslc.put(CatSLC.SLC_BWTR, new S57enum(1, "breakwater")); Catslc.put(CatSLC.SLC_GRYN, new S57enum(2, "groyne")); Catslc.put(CatSLC.SLC_MOLE, new S57enum(3, "mole")); Catslc.put(CatSLC.SLC_PIER, new S57enum(4, "pier")); Catslc.put(CatSLC.SLC_PPER, new S57enum(5, "promenade_pier")); Catslc.put(CatSLC.SLC_WHRF, new S57enum(6, "wharf")); @@ -405,5 +404,5 @@ } public enum CatSIT { SIT_UNKN, SIT_PRTC, SIT_PRTE, SIT_IPT, SIT_BRTH, SIT_DOCK, SIT_LOCK, SIT_FLDB, SIT_BRDG, SIT_DRDG, SIT_TCLT, SIT_SPCL, SIT_PLTG, SIT_ONCT } - private static final EnumMap Catsit = new EnumMap(CatSIT.class); static {Catsit.put(CatSIT.SIT_UNKN, new S57enum(0, "")); + private static final EnumMap Catsit = new EnumMap<>(CatSIT.class); static {Catsit.put(CatSIT.SIT_UNKN, new S57enum(0, "")); Catsit.put(CatSIT.SIT_PRTC, new S57enum(1, "port_control")); Catsit.put(CatSIT.SIT_PRTE, new S57enum(2, "port_entry_departure")); Catsit.put(CatSIT.SIT_IPT, new S57enum(3, "ipt")); Catsit.put(CatSIT.SIT_BRTH, new S57enum(4, "berthing")); Catsit.put(CatSIT.SIT_DOCK, new S57enum(5, "dock")); Catsit.put(CatSIT.SIT_LOCK, new S57enum(6, "lock")); @@ -414,5 +413,5 @@ public enum CatSIW { SIW_UNKN, SIW_DNGR, SIW_OBST, SIW_CABL, SIW_MILY, SIW_DSTR, SIW_WTHR, SIW_STRM, SIW_ICE, SIW_TIME, SIW_TIDE, SIW_TSTR, SIW_TIDG, SIW_TIDS, SIW_DIVE, SIW_WTLG, SIW_VRCL, SIW_HIWM, SIW_DPTH, SIW_CURR } - private static final EnumMap Catsiw = new EnumMap(CatSIW.class); static {Catsiw.put(CatSIW.SIW_UNKN, new S57enum(0, "")); + private static final EnumMap Catsiw = new EnumMap<>(CatSIW.class); static {Catsiw.put(CatSIW.SIW_UNKN, new S57enum(0, "")); Catsiw.put(CatSIW.SIW_DNGR, new S57enum(1, "danger")); Catsiw.put(CatSIW.SIW_OBST, new S57enum(2, "maritime_obstruction")); Catsiw.put(CatSIW.SIW_CABL, new S57enum(3, "cable")); Catsiw.put(CatSIW.SIW_MILY, new S57enum(4, "military")); Catsiw.put(CatSIW.SIW_DSTR, new S57enum(5, "distress")); Catsiw.put(CatSIW.SIW_WTHR, new S57enum(6, "weather")); @@ -424,10 +423,10 @@ } public enum CatSIL { SIL_UNKN, SIL_SILO, SIL_TANK, SIL_GRNE, SIL_WTRT } - private static final EnumMap Catsil = new EnumMap(CatSIL.class); static { Catsil.put(CatSIL.SIL_UNKN, new S57enum(0, "")); + private static final EnumMap Catsil = new EnumMap<>(CatSIL.class); static { Catsil.put(CatSIL.SIL_UNKN, new S57enum(0, "")); Catsil.put(CatSIL.SIL_SILO, new S57enum(1, "silo")); Catsil.put(CatSIL.SIL_TANK, new S57enum(2, "tank")); Catsil.put(CatSIL.SIL_GRNE, new S57enum(3, "grain_elevator")); Catsil.put(CatSIL.SIL_WTRT, new S57enum(4, "water_tower")); } public enum CatSLO { SLO_UNKN, SLO_CUTG, SLO_EMBK, SLO_DUNE, SLO_HILL, SLO_PINO, SLO_CLIF, SLO_SCRE } - private static final EnumMap Catslo = new EnumMap(CatSLO.class); static { Catslo.put(CatSLO.SLO_UNKN, new S57enum(0, "")); + private static final EnumMap Catslo = new EnumMap<>(CatSLO.class); static { Catslo.put(CatSLO.SLO_UNKN, new S57enum(0, "")); Catslo.put(CatSLO.SLO_CUTG, new S57enum(1, "cutting")); Catslo.put(CatSLO.SLO_EMBK, new S57enum(2, "embankment")); Catslo.put(CatSLO.SLO_DUNE, new S57enum(3, "dune")); Catslo.put(CatSLO.SLO_HILL, new S57enum(4, "hill")); Catslo.put(CatSLO.SLO_PINO, new S57enum(5, "pingo")); Catslo.put(CatSLO.SLO_CLIF, new S57enum(6, "cliff")); Catslo.put(CatSLO.SLO_SCRE, new S57enum(7, "scree")); @@ -436,5 +435,5 @@ SCF_WTRT, SCF_FUEL, SCF_ELEC, SCF_BGAS, SCF_SHWR, SCF_LAUN, SCF_WC, SCF_POST, SCF_TELE, SCF_REFB, SCF_CARP, SCF_BTPK, SCF_CRVN, SCF_CAMP, SCF_PMPO, SCF_EMRT, SCF_SLPW, SCF_VMOR, SCF_SCRB, SCF_PCNC, SCF_MECH, SCF_SECS } - private static final EnumMap Catscf = new EnumMap(CatSCF.class); static { Catscf.put(CatSCF.SCF_UNKN, new S57enum(0, "")); + private static final EnumMap Catscf = new EnumMap<>(CatSCF.class); static { Catscf.put(CatSCF.SCF_UNKN, new S57enum(0, "")); Catscf.put(CatSCF.SCF_VBTH, new S57enum(1, "visitor_berth")); Catscf.put(CatSCF.SCF_CLUB, new S57enum(2, "nautical_club")); Catscf.put(CatSCF.SCF_BHST, new S57enum(3, "boat_hoist")); Catscf.put(CatSCF.SCF_SMKR, new S57enum(4, "sailmaker")); Catscf.put(CatSCF.SCF_BTYD, new S57enum(5, "boatyard")); Catscf.put(CatSCF.SCF_INN, new S57enum(6, "public_inn")); @@ -452,5 +451,5 @@ SPM_NOTC, SPM_TSS, SPM_NANC, SPM_NBRT, SPM_NOTK, SPM_NTWT, SPM_RWAK, SPM_SPDL, SPM_STOP, SPM_WRNG, SPM_SSSN, SPM_RVCL, SPM_MVDT, SPM_RHCL, SPM_SCNT, SPM_BRTH, SPM_OHPC, SPM_CHEG, SPM_TELE, SPM_FCRS, SPM_MTRL, SPM_PLIN, SPM_ANCH, SPM_CLRG, SPM_CTRL, SPM_DIVG, SPM_RBCN, SPM_FGND, SPM_YCHT, SPM_HPRT, SPM_GPS, SPM_SLDG, SPM_NENT, SPM_WRKP, SPM_UKPP, SPM_WELH, SPM_CHSP, SPM_MFRM, SPM_AREF } - private static final EnumMap Catspm = new EnumMap(CatSPM.class); static { Catspm.put(CatSPM.SPM_UNKN, new S57enum(0, "")); + private static final EnumMap Catspm = new EnumMap<>(CatSPM.class); static { Catspm.put(CatSPM.SPM_UNKN, new S57enum(0, "")); Catspm.put(CatSPM.SPM_FDGA, new S57enum(1, "firing_danger_area")); Catspm.put(CatSPM.SPM_TRGT, new S57enum(2, "target")); Catspm.put(CatSPM.SPM_MSHP, new S57enum(3, "marker_ship")); Catspm.put(CatSPM.SPM_DGRG, new S57enum(4, "degaussing_range")); Catspm.put(CatSPM.SPM_BARG, new S57enum(5, "barge")); Catspm.put(CatSPM.SPM_CABL, new S57enum(6, "cable")); @@ -475,14 +474,14 @@ } public enum CatTRK { TRK_UNKN, TRK_FIXM, TRK_NFXM } - private static final EnumMap Cattrk = new EnumMap(CatTRK.class); static { Cattrk.put(CatTRK.TRK_UNKN, new S57enum(0, "")); + private static final EnumMap Cattrk = new EnumMap<>(CatTRK.class); static { Cattrk.put(CatTRK.TRK_UNKN, new S57enum(0, "")); Cattrk.put(CatTRK.TRK_FIXM, new S57enum(1, "fixed_marks")); Cattrk.put(CatTRK.TRK_NFXM, new S57enum(2, "no_fixed_marks")); } public enum CatTSS { TSS_UNKN, TSS_IMOA, TSS_NIMO } - private static final EnumMap Cattss = new EnumMap(CatTSS.class); static { Cattss.put(CatTSS.TSS_UNKN, new S57enum(0, "")); + private static final EnumMap Cattss = new EnumMap<>(CatTSS.class); static { Cattss.put(CatTSS.TSS_UNKN, new S57enum(0, "")); Cattss.put(CatTSS.TSS_IMOA, new S57enum(1, "imo_adopted")); Cattss.put(CatTSS.TSS_NIMO, new S57enum(2, "not_imo_adopted")); } public enum CatVEG { VEG_UNKN, VEG_GRAS, VEG_PDDY, VEG_BUSH, VEG_DCDW, VEG_CONW, VEG_WOOD, VEG_MGRV, VEG_PARK, VEG_PKLD, VEG_MCRP, VEG_REED, VEG_MOSS, VEG_TREE, VEG_EVGT, VEG_CONT, VEG_PLMT, VEG_NPMT, VEG_CSAT, VEG_EUCT, VEG_DCDT, VEG_MRVT, VEG_FLOT } - private static final EnumMap Catveg = new EnumMap(CatVEG.class); static { Catveg.put(CatVEG.VEG_UNKN, new S57enum(0, "")); + private static final EnumMap Catveg = new EnumMap<>(CatVEG.class); static { Catveg.put(CatVEG.VEG_UNKN, new S57enum(0, "")); Catveg.put(CatVEG.VEG_GRAS, new S57enum(1, "grass")); Catveg.put(CatVEG.VEG_PDDY, new S57enum(2, "paddy")); Catveg.put(CatVEG.VEG_BUSH, new S57enum(3, "bush")); Catveg.put(CatVEG.VEG_DCDW, new S57enum(4, "deciduous_wood")); Catveg.put(CatVEG.VEG_CONW, new S57enum(5, "coniferous_wood")); Catveg.put(CatVEG.VEG_WOOD, new S57enum(6, "wood")); @@ -495,25 +494,25 @@ } public enum CatWAT { WAT_UNKN, WAT_BKRS, WAT_EDDY, WAT_OVFL, WAT_TDRP, WAT_BMBR } - private static final EnumMap Catwat = new EnumMap(CatWAT.class); static { Catwat.put(CatWAT.WAT_UNKN, new S57enum(0, "")); + private static final EnumMap Catwat = new EnumMap<>(CatWAT.class); static { Catwat.put(CatWAT.WAT_UNKN, new S57enum(0, "")); Catwat.put(CatWAT.WAT_BKRS, new S57enum(1, "breakers")); Catwat.put(CatWAT.WAT_EDDY, new S57enum(2, "eddies")); Catwat.put(CatWAT.WAT_OVFL, new S57enum(3, "overfalls")); Catwat.put(CatWAT.WAT_TDRP, new S57enum(4, "tide_rips")); Catwat.put(CatWAT.WAT_BMBR, new S57enum(5, "bombora")); } public enum CatWED { WED_UNKN, WED_KELP, WED_SWED, WED_SGRS, WED_SGSO } - private static final EnumMap Catwed = new EnumMap(CatWED.class); static { Catwed.put(CatWED.WED_UNKN, new S57enum(0, "")); + private static final EnumMap Catwed = new EnumMap<>(CatWED.class); static { Catwed.put(CatWED.WED_UNKN, new S57enum(0, "")); Catwed.put(CatWED.WED_KELP, new S57enum(1, "kelp")); Catwed.put(CatWED.WED_SWED, new S57enum(2, "sea_weed")); Catwed.put(CatWED.WED_SGRS, new S57enum(3, "sea_grass")); Catwed.put(CatWED.WED_SGSO, new S57enum(4, "sargasso")); } public enum CatWRK { WRK_UNKN, WRK_NDGR, WRK_DNGR, WRK_DREM, WRK_MSTS, WRK_HULS } - private static final EnumMap Catwrk = new EnumMap(CatWRK.class); static { Catwrk.put(CatWRK.WRK_UNKN, new S57enum(0, "")); + private static final EnumMap Catwrk = new EnumMap<>(CatWRK.class); static { Catwrk.put(CatWRK.WRK_UNKN, new S57enum(0, "")); Catwrk.put(CatWRK.WRK_NDGR, new S57enum(1, "non-dangerous")); Catwrk.put(CatWRK.WRK_DNGR, new S57enum(2, "dangerous")); Catwrk.put(CatWRK.WRK_DREM, new S57enum(3, "distributed_remains")); Catwrk.put(CatWRK.WRK_MSTS, new S57enum(4, "mast_showing")); Catwrk.put(CatWRK.WRK_HULS, new S57enum(5, "hull_showing")); } public enum CatZOC { ZOC_UNKN, ZOC_A1, ZOC_A2, ZOC_B, ZOC_C, ZOC_D, ZOC_U } - private static final EnumMap Catzoc = new EnumMap(CatZOC.class); static { Catzoc.put(CatZOC.ZOC_UNKN, new S57enum(0, "")); + private static final EnumMap Catzoc = new EnumMap<>(CatZOC.class); static { Catzoc.put(CatZOC.ZOC_UNKN, new S57enum(0, "")); Catzoc.put(CatZOC.ZOC_A1, new S57enum(1, "a1")); Catzoc.put(CatZOC.ZOC_A2, new S57enum(2, "a2")); Catzoc.put(CatZOC.ZOC_B, new S57enum(3, "b")); Catzoc.put(CatZOC.ZOC_C, new S57enum(4, "c")); Catzoc.put(CatZOC.ZOC_D, new S57enum(5, "d")); Catzoc.put(CatZOC.ZOC_U, new S57enum(6, "u")); } public enum ColCOL { COL_UNK, COL_WHT, COL_BLK, COL_RED, COL_GRN, COL_BLU, COL_YEL, COL_GRY, COL_BRN, COL_AMB, COL_VIO, COL_ORG, COL_MAG, COL_PNK } - private static final EnumMap Colour = new EnumMap(ColCOL.class); static { Colour.put(ColCOL.COL_UNK, new S57enum(0, "")); + private static final EnumMap Colour = new EnumMap<>(ColCOL.class); static { Colour.put(ColCOL.COL_UNK, new S57enum(0, "")); Colour.put(ColCOL.COL_WHT, new S57enum(1, "white")); Colour.put(ColCOL.COL_BLK, new S57enum(2, "black")); Colour.put(ColCOL.COL_RED, new S57enum(3, "red")); Colour.put(ColCOL.COL_GRN, new S57enum(4, "green")); Colour.put(ColCOL.COL_BLU, new S57enum(5, "blue")); Colour.put(ColCOL.COL_YEL, new S57enum(6, "yellow")); @@ -523,5 +522,5 @@ } public enum ColPAT { PAT_UNKN, PAT_HORI, PAT_VERT, PAT_DIAG, PAT_SQUR, PAT_STRP, PAT_BRDR, PAT_CROS, PAT_SALT } - private static final EnumMap Colpat = new EnumMap(ColPAT.class); static { Colpat.put(ColPAT.PAT_UNKN, new S57enum(0, "")); + private static final EnumMap Colpat = new EnumMap<>(ColPAT.class); static { Colpat.put(ColPAT.PAT_UNKN, new S57enum(0, "")); Colpat.put(ColPAT.PAT_HORI, new S57enum(1, "horizontal")); Colpat.put(ColPAT.PAT_VERT, new S57enum(2, "vertical")); Colpat.put(ColPAT.PAT_DIAG, new S57enum(3, "diagonal")); Colpat.put(ColPAT.PAT_SQUR, new S57enum(4, "squared")); Colpat.put(ColPAT.PAT_STRP, new S57enum(5, "stripes")); Colpat.put(ColPAT.PAT_BRDR, new S57enum(6, "border")); @@ -529,28 +528,28 @@ } public enum CndCND { CND_UNKN, CND_UCNS, CND_RUIN, CND_URCL, CND_WLES, CND_PCNS } - private static final EnumMap Condtn = new EnumMap(CndCND.class); static { Condtn.put(CndCND.CND_UNKN, new S57enum(0, "")); + private static final EnumMap Condtn = new EnumMap<>(CndCND.class); static { Condtn.put(CndCND.CND_UNKN, new S57enum(0, "")); Condtn.put(CndCND.CND_UCNS, new S57enum(1, "under_construction")); Condtn.put(CndCND.CND_RUIN, new S57enum(2, "ruined")); Condtn.put(CndCND.CND_URCL, new S57enum(3, "under_reclamation")); Condtn.put(CndCND.CND_WLES, new S57enum(4, "wingless")); Condtn.put(CndCND.CND_PCNS, new S57enum(5, "planned_construction")); } public enum ConRAD { RAD_UNKN, RAD_CNSP, RAD_NCSP, RAD_REFL } - private static final EnumMap Conrad = new EnumMap(ConRAD.class); static { Conrad.put(ConRAD.RAD_UNKN, new S57enum(0, "")); + private static final EnumMap Conrad = new EnumMap<>(ConRAD.class); static { Conrad.put(ConRAD.RAD_UNKN, new S57enum(0, "")); Conrad.put(ConRAD.RAD_CNSP, new S57enum(1, "conspicuous")); Conrad.put(ConRAD.RAD_NCSP, new S57enum(2, "not_conspicuous")); Conrad.put(ConRAD.RAD_REFL, new S57enum(3, "reflector")); } public enum ConVIS { VIS_UNKN, VIS_CNSP, VIS_NCSP } - private static final EnumMap Convis = new EnumMap(ConVIS.class); static { Convis.put(ConVIS.VIS_UNKN, new S57enum(0, "")); + private static final EnumMap Convis = new EnumMap<>(ConVIS.class); static { Convis.put(ConVIS.VIS_UNKN, new S57enum(0, "")); Convis.put(ConVIS.VIS_CNSP, new S57enum(1, "conspicuous")); Convis.put(ConVIS.VIS_NCSP, new S57enum(2, "not_conspicuous")); } public enum UniDPU { DPU_UNKN, DPU_METR, DPU_FTFT, DPU_FTHM, DPU_FTFR } - private static final EnumMap Dunits = new EnumMap(UniDPU.class); static { Dunits.put(UniDPU.DPU_UNKN, new S57enum(0, "")); + private static final EnumMap Dunits = new EnumMap<>(UniDPU.class); static { Dunits.put(UniDPU.DPU_UNKN, new S57enum(0, "")); Dunits.put(UniDPU.DPU_METR, new S57enum(1, "metres")); Dunits.put(UniDPU.DPU_FTFT, new S57enum(2, "fathoms_feet")); Dunits.put(UniDPU.DPU_FTHM, new S57enum(3, "fathoms")); Dunits.put(UniDPU.DPU_FTFR, new S57enum(4, "fathoms_fractions")); } public enum ExcLIT { EXH_UNKN, EXH_24H, EXH_DAY, EXH_FOG, EXH_NGHT, EXH_WRNG, EXH_STRM } - private static final EnumMap Exclit = new EnumMap(ExcLIT.class); static { Exclit.put(ExcLIT.EXH_UNKN, new S57enum(0, "")); + private static final EnumMap Exclit = new EnumMap<>(ExcLIT.class); static { Exclit.put(ExcLIT.EXH_UNKN, new S57enum(0, "")); Exclit.put(ExcLIT.EXH_24H, new S57enum(1, "24h")); Exclit.put(ExcLIT.EXH_DAY, new S57enum(2, "day")); Exclit.put(ExcLIT.EXH_FOG, new S57enum(3, "fog")); Exclit.put(ExcLIT.EXH_NGHT, new S57enum(4, "night")); Exclit.put(ExcLIT.EXH_WRNG, new S57enum(5, "warning")); Exclit.put(ExcLIT.EXH_STRM, new S57enum(6, "storm")); } public enum ExpSOU { EXP_UNKN, EXP_WTHN, EXP_SHLR, EXP_DEPR } - private static final EnumMap Expsou = new EnumMap(ExpSOU.class); static { Expsou.put(ExpSOU.EXP_UNKN, new S57enum(0, "")); + private static final EnumMap Expsou = new EnumMap<>(ExpSOU.class); static { Expsou.put(ExpSOU.EXP_UNKN, new S57enum(0, "")); Expsou.put(ExpSOU.EXP_WTHN, new S57enum(1, "within")); Expsou.put(ExpSOU.EXP_SHLR, new S57enum(2, "shoaler")); Expsou.put(ExpSOU.EXP_DEPR, new S57enum(3, "deeper")); } @@ -558,5 +557,5 @@ FNC_DIST, FNC_TRNS, FNC_FCTY, FNC_POWR, FNC_ADMIN, FNC_EDUC, FNC_CHCH, FNC_CHPL, FNC_TMPL, FNC_PGDA, FNC_SHSH, FNC_BTMP, FNC_MOSQ, FNC_MRBT, FNC_LOOK, FNC_COMM, FNC_TV, FNC_RADO, FNC_RADR, FNC_LGHT, FNC_MCWV, FNC_COOL, FNC_OBS, FNC_TMBL, FNC_CLOK, FNC_CTRL, FNC_ASHM, FNC_STAD, FNC_BUSS } - private static final EnumMap Functn = new EnumMap(FncFNC.class); static {Functn.put(FncFNC.FNC_UNKN, new S57enum(0, "")); + private static final EnumMap Functn = new EnumMap<>(FncFNC.class); static {Functn.put(FncFNC.FNC_UNKN, new S57enum(0, "")); Functn.put(FncFNC.FNC_HBRM, new S57enum(2, "harbour_master")); Functn.put(FncFNC.FNC_CSTM, new S57enum(3, "customs")); Functn.put(FncFNC.FNC_HLTH, new S57enum(4, "health")); Functn.put(FncFNC.FNC_HOSP, new S57enum(5, "hospital")); Functn.put(FncFNC.FNC_POST, new S57enum(6, "post_office")); Functn.put(FncFNC.FNC_HOTL, new S57enum(7, "hotel")); @@ -575,15 +574,15 @@ } public enum UniHLU { HLU_UNKN, HLU_METR, HLU_FEET, HLU_KMTR, HLU_HMTR, HLU_SMIL, HLU_NMIL } - private static final EnumMap Hunits = new EnumMap(UniHLU.class); static { Hunits.put(UniHLU.HLU_UNKN, new S57enum(0, "")); + private static final EnumMap Hunits = new EnumMap<>(UniHLU.class); static { Hunits.put(UniHLU.HLU_UNKN, new S57enum(0, "")); Hunits.put(UniHLU.HLU_METR, new S57enum(1, "metres")); Hunits.put(UniHLU.HLU_FEET, new S57enum(2, "feet")); Hunits.put(UniHLU.HLU_KMTR, new S57enum(3, "kilometres")); Hunits.put(UniHLU.HLU_HMTR, new S57enum(4, "hectometres")); Hunits.put(UniHLU.HLU_SMIL, new S57enum(5, "statute_miles")); Hunits.put(UniHLU.HLU_NMIL, new S57enum(6, "nautical_miles")); } public enum JrsJRS { JRS_UNKN, JRS_INT, JRS_NAT, JRS_NSD } - private static final EnumMap Jrsdtn = new EnumMap(JrsJRS.class); static { Jrsdtn.put(JrsJRS.JRS_UNKN, new S57enum(0, "")); + private static final EnumMap Jrsdtn = new EnumMap<>(JrsJRS.class); static { Jrsdtn.put(JrsJRS.JRS_UNKN, new S57enum(0, "")); Jrsdtn.put(JrsJRS.JRS_INT, new S57enum(1, "international")); Jrsdtn.put(JrsJRS.JRS_NAT, new S57enum(2, "national")); Jrsdtn.put(JrsJRS.JRS_NSD, new S57enum(3, "national_sub-division")); } public enum LitCHR { CHR_UNKN, CHR_F, CHR_FL, CHR_LFL, CHR_Q, CHR_VQ, CHR_UQ, CHR_ISO, CHR_OC, CHR_IQ, CHR_IVQ, CHR_IUQ, CHR_MO, CHR_FFL, CHR_FLLFL, CHR_OCFL, CHR_FLFL, CHR_ALOC, CHR_ALLFL, CHR_ALFL, CHR_ALGR, CHR_QLFL, CHR_VQLFL, CHR_UQLFL, CHR_AL, CHR_ALFFL } - private static final EnumMap Litchr = new EnumMap(LitCHR.class); static { Litchr.put(LitCHR.CHR_UNKN, new S57enum(0, "")); + private static final EnumMap Litchr = new EnumMap<>(LitCHR.class); static { Litchr.put(LitCHR.CHR_UNKN, new S57enum(0, "")); Litchr.put(LitCHR.CHR_F, new S57enum(1, "F")); Litchr.put(LitCHR.CHR_FL, new S57enum(2, "Fl")); Litchr.put(LitCHR.CHR_LFL, new S57enum(3, "LFl")); Litchr.put(LitCHR.CHR_Q, new S57enum(4, "Q")); Litchr.put(LitCHR.CHR_VQ, new S57enum(5, "VQ")); Litchr.put(LitCHR.CHR_UQ, new S57enum(6, "UQ")); Litchr.put(LitCHR.CHR_ISO, new S57enum(7, "Iso")); Litchr.put(LitCHR.CHR_OC, new S57enum(8, "Oc")); @@ -596,5 +595,5 @@ } public enum LitVIS { LIT_UNKN, LIT_HIGH, LIT_LOW, LIT_FANT, LIT_INTS, LIT_UINT, LIT_RSTR, LIT_OBSC, LIT_POBS } - private static final EnumMap Litvis = new EnumMap(LitVIS.class); static { Litvis.put(LitVIS.LIT_UNKN, new S57enum(0, "")); + private static final EnumMap Litvis = new EnumMap<>(LitVIS.class); static { Litvis.put(LitVIS.LIT_UNKN, new S57enum(0, "")); Litvis.put(LitVIS.LIT_HIGH, new S57enum(1, "high")); Litvis.put(LitVIS.LIT_LOW, new S57enum(2, "low")); Litvis.put(LitVIS.LIT_FANT, new S57enum(3, "faint")); Litvis.put(LitVIS.LIT_INTS, new S57enum(4, "intensified")); Litvis.put(LitVIS.LIT_UINT, new S57enum(5, "unintensified")); Litvis.put(LitVIS.LIT_RSTR, new S57enum(6, "restricted")); @@ -602,5 +601,5 @@ } public enum MarSYS { SYS_UNKN, SYS_IALA, SYS_IALB, SYS_NONE, SYS_OTHR, SYS_CEVN, SYS_RIWR, SYS_BWR2, SYS_BNWR, SYS_PPWB } - private static final EnumMap Marsys = new EnumMap(MarSYS.class); static { Marsys.put(MarSYS.SYS_UNKN, new S57enum(0, "")); + private static final EnumMap Marsys = new EnumMap<>(MarSYS.class); static { Marsys.put(MarSYS.SYS_UNKN, new S57enum(0, "")); Marsys.put(MarSYS.SYS_IALA, new S57enum(1, "iala-a")); Marsys.put(MarSYS.SYS_IALB, new S57enum(2, "iala-b")); Marsys.put(MarSYS.SYS_NONE, new S57enum(9, "none")); Marsys.put(MarSYS.SYS_OTHR, new S57enum(10, "other")); Marsys.put(MarSYS.SYS_CEVN, new S57enum(11, "cevni")); Marsys.put(MarSYS.SYS_RIWR, new S57enum(12, "riwr")); @@ -608,5 +607,5 @@ } public enum NatCON { CON_UNKN, CON_MSNY, CON_CONC, CON_BDRS, CON_HSRF, CON_USRF, CON_WOOD, CON_METL, CON_GRP, CON_PNTD, CON_FMWK } - private static final EnumMap Natcon = new EnumMap(NatCON.class); static { Natcon.put(NatCON.CON_UNKN, new S57enum(0, "")); + private static final EnumMap Natcon = new EnumMap<>(NatCON.class); static { Natcon.put(NatCON.CON_UNKN, new S57enum(0, "")); Natcon.put(NatCON.CON_MSNY, new S57enum(1, "masonry")); Natcon.put(NatCON.CON_CONC, new S57enum(2, "concreted")); Natcon.put(NatCON.CON_BDRS, new S57enum(3, "loose_boulders")); Natcon.put(NatCON.CON_HSRF, new S57enum(4, "hard-surfaced")); Natcon.put(NatCON.CON_USRF, new S57enum(5, "unsurfaced")); Natcon.put(NatCON.CON_WOOD, new S57enum(6, "wooden")); @@ -615,5 +614,5 @@ } public enum NatSUR { SUR_UNKN, SUR_MUD, SUR_CLAY, SUR_SILT, SUR_SAND, SUR_STON, SUR_GRVL, SUR_PBBL, SUR_CBBL, SUR_ROCK, SUR_LAVA, SUR_CORL, SUR_SHEL, SUR_BLDR } - private static final EnumMap Natsur = new EnumMap(NatSUR.class); static { Natsur.put(NatSUR.SUR_UNKN, new S57enum(0, "")); + private static final EnumMap Natsur = new EnumMap<>(NatSUR.class); static { Natsur.put(NatSUR.SUR_UNKN, new S57enum(0, "")); Natsur.put(NatSUR.SUR_MUD, new S57enum(1, "mud")); Natsur.put(NatSUR.SUR_CLAY, new S57enum(2, "clay")); Natsur.put(NatSUR.SUR_SILT, new S57enum(3, "silt")); Natsur.put(NatSUR.SUR_SAND, new S57enum(4, "sand")); Natsur.put(NatSUR.SUR_STON, new S57enum(5, "stone")); Natsur.put(NatSUR.SUR_GRVL, new S57enum(6, "gravel")); @@ -623,5 +622,5 @@ } public enum NatQUA { QUA_UNKN, QUA_FINE, QUA_MEDM, QUA_CORS, QUA_BRKN, QUA_STKY, QUA_SOFT, QUA_STIF, QUA_VCNC, QUA_CALC, QUA_HARD } - private static final EnumMap Natqua = new EnumMap(NatQUA.class); static { Natqua.put(NatQUA.QUA_UNKN, new S57enum(0, "")); + private static final EnumMap Natqua = new EnumMap<>(NatQUA.class); static { Natqua.put(NatQUA.QUA_UNKN, new S57enum(0, "")); Natqua.put(NatQUA.QUA_FINE, new S57enum(1, "fine")); Natqua.put(NatQUA.QUA_MEDM, new S57enum(2, "medium")); Natqua.put(NatQUA.QUA_CORS, new S57enum(3, "coarse")); Natqua.put(NatQUA.QUA_BRKN, new S57enum(4, "broken")); Natqua.put(NatQUA.QUA_STKY, new S57enum(5, "sticky")); Natqua.put(NatQUA.QUA_SOFT, new S57enum(6, "soft")); @@ -631,5 +630,5 @@ public enum PrdPRD { PRD_UNKN, PRD_OIL, PRD_GAS, PRD_WATR, PRD_STON, PRD_COAL, PRD_ORE, PRD_CHEM, PRD_DWTR, PRD_MILK, PRD_BXIT, PRD_COKE, PRD_IIGS, PRD_SALT, PRD_SAND, PRD_TMBR, PRD_SDST, PRD_SCRP, PRD_LNA, PRD_LPA, PRD_WINE, PRD_CMNT, PRD_GRAN } - private static final EnumMap Prodct = new EnumMap(PrdPRD.class); static { Prodct.put(PrdPRD.PRD_UNKN, new S57enum(0, "")); + private static final EnumMap Prodct = new EnumMap<>(PrdPRD.class); static { Prodct.put(PrdPRD.PRD_UNKN, new S57enum(0, "")); Prodct.put(PrdPRD.PRD_OIL, new S57enum(1, "oil")); Prodct.put(PrdPRD.PRD_GAS, new S57enum(2, "gas")); Prodct.put(PrdPRD.PRD_WATR, new S57enum(3, "water")); Prodct.put(PrdPRD.PRD_STON, new S57enum(4, "stone")); Prodct.put(PrdPRD.PRD_COAL, new S57enum(5, "coal")); Prodct.put(PrdPRD.PRD_ORE, new S57enum(6, "ore")); @@ -642,5 +641,5 @@ } public enum QuaSOU { SOU_UNKN, SOU_KNWN, SOU_UKNN, SOU_DFUL, SOU_UNRL, SOU_NBFD, SOU_LKWN, SOU_LUKN, SOU_NSRV, SOU_NCNF, SOU_MANT, SOU_NMNT } - private static final EnumMap Quasou = new EnumMap(QuaSOU.class); static { Quasou.put(QuaSOU.SOU_UNKN, new S57enum(0, "")); + private static final EnumMap Quasou = new EnumMap<>(QuaSOU.class); static { Quasou.put(QuaSOU.SOU_UNKN, new S57enum(0, "")); Quasou.put(QuaSOU.SOU_KNWN, new S57enum(1, "known")); Quasou.put(QuaSOU.SOU_UKNN, new S57enum(2, "unknown")); Quasou.put(QuaSOU.SOU_DFUL, new S57enum(3, "doubtful")); Quasou.put(QuaSOU.SOU_UNRL, new S57enum(4, "unreliable")); Quasou.put(QuaSOU.SOU_NBFD, new S57enum(5, "no_bottom_found")); Quasou.put(QuaSOU.SOU_LKWN, new S57enum(6, "least_known")); @@ -650,5 +649,5 @@ public enum RstRST { RST_UNKN, RST_NANC, RST_RANC, RST_NFSH, RST_RFSH, RST_NTRL, RST_RTRL, RST_NENT, RST_RENT, RST_NDRG, RST_RDRG, RST_NDVG, RST_RDVG, RST_NWAK, RST_TBAV, RST_NCST, RST_NDSC, RST_RDSC, RST_NEXD, RST_REXD, RST_NDRL, RST_RDRL, RST_NHAR, RST_NLTG, RST_NDRA, RST_NSTP, RST_NLND, RST_RSPD, RST_NOVT, RST_NCOV, RST_NPOV, RST_NBRT, RST_RBRT, RST_NMFT, RST_RMFT, RST_NTRN, RST_RFWD } - private static final EnumMap Restrn = new EnumMap(RstRST.class); static { Restrn.put(RstRST.RST_UNKN, new S57enum(0, "")); + private static final EnumMap Restrn = new EnumMap<>(RstRST.class); static { Restrn.put(RstRST.RST_UNKN, new S57enum(0, "")); Restrn.put(RstRST.RST_NANC, new S57enum(1, "no_anchoring")); Restrn.put(RstRST.RST_RANC, new S57enum(2, "restricted_anchoring")); Restrn.put(RstRST.RST_NFSH, new S57enum(3, "no_fishing")); Restrn.put(RstRST.RST_RFSH, new S57enum(4, "restricted_fishing")); Restrn.put(RstRST.RST_NTRL, new S57enum(5, "no_trawling")); Restrn.put(RstRST.RST_RTRL, new S57enum(6, "restricted_trawling")); @@ -666,10 +665,10 @@ } public enum SigGEN { GEN_UNKN, GEN_AUTO, GEN_WAVE, GEN_HAND, GEN_WIND } - private static final EnumMap Siggen = new EnumMap(SigGEN.class); static { Siggen.put(SigGEN.GEN_UNKN, new S57enum(0, "")); + private static final EnumMap Siggen = new EnumMap<>(SigGEN.class); static { Siggen.put(SigGEN.GEN_UNKN, new S57enum(0, "")); Siggen.put(SigGEN.GEN_AUTO, new S57enum(1, "automatic")); Siggen.put(SigGEN.GEN_WAVE, new S57enum(2, "wave")); Siggen.put(SigGEN.GEN_HAND, new S57enum(3, "hand")); Siggen.put(SigGEN.GEN_WIND, new S57enum(4, "wind")); } public enum StsSTS { STS_UNKN, STS_PERM, STS_OCAS, STS_RCMD, STS_NIUS, STS_IMTT, STS_RESV, STS_TEMP, STS_PRIV, STS_MAND, STS_EXTD, STS_ILLD, STS_HIST, STS_PBLC, STS_SYNC, STS_WCHD, STS_UWCD, STS_EDBT, STS_OREQ, STS_DPAW, STS_RSNG, STS_INCR, STS_DECR, TS_STNG, STS_GOOD, STS_MODY, STS_POOR } - private static final EnumMap Status = new EnumMap(StsSTS.class); static { Status.put(StsSTS.STS_UNKN, new S57enum(0, "")); + private static final EnumMap Status = new EnumMap<>(StsSTS.class); static { Status.put(StsSTS.STS_UNKN, new S57enum(0, "")); Status.put(StsSTS.STS_PERM, new S57enum(1, "permanent")); Status.put(StsSTS.STS_OCAS, new S57enum(2, "occasional")); Status.put(StsSTS.STS_RCMD, new S57enum(3, "recommended")); Status.put(StsSTS.STS_NIUS, new S57enum(4, "not_in_use")); Status.put(StsSTS.STS_IMTT, new S57enum(5, "intermittent")); Status.put(StsSTS.STS_RESV, new S57enum(6, "reserved")); @@ -683,10 +682,10 @@ } public enum SurTYP { TYP_UNKN, TYP_SKCH, TYP_CTLD, TYP_PSSG, TYP_REMT } - private static final EnumMap Surtyp = new EnumMap(SurTYP.class); static { Surtyp.put(SurTYP.TYP_UNKN, new S57enum(0, "")); + private static final EnumMap Surtyp = new EnumMap<>(SurTYP.class); static { Surtyp.put(SurTYP.TYP_UNKN, new S57enum(0, "")); Surtyp.put(SurTYP.TYP_SKCH, new S57enum(1, "sketch")); Surtyp.put(SurTYP.TYP_CTLD, new S57enum(2, "controlled")); Surtyp.put(SurTYP.TYP_PSSG, new S57enum(4, "examination")); Surtyp.put(SurTYP.TYP_PSSG, new S57enum(5, "passage")); Surtyp.put(SurTYP.TYP_REMT, new S57enum(6, "remote")); } public enum TecSOU { SOU_UNKN, SOU_ESND, SOU_FSSN, SOU_MLBM, SOU_DIVR, SOU_LDLN, SOU_WDRG, SOU_LASR, SOU_VACC, SOU_EMAG, SOU_PHGY, SOU_SATL, SOU_LEVL, SOU_SSSN, SOU_COMP } - private static final EnumMap Tecsou = new EnumMap(TecSOU.class); static { Tecsou.put(TecSOU.SOU_UNKN, new S57enum(0, "")); + private static final EnumMap Tecsou = new EnumMap<>(TecSOU.class); static { Tecsou.put(TecSOU.SOU_UNKN, new S57enum(0, "")); Tecsou.put(TecSOU.SOU_ESND, new S57enum(1, "echo-sounder")); Tecsou.put(TecSOU.SOU_FSSN, new S57enum(2, "side-scan_sonar")); Tecsou.put(TecSOU.SOU_MLBM, new S57enum(3, "multi-beam")); Tecsou.put(TecSOU.SOU_DIVR, new S57enum(4, "diver")); Tecsou.put(TecSOU.SOU_LDLN, new S57enum(5, "lead-line")); Tecsou.put(TecSOU.SOU_WDRG, new S57enum(6, "wire-drag")); @@ -698,5 +697,5 @@ TOP_NORTH, TOP_SOUTH, TOP_BESM, TOP_IBESM, TOP_FLAG, TOP_SPRH, TOP_SQUR, TOP_HRECT, TOP_VRECT, TOP_TRAP, TOP_ITRAP, TOP_TRI, TOP_ITRI, TOP_CIRC, TOP_CRSS, TOP_T, TOP_TRCL, TOP_CRCL, TOP_RHCL, TOP_CLTR, TOP_OTHR } - private static final EnumMap Topshp = new EnumMap(TopSHP.class); static { Topshp.put(TopSHP.TOP_UNKN, new S57enum(0, "")); + private static final EnumMap Topshp = new EnumMap<>(TopSHP.class); static { Topshp.put(TopSHP.TOP_UNKN, new S57enum(0, "")); Topshp.put(TopSHP.TOP_CONE, new S57enum(1, "cone, point up")); Topshp.put(TopSHP.TOP_ICONE, new S57enum(2, "cone, point down")); Topshp.put(TopSHP.TOP_SPHR, new S57enum(3, "sphere")); Topshp.put(TopSHP.TOP_ISD, new S57enum(4, "2 spheres")); Topshp.put(TopSHP.TOP_CAN, new S57enum(5, "cylinder")); Topshp.put(TopSHP.TOP_BORD, new S57enum(6, "board")); @@ -712,10 +711,10 @@ } public enum TrfTRF { TRF_UNKN, TRF_INBD, TRF_OBND, TRF_ONEW, TRF_TWOW } - private static final EnumMap Trafic = new EnumMap(TrfTRF.class); static { Trafic.put(TrfTRF.TRF_UNKN, new S57enum(0, "")); + private static final EnumMap Trafic = new EnumMap<>(TrfTRF.class); static { Trafic.put(TrfTRF.TRF_UNKN, new S57enum(0, "")); Trafic.put(TrfTRF.TRF_INBD, new S57enum(1, "inbound")); Trafic.put(TrfTRF.TRF_OBND, new S57enum(2, "outbbound")); Trafic.put(TrfTRF.TRF_ONEW, new S57enum(3, "one-way")); Trafic.put(TrfTRF.TRF_TWOW, new S57enum(4, "two-way")); } public enum WatLEV { LEV_UNKN, LEV_PSUB, LEV_DRY, LEV_SUBM, LEV_CVRS, LEV_AWSH, LEV_FLDS, LEV_FLTG, LEV_AMWL, LEV_BMWL } - private static final EnumMap Watlev = new EnumMap(WatLEV.class); static { Watlev.put(WatLEV.LEV_UNKN, new S57enum(0, "")); + private static final EnumMap Watlev = new EnumMap<>(WatLEV.class); static { Watlev.put(WatLEV.LEV_UNKN, new S57enum(0, "")); Watlev.put(WatLEV.LEV_PSUB, new S57enum(1, "part-submerged")); Watlev.put(WatLEV.LEV_DRY, new S57enum(2, "dry")); Watlev.put(WatLEV.LEV_SUBM, new S57enum(3, "submerged")); Watlev.put(WatLEV.LEV_CVRS, new S57enum(4, "covers")); Watlev.put(WatLEV.LEV_AWSH, new S57enum(5, "awash")); Watlev.put(WatLEV.LEV_FLDS, new S57enum(6, "floods")); @@ -723,14 +722,14 @@ } public enum Cat_TS { TS_UNKN, TS_FLOD, TS_EBB, TS_OTHR } - private static final EnumMap Cat_ts = new EnumMap(Cat_TS.class); static { Cat_ts.put(Cat_TS.TS_UNKN, new S57enum(0, "")); + private static final EnumMap Cat_ts = new EnumMap<>(Cat_TS.class); static { Cat_ts.put(Cat_TS.TS_UNKN, new S57enum(0, "")); Cat_ts.put(Cat_TS.TS_FLOD, new S57enum(1, "flood")); Cat_ts.put(Cat_TS.TS_EBB, new S57enum(2, "ebb")); Cat_ts.put(Cat_TS.TS_OTHR, new S57enum(3, "other")); } public enum UniPAU { PAU_UNKN, PAU_MTRS, PAU_DGRS, PAU_MMTR, PAU_FEET, PAU_CBLS } - private static final EnumMap Punits = new EnumMap(UniPAU.class); static { Punits.put(UniPAU.PAU_UNKN, new S57enum(0, "")); + private static final EnumMap Punits = new EnumMap<>(UniPAU.class); static { Punits.put(UniPAU.PAU_UNKN, new S57enum(0, "")); Punits.put(UniPAU.PAU_MTRS, new S57enum(1, "metres")); Punits.put(UniPAU.PAU_DGRS, new S57enum(2, "degrees")); Punits.put(UniPAU.PAU_MMTR, new S57enum(3, "millimetres")); Punits.put(UniPAU.PAU_FEET, new S57enum(4, "feet")); Punits.put(UniPAU.PAU_CBLS, new S57enum(5, "cables")); } public enum QuaPOS { POS_UNKN, POS_SRVD, POS_USRV, POS_PSRV, POS_APRX, POS_DBTF, POS_URLB, POS_RSRV, POS_UCNF, POS_ESTM, POS_PRCS, POS_CALC } - private static final EnumMap Quapos = new EnumMap(QuaPOS.class); static { Quapos.put(QuaPOS.POS_UNKN, new S57enum(0, "")); + private static final EnumMap Quapos = new EnumMap<>(QuaPOS.class); static { Quapos.put(QuaPOS.POS_UNKN, new S57enum(0, "")); Quapos.put(QuaPOS.POS_SRVD, new S57enum(1, "surveyed")); Quapos.put(QuaPOS.POS_USRV, new S57enum(2, "unsurveyed")); Quapos.put(QuaPOS.POS_PSRV, new S57enum(3, "part-surveyed")); Quapos.put(QuaPOS.POS_APRX, new S57enum(4, "approximate")); Quapos.put(QuaPOS.POS_DBTF, new S57enum(5, "doubtful")); Quapos.put(QuaPOS.POS_URLB, new S57enum(6, "unreliable")); @@ -741,5 +740,5 @@ DAT_MHW, DAT_MHWS, DAT_HW, DAT_AMSL, DAT_HWS, DAT_MHHW, DAT_ESLW, DAT_LAT, DAT_LOCAL, DAT_IGLD, DAT_MWL, DAT_LLWLT, DAT_HHWLT, DAT_NHHW, DAT_HAT, DAT_LLWRL, DAT_LHWRL, DAT_LMWRL, DAT_EHW, DAT_HSHW, DAT_RLWL, DAT_HSHWD, DAT_DRLWRL, DAT_RPWL, DAT_RNBL, DAT_OHIO } - private static final EnumMap Verdat = new EnumMap(VerDAT.class); static { Verdat.put(VerDAT.DAT_UNKN, new S57enum(0, "")); + private static final EnumMap Verdat = new EnumMap<>(VerDAT.class); static { Verdat.put(VerDAT.DAT_UNKN, new S57enum(0, "")); Verdat.put(VerDAT.DAT_MLWS, new S57enum(1, "mlws")); Verdat.put(VerDAT.DAT_MLLWS, new S57enum(2, "mllws")); Verdat.put(VerDAT.DAT_MSL, new S57enum(3, "msl")); Verdat.put(VerDAT.DAT_LLW, new S57enum(4, "llw")); Verdat.put(VerDAT.DAT_MLW, new S57enum(5, "mlw")); Verdat.put(VerDAT.DAT_LLWS, new S57enum(6, "llws")); @@ -758,10 +757,10 @@ } public enum AddMRK { MRK_UNKN, MRK_TOPB, MRK_BOTB, MRK_RTRI, MRK_LTRI, MRK_BTRI } - private static final EnumMap Addmrk = new EnumMap(AddMRK.class); static { Addmrk.put(AddMRK.MRK_UNKN, new S57enum(0, "")); + private static final EnumMap Addmrk = new EnumMap<>(AddMRK.class); static { Addmrk.put(AddMRK.MRK_UNKN, new S57enum(0, "")); Addmrk.put(AddMRK.MRK_TOPB, new S57enum(1, "top_board")); Addmrk.put(AddMRK.MRK_BOTB, new S57enum(2, "bottom_board")); Addmrk.put(AddMRK.MRK_RTRI, new S57enum(3, "right_triangle")); Addmrk.put(AddMRK.MRK_LTRI, new S57enum(4, "left_triangle")); Addmrk.put(AddMRK.MRK_BTRI, new S57enum(5, "bottom_triangle")); } public enum BnkWTW { BWW_UNKN, BWW_LEFT, BWW_RGHT } - private static final EnumMap Bnkwtw = new EnumMap(BnkWTW.class); static { Bnkwtw.put(BnkWTW.BWW_UNKN, new S57enum(0, "")); + private static final EnumMap Bnkwtw = new EnumMap<>(BnkWTW.class); static { Bnkwtw.put(BnkWTW.BWW_UNKN, new S57enum(0, "")); Bnkwtw.put(BnkWTW.BWW_LEFT, new S57enum(1, "left")); Bnkwtw.put(BnkWTW.BWW_RGHT, new S57enum(2, "right")); } @@ -774,5 +773,5 @@ NMK_WRAL, NMK_WLAR, NMK_MWWC, NMK_MWWJ, NMK_MWAR, NMK_MWAL, NMK_WARL, NMK_WALR, NMK_PEND, NMK_DWTR, NMK_TELE, NMK_MTCP, NMK_SPCP, NMK_WSKP, NMK_SLCP, NMK_UPCP, NMK_SLBP, NMK_RADI, NMK_WTBP, NMK_HSCP, NMK_LBGP, NMK_KTPM, NMK_KTSM, NMK_KTMR, NMK_CRTP, NMK_CRTS, NMK_TRBM, NMK_RSPD } - private static final EnumMap Catnmk = new EnumMap(CatNMK.class); static { Catnmk.put(CatNMK.NMK_UNKN, new S57enum(0, "")); + private static final EnumMap Catnmk = new EnumMap<>(CatNMK.class); static { Catnmk.put(CatNMK.NMK_UNKN, new S57enum(0, "")); Catnmk.put(CatNMK.NMK_NENT, new S57enum(1, "no_entry")); Catnmk.put(CatNMK.NMK_CLSA, new S57enum(2, "closed_area")); Catnmk.put(CatNMK.NMK_NOVK, new S57enum(3, "no_overtaking")); Catnmk.put(CatNMK.NMK_NCOV, new S57enum(4, "no_convoy_overtaking")); Catnmk.put(CatNMK.NMK_NPAS, new S57enum(5, "no_passing")); Catnmk.put(CatNMK.NMK_NBRT, new S57enum(6, "no_berthing")); @@ -818,24 +817,24 @@ } public enum ClsDNG { DNG_UNKN, DNG_1BLU, DNG_2BLU, DNG_3BLU, DNG_0BLU, DNG_1RED } - private static final EnumMap Clsdng = new EnumMap(ClsDNG.class); static { Clsdng.put(ClsDNG.DNG_UNKN, new S57enum(0, "")); + private static final EnumMap Clsdng = new EnumMap<>(ClsDNG.class); static { Clsdng.put(ClsDNG.DNG_UNKN, new S57enum(0, "")); Clsdng.put(ClsDNG.DNG_1BLU, new S57enum(1, "one_blue")); Clsdng.put(ClsDNG.DNG_2BLU, new S57enum(2, "two_blue")); Clsdng.put(ClsDNG.DNG_3BLU, new S57enum(3, "three_blue")); Clsdng.put(ClsDNG.DNG_0BLU, new S57enum(4, "no_blue")); Clsdng.put(ClsDNG.DNG_1RED, new S57enum(5, "one_red")); } public enum DirIMP { IMP_UNKN, IMP_UPST, IMP_DNST, IMP_LTBK, IMP_RTBK, IMP_THBR } - private static final EnumMap Dirimp = new EnumMap(DirIMP.class); static { Dirimp.put(DirIMP.IMP_UNKN, new S57enum(0, "")); + private static final EnumMap Dirimp = new EnumMap<>(DirIMP.class); static { Dirimp.put(DirIMP.IMP_UNKN, new S57enum(0, "")); Dirimp.put(DirIMP.IMP_UPST, new S57enum(1, "upstream")); Dirimp.put(DirIMP.IMP_DNST, new S57enum(2, "downstream")); Dirimp.put(DirIMP.IMP_LTBK, new S57enum(3, "left_bank")); Dirimp.put(DirIMP.IMP_RTBK, new S57enum(4, "right_bank")); Dirimp.put(DirIMP.IMP_THBR, new S57enum(5, "to_harbour")); } public enum FncFNM { FNM_UNKN, FNM_PRHB, FNM_RGLN, FNM_RSTN, FNM_RCMD, FNM_INFO } - private static final EnumMap Fnctnm = new EnumMap(FncFNM.class); static { Fnctnm.put(FncFNM.FNM_UNKN, new S57enum(0, "")); + private static final EnumMap Fnctnm = new EnumMap<>(FncFNM.class); static { Fnctnm.put(FncFNM.FNM_UNKN, new S57enum(0, "")); Fnctnm.put(FncFNM.FNM_PRHB, new S57enum(1, "prohibition")); Fnctnm.put(FncFNM.FNM_RGLN, new S57enum(2, "regulation")); Fnctnm.put(FncFNM.FNM_RSTN, new S57enum(3, "restriction")); Fnctnm.put(FncFNM.FNM_RCMD, new S57enum(4, "recommendation")); Fnctnm.put(FncFNM.FNM_INFO, new S57enum(5, "information")); } public enum BunVES { VES_UNKN, VES_BVAV, VES_NBVA } - private static final EnumMap Bunves = new EnumMap(BunVES.class); static { Bunves.put(BunVES.VES_UNKN, new S57enum(0, "")); + private static final EnumMap Bunves = new EnumMap<>(BunVES.class); static { Bunves.put(BunVES.VES_UNKN, new S57enum(0, "")); Bunves.put(BunVES.VES_BVAV, new S57enum(1, "bunker_vessel_available")); Bunves.put(BunVES.VES_NBVA, new S57enum(2, "no_bunker_vessel_available")); } public enum CatBRT { BRT_UNKN, BRT_LODG, BRT_ULDG, BRT_OVNT, BRT_PSHN, BRT_NPSH, BRT_FLTG, BRT_FCLS, BRT_SCLS } - private static final EnumMap Catbrt = new EnumMap(CatBRT.class); static { Catbrt.put(CatBRT.BRT_UNKN, new S57enum(0, "")); + private static final EnumMap Catbrt = new EnumMap<>(CatBRT.class); static { Catbrt.put(CatBRT.BRT_UNKN, new S57enum(0, "")); Catbrt.put(CatBRT.BRT_LODG, new S57enum(1, "loading")); Catbrt.put(CatBRT.BRT_ULDG, new S57enum(2, "unloading")); Catbrt.put(CatBRT.BRT_OVNT, new S57enum(3, "overnight_accommodation")); Catbrt.put(CatBRT.BRT_PSHN, new S57enum(4, "pushing-navigation")); Catbrt.put(CatBRT.BRT_NPSH, new S57enum(5, "non-pushing-navigation")); @@ -843,9 +842,9 @@ } public enum CatBUN { BUN_UNKN, BUN_DESL, BUN_WATR, BUN_BLST } - private static final EnumMap Catbun = new EnumMap(CatBUN.class); static { Catbun.put(CatBUN.BUN_UNKN, new S57enum(0, "")); + private static final EnumMap Catbun = new EnumMap<>(CatBUN.class); static { Catbun.put(CatBUN.BUN_UNKN, new S57enum(0, "")); Catbun.put(CatBUN.BUN_DESL, new S57enum(1, "diesel")); Catbun.put(CatBUN.BUN_WATR, new S57enum(2, "water")); Catbun.put(CatBUN.BUN_BLST, new S57enum(3, "ballast")); } public enum CatCCL { CCL_UNKN, CCL_SMLV, CCL_PNCH, CCL_CMPB, CCL_DMEB, CCL_RHNB, CCL_1BPT, CCL_2PTL, CCL_2PTW, CCL_4BPT, CCL_6BPT, CCL_NCCL } - private static final EnumMap Catccl = new EnumMap(CatCCL.class); static { Catccl.put(CatCCL.CCL_UNKN, new S57enum(0, "")); + private static final EnumMap Catccl = new EnumMap<>(CatCCL.class); static { Catccl.put(CatCCL.CCL_UNKN, new S57enum(0, "")); Catccl.put(CatCCL.CCL_SMLV, new S57enum(1, "small_vessels")); Catccl.put(CatCCL.CCL_PNCH, new S57enum(2, "peniche")); Catccl.put(CatCCL.CCL_CMPB, new S57enum(3, "campine_barge")); Catccl.put(CatCCL.CCL_DMEB, new S57enum(4, "dortmund-ems_barge")); Catccl.put(CatCCL.CCL_RHNB, new S57enum(5, "rhine-herne_barge")); Catccl.put(CatCCL.CCL_1BPT, new S57enum(6, "1-barge_push-tow")); @@ -854,5 +853,5 @@ } public enum CatCOM { COM_UNKN, COM_VTSC, COM_VTSS, COM_IVSP, COM_MID, COM_LOCK, COM_BRDG, COM_CSTM, COM_HRBR } - private static final EnumMap Catcom = new EnumMap(CatCOM.class); static { Catcom.put(CatCOM.COM_UNKN, new S57enum(0, "")); + private static final EnumMap Catcom = new EnumMap<>(CatCOM.class); static { Catcom.put(CatCOM.COM_UNKN, new S57enum(0, "")); Catcom.put(CatCOM.COM_VTSC, new S57enum(1, "vts_centre")); Catcom.put(CatCOM.COM_VTSS, new S57enum(2, "vts_sector")); Catcom.put(CatCOM.COM_IVSP, new S57enum(3, "ivs_point")); Catcom.put(CatCOM.COM_MID, new S57enum(4, "mib")); Catcom.put(CatCOM.COM_LOCK, new S57enum(5, "lock")); Catcom.put(CatCOM.COM_BRDG, new S57enum(6, "bridge")); @@ -860,20 +859,20 @@ } public enum CatHBR { HBR_UNKN, HBR_CSTM, HBR_REFG, HBR_MRNA, HBR_FISH, HBR_PRIV, HBR_ } - private static final EnumMap Cathbr = new EnumMap(CatHBR.class); static { Cathbr.put(CatHBR.HBR_UNKN, new S57enum(0, "")); + private static final EnumMap Cathbr = new EnumMap<>(CatHBR.class); static { Cathbr.put(CatHBR.HBR_UNKN, new S57enum(0, "")); Cathbr.put(CatHBR.HBR_CSTM, new S57enum(1, "customs")); Cathbr.put(CatHBR.HBR_REFG, new S57enum(2, "refuge")); Cathbr.put(CatHBR.HBR_MRNA, new S57enum(3, "marina")); Cathbr.put(CatHBR.HBR_FISH, new S57enum(4, "fishing")); Cathbr.put(CatHBR.HBR_PRIV, new S57enum(5, "private")); } public enum CatRFD { RFD_UNKN, RFD_CRSD, RFD_WOIL, RFD_GBWT, RFD_DREF } - private static final EnumMap Catrfd = new EnumMap(CatRFD.class); static { Catrfd.put(CatRFD.RFD_UNKN, new S57enum(0, "")); + private static final EnumMap Catrfd = new EnumMap<>(CatRFD.class); static { Catrfd.put(CatRFD.RFD_UNKN, new S57enum(0, "")); Catrfd.put(CatRFD.RFD_CRSD, new S57enum(1, "cargo_residue")); Catrfd.put(CatRFD.RFD_WOIL, new S57enum(2, "waste_oil")); Catrfd.put(CatRFD.RFD_GBWT, new S57enum(3, "grey_black_water")); Catrfd.put(CatRFD.RFD_DREF, new S57enum(4, "domestic_refuse")); } public enum CatTML { TML_UNKN, TML_PSGR, TML_FERY, TML_TSPT, TML_RORO } - private static final EnumMap Cattml = new EnumMap(CatTML.class); static { Cattml.put(CatTML.TML_UNKN, new S57enum(0, "")); + private static final EnumMap Cattml = new EnumMap<>(CatTML.class); static { Cattml.put(CatTML.TML_UNKN, new S57enum(0, "")); Cattml.put(CatTML.TML_PSGR, new S57enum(1, "passenger")); Cattml.put(CatTML.TML_FERY, new S57enum(2, "ferry")); Cattml.put(CatTML.TML_TSPT, new S57enum(3, "transhipment")); Cattml.put(CatTML.TML_RORO, new S57enum(4, "roro")); } public enum TrsTGD { TGD_UNKN, TGD_CONT, TGD_BULK, TGD_OIL, TGD_FUEL, TGD_CHEM, TGD_LIQD, TGD_EXPL, TGD_FISH, TGD_CARS, TGD_GNRL } - private static final EnumMap Trshgd = new EnumMap(TrsTGD.class); static { Trshgd.put(TrsTGD.TGD_UNKN, new S57enum(0, "")); + private static final EnumMap Trshgd = new EnumMap<>(TrsTGD.class); static { Trshgd.put(TrsTGD.TGD_UNKN, new S57enum(0, "")); Trshgd.put(TrsTGD.TGD_CONT, new S57enum(1, "containers")); Trshgd.put(TrsTGD.TGD_BULK, new S57enum(2, "bulk")); Trshgd.put(TrsTGD.TGD_OIL, new S57enum(3, "oil")); Trshgd.put(TrsTGD.TGD_FUEL, new S57enum(4, "fuel")); Trshgd.put(TrsTGD.TGD_CHEM, new S57enum(5, "chemicals")); Trshgd.put(TrsTGD.TGD_LIQD, new S57enum(6, "liquid")); @@ -882,10 +881,10 @@ } public enum CatGAG { GAG_UNKN, GAG_STAF, GAG_RCRD, GAG_RCRA, GAG_RCEI, GAG_RRAI } - private static final EnumMap Catgag = new EnumMap(CatGAG.class); static { Catgag.put(CatGAG.GAG_UNKN, new S57enum(0, "")); + private static final EnumMap Catgag = new EnumMap<>(CatGAG.class); static { Catgag.put(CatGAG.GAG_UNKN, new S57enum(0, "")); Catgag.put(CatGAG.GAG_STAF, new S57enum(1, "staff")); Catgag.put(CatGAG.GAG_RCRD, new S57enum(2, "recording")); Catgag.put(CatGAG.GAG_RCRA, new S57enum(3, "recording_remote_access")); Catgag.put(CatGAG.GAG_RCEI, new S57enum(4, "recording_external_indicator")); Catgag.put(CatGAG.GAG_RRAI, new S57enum(5, "recording_remote_access_indicator")); } public enum RefLEV { LEV_UNKN, LEV_BALT, LEV_ADRC, LEV_AMSD, LEV_MSL, LEV_OTHR, LEV_NG29, LEV_NA88, LEV_1912, LEV_1929 } - private static final EnumMap Reflev = new EnumMap(RefLEV.class); static { Reflev.put(RefLEV.LEV_UNKN, new S57enum(0, "")); + private static final EnumMap Reflev = new EnumMap<>(RefLEV.class); static { Reflev.put(RefLEV.LEV_UNKN, new S57enum(0, "")); Reflev.put(RefLEV.LEV_BALT, new S57enum(1, "baltic")); Reflev.put(RefLEV.LEV_ADRC, new S57enum(2, "adriatic")); Reflev.put(RefLEV.LEV_AMSD, new S57enum(3, "amsterdam")); Reflev.put(RefLEV.LEV_MSL, new S57enum(4, "msl")); Reflev.put(RefLEV.LEV_OTHR, new S57enum(5, "other")); Reflev.put(RefLEV.LEV_NG29, new S57enum(6, "ngvd29")); @@ -893,18 +892,18 @@ } public enum CatVTR { VTR_UNKN, VTR_OFFL, VTR_PRIV, VTR_CARC, VTR_CARP, VTR_PREQ, VTR_LGAT } - private static final EnumMap Catvtr = new EnumMap(CatVTR.class); static { Catvtr.put(CatVTR.VTR_UNKN, new S57enum(0, "")); + private static final EnumMap Catvtr = new EnumMap<>(CatVTR.class); static { Catvtr.put(CatVTR.VTR_UNKN, new S57enum(0, "")); Catvtr.put(CatVTR.VTR_OFFL, new S57enum(1, "official")); Catvtr.put(CatVTR.VTR_PRIV, new S57enum(2, "private")); Catvtr.put(CatVTR.VTR_CARC, new S57enum(3, "car_cranes")); Catvtr.put(CatVTR.VTR_CARP, new S57enum(4, "car_planks")); Catvtr.put(CatVTR.VTR_PREQ, new S57enum(5, "permission_required")); Catvtr.put(CatVTR.VTR_LGAT, new S57enum(6, "locked_gate")); } public enum CatTAB { TAB_UNKN, TAB_OPPD, TAB_NOPP } - private static final EnumMap Cattab = new EnumMap(CatTAB.class); static { Cattab.put(CatTAB.TAB_UNKN, new S57enum(0, "")); + private static final EnumMap Cattab = new EnumMap<>(CatTAB.class); static { Cattab.put(CatTAB.TAB_UNKN, new S57enum(0, "")); Cattab.put(CatTAB.TAB_OPPD, new S57enum(1, "operational_period")); Cattab.put(CatTAB.TAB_NOPP, new S57enum(2, "non-operational_period")); } public enum UseSHP { SHP_UNKN, SHP_LINT, SHP_OCSH, SHP_LESR } - private static final EnumMap Useshp = new EnumMap(UseSHP.class); static { Useshp.put(UseSHP.SHP_UNKN, new S57enum(0, "")); + private static final EnumMap Useshp = new EnumMap<>(UseSHP.class); static { Useshp.put(UseSHP.SHP_UNKN, new S57enum(0, "")); Useshp.put(UseSHP.SHP_LINT, new S57enum(1, "liner_trade")); Useshp.put(UseSHP.SHP_OCSH, new S57enum(2, "occasional_professional_shipping")); Useshp.put(UseSHP.SHP_LESR, new S57enum(3, "leisure")); } public enum CatEXS { EXS_UNKN, EXS_LLOK, EXS_AQDT, EXS_SPLK, EXS_WSLK, EXS_OTHR } - private static final EnumMap Catexs = new EnumMap(CatEXS.class); static { Catexs.put(CatEXS.EXS_UNKN, new S57enum(0, "")); + private static final EnumMap Catexs = new EnumMap<>(CatEXS.class); static { Catexs.put(CatEXS.EXS_UNKN, new S57enum(0, "")); Catexs.put(CatEXS.EXS_LLOK, new S57enum(1, "lift-lock")); Catexs.put(CatEXS.EXS_AQDT, new S57enum(2, "aqueduct")); Catexs.put(CatEXS.EXS_SPLK, new S57enum(3, "sloping_plane_lock")); Catexs.put(CatEXS.EXS_WSLK, new S57enum(4, "water_slope_lock")); Catexs.put(CatEXS.EXS_OTHR, new S57enum(5, "other")); @@ -912,5 +911,5 @@ public enum CatWWM { WWM_UNKN, WWM_WWRT, WWM_WWLT, WWM_WWSP, WWM_CHRT, WWM_CHLT, WWM_CHSP, WWM_CHRB, WWM_CHLB, WWM_CORT, WWM_COLT, WWM_DGRT, WWM_DGLT, WWM_TORT, WWM_TOLT, WWM_JNRT, WWM_JNLT, WWM_HBRT, WWM_HBLT, WWM_BRPR } - private static final EnumMap Catwwm = new EnumMap(CatWWM.class); static { Catwwm.put(CatWWM.WWM_UNKN, new S57enum(0, "")); + private static final EnumMap Catwwm = new EnumMap<>(CatWWM.class); static { Catwwm.put(CatWWM.WWM_UNKN, new S57enum(0, "")); Catwwm.put(CatWWM.WWM_WWRT, new S57enum(1, "waterway_right")); Catwwm.put(CatWWM.WWM_WWLT, new S57enum(2, "waterway_left")); Catwwm.put(CatWWM.WWM_WWSP, new S57enum(3, "waterway_separation")); Catwwm.put(CatWWM.WWM_CHRT, new S57enum(4, "channel_right")); Catwwm.put(CatWWM.WWM_CHLT, new S57enum(5, "channel_left")); Catwwm.put(CatWWM.WWM_CHSP, new S57enum(6, "channel_separation")); @@ -922,18 +921,18 @@ } public enum Lg_SPR { SPR_UNKN, SPR_OTHR, SPR_SPOG, SPR_SPTW } - private static final EnumMap Lg_spr = new EnumMap(Lg_SPR.class); static { Lg_spr.put(Lg_SPR.SPR_UNKN, new S57enum(0, "")); + private static final EnumMap Lg_spr = new EnumMap<>(Lg_SPR.class); static { Lg_spr.put(Lg_SPR.SPR_UNKN, new S57enum(0, "")); Lg_spr.put(Lg_SPR.SPR_OTHR, new S57enum(1, "other")); Lg_spr.put(Lg_SPR.SPR_SPOG, new S57enum(2, "speed_over_ground")); Lg_spr.put(Lg_SPR.SPR_SPTW, new S57enum(3, "speed_through_water")); } public enum Lg_WDU { WDU_UNKN, WDU_OTHR, WDU_CUMT, WDU_TONS } - private static final EnumMap Lg_wdu = new EnumMap(Lg_WDU.class); static { Lg_wdu.put(Lg_WDU.WDU_UNKN, new S57enum(0, "")); + private static final EnumMap Lg_wdu = new EnumMap<>(Lg_WDU.class); static { Lg_wdu.put(Lg_WDU.WDU_UNKN, new S57enum(0, "")); Lg_wdu.put(Lg_WDU.WDU_OTHR, new S57enum(1, "other")); Lg_wdu.put(Lg_WDU.WDU_CUMT, new S57enum(2, "cubic_metres")); Lg_wdu.put(Lg_WDU.WDU_TONS, new S57enum(3, "tonnes")); } public enum Lg_REL { REL_UNKN, REL_OTHR, REL_USWW, REL_CREQ, REL_TKOP } - private static final EnumMap Lg_rel = new EnumMap(Lg_REL.class); static { Lg_rel.put(Lg_REL.REL_UNKN, new S57enum(0, "")); + private static final EnumMap Lg_rel = new EnumMap<>(Lg_REL.class); static { Lg_rel.put(Lg_REL.REL_UNKN, new S57enum(0, "")); Lg_rel.put(Lg_REL.REL_OTHR, new S57enum(1, "other")); Lg_rel.put(Lg_REL.REL_USWW, new S57enum(2, "usage_of_waterway")); Lg_rel.put(Lg_REL.REL_CREQ, new S57enum(3, "carriage_of_equipment")); Lg_rel.put(Lg_REL.REL_TKOP, new S57enum(4, "task_operation")); } public enum Lg_FNC { FNC_UNKN, FNC_OTHR, FNC_PRHB, FNC_PRHE, FNC_PERM, FNC_PERE, FNC_RCMD, FNC_NRCD } - private static final EnumMap Lg_fnc = new EnumMap(Lg_FNC.class); static { Lg_fnc.put(Lg_FNC.FNC_UNKN, new S57enum(0, "")); + private static final EnumMap Lg_fnc = new EnumMap<>(Lg_FNC.class); static { Lg_fnc.put(Lg_FNC.FNC_UNKN, new S57enum(0, "")); Lg_fnc.put(Lg_FNC.FNC_OTHR, new S57enum(1, "other")); Lg_fnc.put(Lg_FNC.FNC_PRHB, new S57enum(2, "prohibited")); Lg_fnc.put(Lg_FNC.FNC_PRHE, new S57enum(3, "prohibited_with_exceptions")); Lg_fnc.put(Lg_FNC.FNC_PERM, new S57enum(4, "permitted")); Lg_fnc.put(Lg_FNC.FNC_PERE, new S57enum(5, "permitted_with_exceptions")); Lg_fnc.put(Lg_FNC.FNC_RCMD, new S57enum(6, "recommended")); @@ -942,5 +941,5 @@ public enum Lc_CSX { CSX_UNKN, CSX_ALL, CSX_OTHR, CSX_NMOT, CSX_CRFT, CSX_VSSL, CSX_ILWW, CSX_SEAG, CSX_MOTR, CSX_MTNK, CSX_MCGO, CSX_CBRG, CSX_TUG, CSX_PSHR, CSX_BARG, CSX_TNKB, CSX_DMBB, CSX_LGTR, CSX_TNKL, CSX_CGOL, CSX_SBLR, CSX_PSGR, CSX_PSGS, CSX_DAYT, CSX_CABN, CSX_HSPD, CSX_FLEQ, CSX_WSIT, CSX_RCNL, CSX_DNGY, CSX_FEST, CSX_FOBJ } - private static final EnumMap Lc_csi = new EnumMap(Lc_CSX.class); static { Lc_csi.put(Lc_CSX.CSX_UNKN, new S57enum(0, "")); + private static final EnumMap Lc_csi = new EnumMap<>(Lc_CSX.class); static { Lc_csi.put(Lc_CSX.CSX_UNKN, new S57enum(0, "")); Lc_csi.put(Lc_CSX.CSX_ALL, new S57enum(1, "all")); Lc_csi.put(Lc_CSX.CSX_OTHR, new S57enum(2, "other")); Lc_csi.put(Lc_CSX.CSX_NMOT, new S57enum(3, "non-motorized")); Lc_csi.put(Lc_CSX.CSX_CRFT, new S57enum(5, "craft")); Lc_csi.put(Lc_CSX.CSX_VSSL, new S57enum(6, "vessel")); Lc_csi.put(Lc_CSX.CSX_ILWW, new S57enum(7, "inland_waterway")); @@ -955,5 +954,5 @@ Lc_csi.put(Lc_CSX.CSX_FOBJ, new S57enum(32, "floating_object")); } - private static final EnumMap Lc_cse = new EnumMap(Lc_CSX.class); static { Lc_cse.put(Lc_CSX.CSX_UNKN, new S57enum(0, "")); + private static final EnumMap Lc_cse = new EnumMap<>(Lc_CSX.class); static { Lc_cse.put(Lc_CSX.CSX_UNKN, new S57enum(0, "")); Lc_cse.put(Lc_CSX.CSX_ALL, new S57enum(1, "all")); Lc_cse.put(Lc_CSX.CSX_OTHR, new S57enum(2, "other")); Lc_cse.put(Lc_CSX.CSX_NMOT, new S57enum(3, "non-motorized")); Lc_cse.put(Lc_CSX.CSX_CRFT, new S57enum(5, "craft")); Lc_cse.put(Lc_CSX.CSX_VSSL, new S57enum(6, "vessel")); Lc_cse.put(Lc_CSX.CSX_ILWW, new S57enum(7, "inland_waterway")); @@ -969,10 +968,10 @@ } public enum Lc_ASX { ASX_UNKN, ASX_ALL, ASX_OTHR, ASX_SNGL, ASX_CONV, ASX_FMTN, ASX_RCNV, ASX_PCNV, ASX_BSTD, ASX_TCNV } - private static final EnumMap Lc_asi = new EnumMap(Lc_ASX.class); static { Lc_asi.put(Lc_ASX.ASX_UNKN, new S57enum(0, "")); + private static final EnumMap Lc_asi = new EnumMap<>(Lc_ASX.class); static { Lc_asi.put(Lc_ASX.ASX_UNKN, new S57enum(0, "")); Lc_asi.put(Lc_ASX.ASX_ALL, new S57enum(1, "all")); Lc_asi.put(Lc_ASX.ASX_OTHR, new S57enum(2, "other")); Lc_asi.put(Lc_ASX.ASX_SNGL, new S57enum(3, "single")); Lc_asi.put(Lc_ASX.ASX_CONV, new S57enum(5, "convoy")); Lc_asi.put(Lc_ASX.ASX_FMTN, new S57enum(6, "formation")); Lc_asi.put(Lc_ASX.ASX_RCNV, new S57enum(7, "rigid_convoy")); Lc_asi.put(Lc_ASX.ASX_PCNV, new S57enum(8, "pushed_convoy")); Lc_asi.put(Lc_ASX.ASX_BSTD, new S57enum(9, "breasted")); Lc_asi.put(Lc_ASX.ASX_TCNV, new S57enum(10, "towed_convoy")); } - private static final EnumMap Lc_ase = new EnumMap(Lc_ASX.class); static { Lc_ase.put(Lc_ASX.ASX_UNKN, new S57enum(0, "")); + private static final EnumMap Lc_ase = new EnumMap<>(Lc_ASX.class); static { Lc_ase.put(Lc_ASX.ASX_UNKN, new S57enum(0, "")); Lc_ase.put(Lc_ASX.ASX_ALL, new S57enum(1, "all")); Lc_ase.put(Lc_ASX.ASX_OTHR, new S57enum(2, "other")); Lc_ase.put(Lc_ASX.ASX_SNGL, new S57enum(3, "single")); Lc_ase.put(Lc_ASX.ASX_CONV, new S57enum(5, "convoy")); Lc_ase.put(Lc_ASX.ASX_FMTN, new S57enum(6, "formation")); Lc_ase.put(Lc_ASX.ASX_RCNV, new S57enum(7, "rigid_convoy")); @@ -980,10 +979,10 @@ } public enum Lc_CCX { CCX_UNKN, CCX_ALL, CCX_OTHR, CCX_BULK, CCX_DRY, CCX_LIQD, CCX_LQDN, CCX_LQDC, CCX_GAS } - private static final EnumMap Lc_cci = new EnumMap(Lc_CCX.class); static { Lc_cci.put(Lc_CCX.CCX_UNKN, new S57enum(0, "")); + private static final EnumMap Lc_cci = new EnumMap<>(Lc_CCX.class); static { Lc_cci.put(Lc_CCX.CCX_UNKN, new S57enum(0, "")); Lc_cci.put(Lc_CCX.CCX_ALL, new S57enum(1, "all")); Lc_cci.put(Lc_CCX.CCX_OTHR, new S57enum(2, "other")); Lc_cci.put(Lc_CCX.CCX_BULK, new S57enum(4, "bulk")); Lc_cci.put(Lc_CCX.CCX_DRY, new S57enum(5, "dry")); Lc_cci.put(Lc_CCX.CCX_LIQD, new S57enum(6, "liquid")); Lc_cci.put(Lc_CCX.CCX_LQDN, new S57enum(7, "liquid_n")); Lc_cci.put(Lc_CCX.CCX_LQDC, new S57enum(8, "liquid_c")); Lc_cci.put(Lc_CCX.CCX_GAS, new S57enum(9, "gas")); } - private static final EnumMap Lc_cce = new EnumMap(Lc_CCX.class); static { Lc_cce.put(Lc_CCX.CCX_UNKN, new S57enum(0, "")); + private static final EnumMap Lc_cce = new EnumMap<>(Lc_CCX.class); static { Lc_cce.put(Lc_CCX.CCX_UNKN, new S57enum(0, "")); Lc_cce.put(Lc_CCX.CCX_ALL, new S57enum(1, "all")); Lc_cce.put(Lc_CCX.CCX_OTHR, new S57enum(2, "other")); Lc_cce.put(Lc_CCX.CCX_BULK, new S57enum(4, "bulk")); Lc_cce.put(Lc_CCX.CCX_DRY, new S57enum(5, "dry")); Lc_cce.put(Lc_CCX.CCX_LIQD, new S57enum(6, "liquid")); Lc_cce.put(Lc_CCX.CCX_LQDN, new S57enum(7, "liquid_n")); @@ -992,5 +991,5 @@ public enum ShpTYP { TYP_UNKN, TYP_CRGO, TYP_CONT, TYP_TNKR, TYP_SAIL, TYP_FISH, TYP_SPPS, TYP_MOWR, TYP_SUBM, TYP_HSPD, TYP_BCAR, TYP_SPLN, TYP_TUGB, TYP_PSGR, TYP_FERY, TYP_BOAT } - private static final EnumMap Shptyp = new EnumMap(ShpTYP.class); static { Shptyp.put(ShpTYP.TYP_UNKN, new S57enum(0, "")); + private static final EnumMap Shptyp = new EnumMap<>(ShpTYP.class); static { Shptyp.put(ShpTYP.TYP_UNKN, new S57enum(0, "")); Shptyp.put(ShpTYP.TYP_CRGO, new S57enum(1, "cargo")); Shptyp.put(ShpTYP.TYP_CONT, new S57enum(2, "container")); Shptyp.put(ShpTYP.TYP_TNKR, new S57enum(3, "tanker")); Shptyp.put(ShpTYP.TYP_SAIL, new S57enum(4, "sailing")); Shptyp.put(ShpTYP.TYP_FISH, new S57enum(5, "fishing")); Shptyp.put(ShpTYP.TYP_SPPS, new S57enum(6, "special_purpose.")); @@ -1001,5 +1000,5 @@ public enum CatCVR { CVR_UNKN, CVR_COVR, CVR_NCVR } - private static final EnumMap Catcvr = new EnumMap(CatCVR.class); static { Catcvr.put(CatCVR.CVR_UNKN, new S57enum(0, "")); + private static final EnumMap Catcvr = new EnumMap<>(CatCVR.class); static { Catcvr.put(CatCVR.CVR_UNKN, new S57enum(0, "")); Catcvr.put(CatCVR.CVR_COVR, new S57enum(1, "coverage")); Catcvr.put(CatCVR.CVR_NCVR, new S57enum(2, "no_coverage")); } @@ -1086,14 +1085,14 @@ keys.put(Att.CATRFD, new S57key(Conv.L, Catrfd)); keys.put(Att.CATTML, new S57key(Conv.L, Cattml)); keys.put(Att.CATGAG, new S57key(Conv.L, Catgag)); keys.put(Att.CATVTR, new S57key(Conv.L, Catvtr)); keys.put(Att.CATTAB, new S57key(Conv.E, Cattab)); keys.put(Att.CATEXS, new S57key(Conv.E, Catexs)); - keys.put(Att.CATWWM, new S57key(Conv.E, Catwwm)); keys.put(Att.LG_SPD, new S57key(Conv.F, null)); keys.put(Att.LG_SPR, new S57key(Conv.L, Lg_spr)); - keys.put(Att.LG_BME, new S57key(Conv.F, null)); keys.put(Att.LG_LGS, new S57key(Conv.F, null)); keys.put(Att.LG_DRT, new S57key(Conv.F, null)); - keys.put(Att.LG_WDP, new S57key(Conv.F, null)); keys.put(Att.LG_WDU, new S57key(Conv.E, Lg_wdu)); keys.put(Att.LG_REL, new S57key(Conv.L, Lg_rel)); - keys.put(Att.LG_FNC, new S57key(Conv.L, Lg_fnc)); keys.put(Att.LG_DES, new S57key(Conv.S, null)); keys.put(Att.LG_PBR, new S57key(Conv.S, null)); - keys.put(Att.LC_CSI, new S57key(Conv.L, Lc_csi)); keys.put(Att.LC_CSE, new S57key(Conv.L, Lc_cse)); keys.put(Att.LC_ASI, new S57key(Conv.L, Lc_asi)); - keys.put(Att.LC_ASE, new S57key(Conv.L, Lc_ase)); keys.put(Att.LC_CCI, new S57key(Conv.L, Lc_cci)); keys.put(Att.LC_CCE, new S57key(Conv.L, Lc_cce)); - keys.put(Att.LC_BM1, new S57key(Conv.F, null)); keys.put(Att.LC_BM2, new S57key(Conv.F, null)); keys.put(Att.LC_LG1, new S57key(Conv.F, null)); - keys.put(Att.LC_LG2, new S57key(Conv.F, null)); keys.put(Att.LC_DR1, new S57key(Conv.F, null)); keys.put(Att.LC_DR2, new S57key(Conv.F, null)); - keys.put(Att.LC_SP1, new S57key(Conv.F, null)); keys.put(Att.LC_SP2, new S57key(Conv.F, null)); keys.put(Att.LC_WD1, new S57key(Conv.F, null)); - keys.put(Att.LC_WD2, new S57key(Conv.F, null)); keys.put(Att.LITRAD, new S57key(Conv.A, null)); keys.put(Att.CATCVR, new S57key(Conv.E, Catcvr)); + keys.put(Att.LG_SPD, new S57key(Conv.F, null)); keys.put(Att.LG_SPR, new S57key(Conv.L, Lg_spr)); keys.put(Att.LG_BME, new S57key(Conv.F, null)); + keys.put(Att.LG_LGS, new S57key(Conv.F, null)); keys.put(Att.LG_DRT, new S57key(Conv.F, null)); keys.put(Att.LG_WDP, new S57key(Conv.F, null)); + keys.put(Att.LG_WDU, new S57key(Conv.E, Lg_wdu)); keys.put(Att.LG_REL, new S57key(Conv.L, Lg_rel)); keys.put(Att.LG_FNC, new S57key(Conv.L, Lg_fnc)); + keys.put(Att.LG_DES, new S57key(Conv.S, null)); keys.put(Att.LG_PBR, new S57key(Conv.S, null)); keys.put(Att.LC_CSI, new S57key(Conv.L, Lc_csi)); + keys.put(Att.LC_CSE, new S57key(Conv.L, Lc_cse)); keys.put(Att.LC_ASI, new S57key(Conv.L, Lc_asi)); keys.put(Att.LC_ASE, new S57key(Conv.L, Lc_ase)); + keys.put(Att.LC_CCI, new S57key(Conv.L, Lc_cci)); keys.put(Att.LC_CCE, new S57key(Conv.L, Lc_cce)); keys.put(Att.LC_BM1, new S57key(Conv.F, null)); + keys.put(Att.LC_BM2, new S57key(Conv.F, null)); keys.put(Att.LC_LG1, new S57key(Conv.F, null)); keys.put(Att.LC_LG2, new S57key(Conv.F, null)); + keys.put(Att.LC_DR1, new S57key(Conv.F, null)); keys.put(Att.LC_DR2, new S57key(Conv.F, null)); keys.put(Att.LC_SP1, new S57key(Conv.F, null)); + keys.put(Att.LC_SP2, new S57key(Conv.F, null)); keys.put(Att.LC_WD1, new S57key(Conv.F, null)); keys.put(Att.LC_WD2, new S57key(Conv.F, null)); + keys.put(Att.LITRAD, new S57key(Conv.A, null)); keys.put(Att.CATCVR, new S57key(Conv.E, Catcvr)); } Index: /applications/editors/josm/plugins/seachart/src/seachart/SeachartAction.java =================================================================== --- /applications/editors/josm/plugins/seachart/src/seachart/SeachartAction.java (revision 31845) +++ /applications/editors/josm/plugins/seachart/src/seachart/SeachartAction.java (revision 31846) @@ -29,4 +29,5 @@ import s57.S57map; +import s57.S57map.*; public class SeachartAction extends JosmAction implements EditLayerChangeListener, LayerChangeListener {