source: osm/applications/editors/josm/plugins/smed2/src/S57/S57val.java@ 28705

Last change on this file since 28705 was 28705, checked in by malcolmh, 13 years ago

save
File size: 101.6 KB
Line 
1package S57;
2
3import java.util.ArrayList;
4import java.util.EnumMap;
5
6import S57.S57att.*;
7
8public class S57val {
9
10 static class S57enum {
11 Integer atvl;
12 String val;
13 S57enum(Integer a, String v) {
14 atvl = a; val = v;
15 }
16 }
17
18 private enum Conv { S, A, L, E, F, I }
19
20 static class S57key {
21 Conv conv;
22 EnumMap map;
23 S57key(Conv c, EnumMap m) {
24 conv = c; map = m;
25 }
26 }
27
28 public static class AttVal {
29 Att att;
30 Conv conv;
31 Object val;
32 AttVal(Att a, Conv c, Object v) {
33 att = a; conv = c; val = v;
34 }
35 }
36
37 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 }
38 private static final EnumMap<BcnSHP, S57enum> Bcnshp = new EnumMap<BcnSHP, S57enum>(BcnSHP.class); static { Bcnshp.put(BcnSHP.BCN_UNKN, new S57enum(0, ""));
39 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"));
40 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"));
41 Bcnshp.put(BcnSHP.BCN_BUOY, new S57enum(7, "buoyant")); Bcnshp.put(BcnSHP.BCN_POLE, new S57enum(1, "pole")); Bcnshp.put(BcnSHP.BCN_PRCH, new S57enum(1, "perch"));
42 Bcnshp.put(BcnSHP.BCN_POST, new S57enum(1, "post"));
43 }
44 public enum BuiSHP { BUI_UNKN, BUI_HIRS, BUI_PYRD, BUI_CYLR, BUI_SPHR, BUI_CUBE }
45 private static final EnumMap<BuiSHP, S57enum> Buishp = new EnumMap<BuiSHP, S57enum>(BuiSHP.class); static { Buishp.put(BuiSHP.BUI_UNKN, new S57enum(0, ""));
46 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"));
47 Buishp.put(BuiSHP.BUI_SPHR, new S57enum(8, "spherical")); Buishp.put(BuiSHP.BUI_CUBE, new S57enum(9, "cubic"));
48 }
49 public enum BoySHP { BOY_UNKN, BOY_CONE, BOY_CAN, BOY_SPHR, BOY_PILR, BOY_SPAR, BOY_BARL, BOY_SUPR, BOY_ICE }
50 private static final EnumMap<BoySHP, S57enum> Boyshp = new EnumMap<BoySHP, S57enum>(BoySHP.class); static { Boyshp.put(BoySHP.BOY_UNKN, new S57enum(0, ""));
51 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"));
52 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"));
53 Boyshp.put(BoySHP.BOY_SUPR, new S57enum(7, "super-buoy")); Boyshp.put(BoySHP.BOY_ICE, new S57enum(8, "ice_buoy"));
54 }
55 public enum CatAIR { AIR_UNKN, AIR_MILA, AIR_CIVA, AIR_MILH, AIR_CIVH, AIR_GLDR, AIR_SMLP, AIR_EMRG }
56 private static final EnumMap<CatAIR, S57enum> Catair = new EnumMap<CatAIR, S57enum>(CatAIR.class); static { Catair.put(CatAIR.AIR_UNKN, new S57enum(0, ""));
57 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"));
58 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"));
59 Catair.put(CatAIR.AIR_EMRG, new S57enum(8, "emergency"));
60 }
61 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 }
62 private static final EnumMap<CatACH, S57enum> Catach = new EnumMap<CatACH, S57enum>(CatACH.class); static {Catach.put(CatACH.ACH_UNKN, new S57enum(0, ""));
63 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"));
64 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, "sea-plane"));
65 Catach.put(CatACH.ACH_SMCF, new S57enum(7, "small_craft")); Catach.put(CatACH.ACH_SMCM, new S57enum(8, "small_craft_mooring")); Catach.put(CatACH.ACH_H24P, new S57enum(9, "24_hour"));
66 Catach.put(CatACH.ACH_LTPD, new S57enum(10, "limited_period")); Catach.put(CatACH.ACH_NPSH, new S57enum(11, "non_pushing")); Catach.put(CatACH.ACH_DRYC, new S57enum(12, "dry_cargo"));
67 Catach.put(CatACH.ACH_RAFT, new S57enum(13, "raft"));
68 }
69 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 }
70 private static final EnumMap<CatBRG, S57enum> Catbrg = new EnumMap<CatBRG, S57enum>(CatBRG.class); static {Catbrg.put(CatBRG.BRG_UNKN, new S57enum(0, ""));
71 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"));
72 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"));
73 Catbrg.put(CatBRG.BRG_DRAW, new S57enum(7, "draw")); Catbrg.put(CatBRG.BRG_TRNS, new S57enum(8, "transporter")); Catbrg.put(CatBRG.BRG_FOOT, new S57enum(9, "footbridge"));
74 Catbrg.put(CatBRG.BRG_VIAD, new S57enum(10, "viaduct")); Catbrg.put(CatBRG.BRG_AQUA, new S57enum(11, "aqueduct")); Catbrg.put(CatBRG.BRG_SUSP, new S57enum(12, "suspension"));
75 }
76 public enum CatBUA { BUA_UNKN, BUA_URBN, BUA_STTL, BUA_VLLG, BUA_TOWN, BUA_CITY, BUA_HOLV }
77 private static final EnumMap<CatBUA, S57enum> Catbua = new EnumMap<CatBUA, S57enum>(CatBUA.class); static { Catbua.put(CatBUA.BUA_UNKN, new S57enum(0, ""));
78 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"));
79 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"));
80 }
81 public enum CatCBL { CBL_UNKN, CBL_POWR, CBL_TRNS, CBL_TELE, CBL_TGPH, CBL_MOOR, CBL_OPTC, CBL_FERY }
82 private static final EnumMap<CatCBL, S57enum> Catcbl = new EnumMap<CatCBL, S57enum>(CatCBL.class); static {Catcbl.put(CatCBL.CBL_UNKN, new S57enum(0, ""));
83 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"));
84 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"));
85 Catcbl.put(CatCBL.CBL_FERY, new S57enum(8, "ferry"));
86 }
87 public enum CatCAN { CAN_UNKN, CAN_TRNS, CAN_DRNG, CAN_IRGN }
88 private static final EnumMap<CatCAN, S57enum> Catcan = new EnumMap<CatCAN, S57enum>(CatCAN.class); static { Catcan.put(CatCAN.CAN_UNKN, new S57enum(0, ""));
89 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"));
90 }
91 public enum CatCAM { CAM_UNKN, CAM_NORTH, CAM_EAST, CAM_SOUTH, CAM_WEST }
92 private static final EnumMap<CatCAM, S57enum> Catcam = new EnumMap<CatCAM, S57enum>(CatCAM.class); static { Catcam.put(CatCAM.CAM_UNKN, new S57enum(0, ""));
93 Catcam.put(CatCAM.CAM_NORTH, new S57enum(1, "north")); Catcam.put(CatCAM.CAM_EAST, new S57enum(2, "east"));
94 Catcam.put(CatCAM.CAM_SOUTH, new S57enum(3, "south")); Catcam.put(CatCAM.CAM_WEST, new S57enum(4, "west"));
95 }
96 public enum CatCHP { CHP_UNKN, CHP_CSTM, CHP_BRDR }
97 private static final EnumMap<CatCHP, S57enum> Catchp = new EnumMap<CatCHP, S57enum>(CatCHP.class); static { Catchp.put(CatCHP.CHP_UNKN, new S57enum(0, ""));
98 Catchp.put(CatCHP.CHP_CSTM, new S57enum(1, "custom")); Catchp.put(CatCHP.CHP_BRDR, new S57enum(2, "border"));
99 }
100 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 }
101 private static final EnumMap<CatCOA, S57enum> Catcoa = new EnumMap<CatCOA, S57enum>(CatCOA.class); static { Catcoa.put(CatCOA.COA_UNKN, new S57enum(0, ""));
102 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"));
103 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"));
104 Catcoa.put(CatCOA.COA_MNGV, new S57enum(7, "mangrove")); Catcoa.put(CatCOA.COA_MRSH, new S57enum(8, "marshy")); Catcoa.put(CatCOA.COA_CRRF, new S57enum(9, "coral_reef"));
105 Catcoa.put(CatCOA.COA_ICE, new S57enum(10, "ice")); Catcoa.put(CatCOA.COA_SHEL, new S57enum(11, "shelly"));
106 }
107 public enum CatCTR { CTR_UNKN, CTR_TRGN, CTR_OBSV, CTR_FIXD, CTR_BMRK, CTR_BDRY, CTR_HORM, CTR_HORS }
108 private static final EnumMap<CatCTR, S57enum> Catctr = new EnumMap<CatCTR, S57enum>(CatCTR.class); static { Catctr.put(CatCTR.CTR_UNKN, new S57enum(0, ""));
109 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"));
110 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"));
111 Catctr.put(CatCTR.CTR_HORS, new S57enum(7, "horizontal_secondary"));
112 }
113 public enum CatCON { CON_UNKN, CAT_AERL, CAT_BELT }
114 private static final EnumMap<CatCON, S57enum> Catcon = new EnumMap<CatCON, S57enum>(CatCON.class); static { Catcon.put(CatCON.CON_UNKN, new S57enum(0, ""));
115 Catcon.put(CatCON.CAT_AERL, new S57enum(1, "aerial")); Catcon.put(CatCON.CAT_BELT, new S57enum(2, "belt"));
116 }
117 public enum CatCOV { COV_UNKN, COV_COVG, COV_NCOV }
118 private static final EnumMap<CatCOV, S57enum> Catcov = new EnumMap<CatCOV, S57enum>(CatCOV.class); static { Catcov.put(CatCOV.COV_UNKN, new S57enum(0, ""));
119 Catcov.put(CatCOV.COV_COVG, new S57enum(1, "coverage")); Catcov.put(CatCOV.COV_NCOV, new S57enum(2, "no_coverage"));
120 }
121 public enum CatCRN { CRN_UNKN, CRN_NONS, CRN_CONT, CRN_SHRL, CRN_TRAV, CRN_AFRM }
122 private static final EnumMap<CatCRN, S57enum> Catcrn = new EnumMap<CatCRN, S57enum>(CatCRN.class); static { Catcrn.put(CatCRN.CRN_UNKN, new S57enum(0, ""));
123 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"));
124 Catcrn.put(CatCRN.CRN_TRAV, new S57enum(4, "travelling")); Catcrn.put(CatCRN.CRN_AFRM , new S57enum(5, "a-frame"));
125 }
126 public enum CatDAM { DAM_UNKN, DAM_WEIR, DAM_DAM, DAM_FLDB }
127 private static final EnumMap<CatDAM, S57enum> Catdam = new EnumMap<CatDAM, S57enum>(CatDAM.class); static { Catdam.put(CatDAM.DAM_UNKN, new S57enum(0, ""));
128 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"));
129 }
130 public enum CatDIS { DIS_UNKN, DIS_NONI, DIS_POLE, DIS_BORD, DIS_UKSH }
131 private static final EnumMap<CatDIS, S57enum> Catdis = new EnumMap<CatDIS, S57enum>(CatDIS.class); static { Catdis.put(CatDIS.DIS_UNKN, new S57enum(0, ""));
132 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"));
133 Catdis.put(CatDIS.DIS_UKSH, new S57enum(4, "unknown_shape"));
134 }
135 public enum CatDOC { DOC_UNKN, DOC_TIDL, DOC_NTDL }
136 private static final EnumMap<CatDOC, S57enum> Catdoc = new EnumMap<CatDOC, S57enum>(CatDOC.class); static { Catdoc.put(CatDOC.DOC_UNKN, new S57enum(0, ""));
137 Catdoc.put(CatDOC.DOC_TIDL, new S57enum(1, "tidal")); Catdoc.put(CatDOC.DOC_NTDL, new S57enum(2, "non-tidal"));
138 }
139 public enum CatDPG { DPG_UNKN, DPG_GENL, DPG_CHEM, DPG_NCLR, DPG_EXPL, DPG_SPIL, DPG_VSSL }
140 private static final EnumMap<CatDPG, S57enum> Catdpg = new EnumMap<CatDPG, S57enum>(CatDPG.class); static { Catdpg.put(CatDPG.DPG_UNKN, new S57enum(0, ""));
141 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"));
142 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"));
143 }
144 public enum CatFNC { FNC_UNKN, FNC_FENC, FNC_MUIR, FNC_HEDG, FNC_WALL }
145 private static final EnumMap<CatFNC, S57enum> Catfnc = new EnumMap<CatFNC, S57enum>(CatFNC.class); static { Catfnc.put(CatFNC.FNC_UNKN, new S57enum(0, ""));
146 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"));
147 Catfnc.put(CatFNC.FNC_WALL, new S57enum(4, "wall"));
148 }
149 public enum CatFRY { FRY_UNKN, FRY_FREE, FRY_CABL, FRY_ICE, FRY_SWWR }
150 private static final EnumMap<CatFRY, S57enum> Catfry = new EnumMap<CatFRY, S57enum>(CatFRY.class); static { Catfry.put(CatFRY.FRY_UNKN, new S57enum(0, ""));
151 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"));
152 Catfry.put(CatFRY.FRY_SWWR, new S57enum(4, "swinging_wire_ferry"));
153 }
154 public enum CatFIF { FIF_UNKN, FIF_STAK, FIF_TRAP, FIF_WEIR, FIF_TUNY }
155 private static final EnumMap<CatFIF, S57enum> Catfif = new EnumMap<CatFIF, S57enum>(CatFIF.class); static { Catfif.put(CatFIF.FIF_UNKN, new S57enum(0, ""));
156 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"));
157 Catfif.put(CatFIF.FIF_TUNY, new S57enum(4, "tunny"));
158 }
159 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 }
160 private static final EnumMap<CatFOG, S57enum> Catfog = new EnumMap<CatFOG, S57enum>(CatFOG.class); static {Catfog.put(CatFOG.FOG_UNKN, new S57enum(0, ""));
161 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"));
162 Catfog.put(CatFOG.FOG_NAUT, new S57enum(4, "nautophone")); Catfog.put(CatFOG.FOG_REED, new S57enum(5, "reed"));
163 Catfog.put(CatFOG.FOG_TYPH, new S57enum(6, "tyfon")); Catfog.put(CatFOG.FOG_BELL, new S57enum(7, "bell")); Catfog.put(CatFOG.FOG_WHIS, new S57enum(8, "whistle"));
164 Catfog.put(CatFOG.FOG_GONG, new S57enum(9, "gong")); Catfog.put(CatFOG.FOG_HORN, new S57enum(10, "horn"));
165 }
166 public enum CatFOR { FOR_UNKN, FOR_CSTL, FOR_FORT, FOR_BTTY, FOR_BKHS, FOR_MTWR, FOR_RDBT }
167 private static final EnumMap<CatFOR, S57enum> Catfor = new EnumMap<CatFOR, S57enum>(CatFOR.class); static { Catfor.put(CatFOR.FOR_UNKN, new S57enum(0, ""));
168 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"));
169 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"));
170 }
171 public enum CatGAT { GAT_UNKN, GAT_GNRL, GAT_FLBG, GAT_CSSN, GAT_LOCK, GAT_DYKE, GAT_SLUC }
172 private static final EnumMap<CatGAT, S57enum> Catgat = new EnumMap<CatGAT, S57enum>(CatGAT.class); static { Catgat.put(CatGAT.GAT_UNKN, new S57enum(0, ""));
173 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"));
174 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"));
175 }
176 public enum CatHAF { HAF_UNKN, HAF_RORO, HAF_TMBR, HAF_FERY, HAF_FISH, HAF_YCHT, HAF_NAVL, HAF_TNKR, HAF_PSGR, HAF_YARD, HAF_CNTR, HAF_BULK, HAF_SYNC, HAF_STCR, HAF_MRNA, HAF_REPR, HAF_QUAR }
177 private static final EnumMap<CatHAF, S57enum> Cathaf = new EnumMap<CatHAF, S57enum>(CatHAF.class); static { Cathaf.put(CatHAF.HAF_UNKN, new S57enum(0, ""));
178 Cathaf.put(CatHAF.HAF_RORO, new S57enum(1, "roro")); Cathaf.put(CatHAF.HAF_TMBR, new S57enum(2, "timber")); Cathaf.put(CatHAF.HAF_FERY, new S57enum(3, "ferry"));
179 Cathaf.put(CatHAF.HAF_FISH, new S57enum(4, "fishing")); Cathaf.put(CatHAF.HAF_YCHT, new S57enum(5, "yacht")); Cathaf.put(CatHAF.HAF_NAVL, new S57enum(6, "naval"));
180 Cathaf.put(CatHAF.HAF_TNKR, new S57enum(7, "tanker")); Cathaf.put(CatHAF.HAF_PSGR, new S57enum(8, "passenger")); Cathaf.put(CatHAF.HAF_YARD, new S57enum(9, "shipyard"));
181 Cathaf.put(CatHAF.HAF_CNTR, new S57enum(10, "container")); Cathaf.put(CatHAF.HAF_BULK, new S57enum(11, "bulk")); Cathaf.put(CatHAF.HAF_SYNC, new S57enum(12, "syncrolift"));
182 Cathaf.put(CatHAF.HAF_STCR, new S57enum(13, "straddle_carrier")); Cathaf.put(CatHAF.HAF_MRNA, new S57enum(14, "marina")); Cathaf.put(CatHAF.HAF_REPR, new S57enum(16, "service_repair"));
183 Cathaf.put(CatHAF.HAF_QUAR, new S57enum(17, "quarantine"));
184 }
185 public enum CatHLK { HLK_UNKN, HLK_REST, HLK_HIST, HLK_MUSM, HLK_ACCM, HLK_BWTR, HLK_CSNO }
186 private static final EnumMap<CatHLK, S57enum> Cathlk = new EnumMap<CatHLK, S57enum>(CatHLK.class); static { Cathlk.put(CatHLK.HLK_UNKN, new S57enum(0, ""));
187 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"));
188 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"));
189 }
190 public enum CatICE { ICE_UNKN, ICE_FAST, ICE_SEA, ICE_GRLR, ICE_PANK, ICE_GLAS, ICE_PEAK, ICE_PACK, ICE_POLR }
191 private static final EnumMap<CatICE, S57enum> Catice = new EnumMap<CatICE, S57enum>(CatICE.class); static { Catice.put(CatICE.ICE_UNKN, new S57enum(0, ""));
192 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"));
193 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"));
194 Catice.put(CatICE.ICE_PACK, new S57enum(7, "pack")); Catice.put(CatICE.ICE_POLR, new S57enum(8, "polar"));
195 }
196 public enum CatINB { INB_UNKN, INB_CALM, INB_SBM }
197 private static final EnumMap<CatINB, S57enum> Catinb = new EnumMap<CatINB, S57enum>(CatINB.class); static { Catinb.put(CatINB.INB_UNKN, new S57enum(0, ""));
198 Catinb.put(CatINB.INB_CALM, new S57enum(1, "calm")); Catinb.put(CatINB.INB_SBM, new S57enum(2, "sbm"));
199 }
200 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,
201 LND_SLTP, LND_MORN, LND_CRTR, LND_CAVE, LND_PINCL, LND_CAY
202 }
203 private static final EnumMap<CatLND, S57enum> Catlnd = new EnumMap<CatLND, S57enum>(CatLND.class); static { Catlnd.put(CatLND.LND_UNKN, new S57enum(0, ""));
204 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"));
205 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"));
206 Catlnd.put(CatLND.LND_CNYN, new S57enum(7, "canyon")); Catlnd.put(CatLND.LND_PDDY, new S57enum(8, "paddy")); Catlnd.put(CatLND.LND_AGRI, new S57enum(9, "agricultural"));
207 Catlnd.put(CatLND.LND_SVNA, new S57enum(10, "savanna")); Catlnd.put(CatLND.LND_PARK, new S57enum(11, "parkland")); Catlnd.put(CatLND.LND_SWMP, new S57enum(12, "swamp"));
208 Catlnd.put(CatLND.LND_LSLD, new S57enum(13, "landslide")); Catlnd.put(CatLND.LND_LAVA, new S57enum(14, "lava")); Catlnd.put(CatLND.LND_SLTP, new S57enum(15, "salt_pan"));
209 Catlnd.put(CatLND.LND_MORN, new S57enum(16, "moraine")); Catlnd.put(CatLND.LND_CRTR, new S57enum(17, "crater")); Catlnd.put(CatLND.LND_CAVE, new S57enum(18, "cave"));
210 Catlnd.put(CatLND.LND_PINCL, new S57enum(19, "rock_pinnacle")); Catlnd.put(CatLND.LND_CAY, new S57enum(20, "cay"));
211 }
212 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,
213 LMK_DOME, LMK_RADR, LMK_TOWR, LMK_WNDM, LMK_WNDG, LMK_SPIR, LMK_BLDR, LMK_MNRT, LMK_WTRT }
214 private static final EnumMap<CatLMK, S57enum> Catlmk = new EnumMap<CatLMK, S57enum>(CatLMK.class); static {Catlmk.put(CatLMK.LMK_UNKN, new S57enum(0, ""));
215 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"));
216 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"));
217 Catlmk.put(CatLMK.LMK_MAST, new S57enum(7, "mast")); Catlmk.put(CatLMK.LMK_WNDS, new S57enum(8, "windsock")); Catlmk.put(CatLMK.LMK_MNMT, new S57enum(9, "monument"));
218 Catlmk.put(CatLMK.LMK_CLMN, new S57enum(10, "column")); Catlmk.put(CatLMK.LMK_MEML, new S57enum(11, "memorial")); Catlmk.put(CatLMK.LMK_OBLK, new S57enum(12, "obelisk"));
219 Catlmk.put(CatLMK.LMK_STAT, new S57enum(13, "statue")); Catlmk.put(CatLMK.LMK_CROS, new S57enum(14, "cross")); Catlmk.put(CatLMK.LMK_DOME, new S57enum(15, "dome"));
220 Catlmk.put(CatLMK.LMK_RADR, new S57enum(16, "radar_scanner")); Catlmk.put(CatLMK.LMK_TOWR, new S57enum(17, "tower")); Catlmk.put(CatLMK.LMK_WNDM, new S57enum(18, "windmill"));
221 Catlmk.put(CatLMK.LMK_WNDG, new S57enum(19, "windmotor")); Catlmk.put(CatLMK.LMK_SPIR, new S57enum(20, "spire")); Catlmk.put(CatLMK.LMK_BLDR, new S57enum(21, "boulder"));
222 Catlmk.put(CatLMK.LMK_MNRT, new S57enum(22, "minaret")); Catlmk.put(CatLMK.LMK_WTRT, new S57enum(23, "water_tower"));
223 }
224 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,
225 LAM_DRLT, LAM_DRRT, LAM_TOLT, LAM_TPRT, LAM_JBRT, LAM_JNLT, LAM_HBRT, LAM_HBLT, LAM_BRGP }
226 private static final EnumMap<CatLAM, S57enum> Catlam = new EnumMap<CatLAM, S57enum>(CatLAM.class); static { Catlam.put(CatLAM.LAM_UNKN, new S57enum(0, ""));
227 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"));
228 Catlam.put(CatLAM.LAM_PCPT, new S57enum(4, "preferred_channel_port")); Catlam.put(CatLAM.LAM_WWLT, new S57enum(5, "waterway_left")); Catlam.put(CatLAM.LAM_WWRT, new S57enum(6, "waterway_right"));
229 Catlam.put(CatLAM.LAM_CHLT, new S57enum(7, "channel_left")); Catlam.put(CatLAM.LAM_CHRT, new S57enum(8, "channel_right")); Catlam.put(CatLAM.LAM_WWSN, new S57enum(9, "waterway_separation"));
230 Catlam.put(CatLAM.LAM_CHSN, new S57enum(10, "channel_separation")); Catlam.put(CatLAM.LAM_CHRB, new S57enum(11, "channel_right_bank")); Catlam.put(CatLAM.LAM_CHLB, new S57enum(12, "channel_left_bank"));
231 Catlam.put(CatLAM.LAM_CRRT, new S57enum(13, "crossover_right")); Catlam.put(CatLAM.LAM_CRLT, new S57enum(14, "crossover_left")); Catlam.put(CatLAM.LAM_DRLT, new S57enum(15, "danger_right"));
232 Catlam.put(CatLAM.LAM_DRRT, new S57enum(16, "danger_left")); Catlam.put(CatLAM.LAM_TOLT, new S57enum(17, "turnoff_right")); Catlam.put(CatLAM.LAM_TPRT, new S57enum(18, "turnoff_left"));
233 Catlam.put(CatLAM.LAM_JBRT, new S57enum(19, "junction_right")); Catlam.put(CatLAM.LAM_JNLT, new S57enum(20, "junction_left")); Catlam.put(CatLAM.LAM_HBRT, new S57enum(21, "harbour_right"));
234 Catlam.put(CatLAM.LAM_HBLT, new S57enum(22, "harbour_left")); Catlam.put(CatLAM.LAM_BRGP, new S57enum(23, "bridge_pier"));
235 }
236 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 }
237 private static final EnumMap<CatLIT, S57enum> Catlit = new EnumMap<CatLIT, S57enum>(CatLIT.class); static { Catlit.put(CatLIT.LIT_UNKN, new S57enum(0, ""));
238 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"));
239 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"));
240 Catlit.put(CatLIT.LIT_STRP, new S57enum(9, "strip_light")); Catlit.put(CatLIT.LIT_SUBS, new S57enum(10, "subsidiary")); Catlit.put(CatLIT.LIT_SPOT, new S57enum(11, "spotlight"));
241 Catlit.put(CatLIT.LIT_FRNT, new S57enum(12, "front")); Catlit.put(CatLIT.LIT_REAR, new S57enum(13, "rear")); Catlit.put(CatLIT.LIT_LOWR, new S57enum(14, "lower"));
242 Catlit.put(CatLIT.LIT_UPPR, new S57enum(15, "upper")); Catlit.put(CatLIT.LIT_MOIR, new S57enum(16, "moire")); Catlit.put(CatLIT.LIT_EMRG, new S57enum(17, "emergency"));
243 Catlit.put(CatLIT.LIT_BRNG, new S57enum(18, "bearing")); Catlit.put(CatLIT.LIT_HORI, new S57enum(19, "horizontal")); Catlit.put(CatLIT.LIT_VERT, new S57enum(20, "vertical"));
244 }
245 public enum CatMFA { MFA_UNKN, MFA_CRST, MFA_OYMS, MFA_FISH, MFA_SEAW, MFA_PRLC }
246 private static final EnumMap<CatMFA, S57enum> Catmfa = new EnumMap<CatMFA, S57enum>(CatMFA.class); static { Catmfa.put(CatMFA.MFA_UNKN, new S57enum(0, ""));
247 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"));
248 Catmfa.put(CatMFA.MFA_SEAW, new S57enum(4, "seaweed")); Catmfa.put(CatMFA.MFA_PRLC, new S57enum(5, "pearl_culture"));
249 }
250 public enum CatMPA { MPA_UNKN, MPA_PRCT, MPA_TRPD, MPA_SUBM, MPA_FIRG, MPA_MINL, MPA_SMLA }
251 private static final EnumMap<CatMPA, S57enum> Catmpa = new EnumMap<CatMPA, S57enum>(CatMPA.class); static { Catmpa.put(CatMPA.MPA_UNKN, new S57enum(0, ""));
252 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"));
253 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"));
254 }
255 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 }
256 private static final EnumMap<CatMOR, S57enum> Catmor = new EnumMap<CatMOR, S57enum>(CatMOR.class); static { Catmor.put(CatMOR.MOR_UNKN, new S57enum(0, ""));
257 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"));
258 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"));
259 Catmor.put(CatMOR.MOR_BUOY, new S57enum(7, "buoy")); Catmor.put(CatMOR.MOR_SHRP, new S57enum(8, "shore_ropes")); Catmor.put(CatMOR.MOR_AUTO, new S57enum(9, "automatic"));
260 Catmor.put(CatMOR.MOR_POST, new S57enum(10, "post")); Catmor.put(CatMOR.MOR_WIRE, new S57enum(11, "wire")); Catmor.put(CatMOR.MOR_CABL, new S57enum(12, "cable"));
261 }
262 public enum CatNAV { NAV_UNKN, NAV_CLRG, NAV_TRST, NAV_LDNG }
263 private static final EnumMap<CatNAV, S57enum> Catnav = new EnumMap<CatNAV, S57enum>(CatNAV.class); static { Catnav.put(CatNAV.NAV_UNKN, new S57enum(0, ""));
264 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"));
265 }
266 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 }
267 private static final EnumMap<CatOBS, S57enum> Catobs = new EnumMap<CatOBS, S57enum>(CatOBS.class); static { Catobs.put(CatOBS.OBS_UNKN, new S57enum(0, ""));
268 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"));
269 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"));
270 Catobs.put(CatOBS.OBS_FLGD, new S57enum(7, "foul_ground")); Catobs.put(CatOBS.OBS_ICEB, new S57enum(8, "ice_boom")); Catobs.put(CatOBS.OBS_GTKL, new S57enum(9, "ground_tackle"));
271 Catobs.put(CatOBS.OBS_BOOM, new S57enum(10, "boom"));
272 }
273 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 }
274 private static final EnumMap<CatOFP, S57enum> Catofp = new EnumMap<CatOFP, S57enum>(CatOFP.class); static { Catofp.put(CatOFP.OFP_UNKN, new S57enum(0, ""));
275 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"));
276 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"));
277 Catofp.put(CatOFP.OFP_AISL, new S57enum(7, "artificial_island")); Catofp.put(CatOFP.OFP_FPSO, new S57enum(8, "fpso")); Catofp.put(CatOFP.OFP_ACCN, new S57enum(9, "accommodation"));
278 Catofp.put(CatOFP.OFP_NCCB, new S57enum(10, "nccb"));
279 }
280 public enum CatOLB { OLB_UNKN, OLB_RETN, OLB_FLTG }
281 private static final EnumMap<CatOLB, S57enum> Catolb = new EnumMap<CatOLB, S57enum>(CatOLB.class); static { Catolb.put(CatOLB.OLB_UNKN, new S57enum(0, ""));
282 Catolb.put(CatOLB.OLB_RETN, new S57enum(1, "retention")); Catolb.put(CatOLB.OLB_FLTG, new S57enum(2, "floating"));
283 }
284 public enum CatPLE { PLE_UNKN, PLE_STAK, PLE_SNAG, PLE_POST, PLE_TRIP }
285 private static final EnumMap<CatPLE, S57enum> Catple = new EnumMap<CatPLE, S57enum>(CatPLE.class); static { Catple.put(CatPLE.PLE_UNKN, new S57enum(0, ""));
286 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"));
287 Catple.put(CatPLE.PLE_TRIP, new S57enum(4, "tripodal"));
288 }
289 public enum CatPIL { PIL_UNKN, PIL_CVSL, PIL_HELI, PIL_SHOR }
290 private static final EnumMap<CatPIL, S57enum> Catpil = new EnumMap<CatPIL, S57enum>(CatPIL.class); static { Catpil.put(CatPIL.PIL_UNKN, new S57enum(0, ""));
291 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"));
292 }
293 public enum CatPIP { PIP_UNKN, PIP_OFAL, PIP_ITAK, PIP_SEWR, PIP_BBLR, PIP_SPPL }
294 private static final EnumMap<CatPIP, S57enum> Catpip = new EnumMap<CatPIP, S57enum>(CatPIP.class); static { Catpip.put(CatPIP.PIP_UNKN, new S57enum(0, ""));
295 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"));
296 Catpip.put(CatPIP.PIP_BBLR, new S57enum(5, "bubbler")); Catpip.put(CatPIP.PIP_SPPL, new S57enum(6, "supply"));
297 }
298 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 }
299 private static final EnumMap<CatPRA, S57enum> Catpra = new EnumMap<CatPRA, S57enum>(CatPRA.class); static { Catpra.put(CatPRA.PRA_UNKN, new S57enum(0, ""));
300 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"));
301 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"));
302 Catpra.put(CatPRA.PRA_FACT, new S57enum(7, "factory")); Catpra.put(CatPRA.PRA_TFRM, new S57enum(8, "tank_farm")); Catpra.put(CatPRA.PRA_WFRM, new S57enum(9, "wind_farm"));
303 Catpra.put(CatPRA.PRA_SLAG, new S57enum(10, "slag"));
304 }
305 public enum CatPYL { PYL_UNKN, PYL_POWR, PYL_TELE, PYL_AERL, PYL_BRDG, PYL_PIER }
306 private static final EnumMap<CatPYL, S57enum> Catpyl = new EnumMap<CatPYL, S57enum>(CatPYL.class); static { Catpyl.put(CatPYL.PYL_UNKN, new S57enum(0, ""));
307 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"));
308 Catpyl.put(CatPYL.PYL_BRDG, new S57enum(4, "bridge")); Catpyl.put(CatPYL.PYL_PIER, new S57enum(5, "bridge_pier"));
309 }
310 public enum CatQUA { QUA_UNKN, QUA_A, QUA_B, QUA_C, QUA_D, QUA_E, QUA_NEVL }
311 private static final EnumMap<CatQUA, S57enum> Catqua = new EnumMap<CatQUA, S57enum>(CatQUA.class); static { Catqua.put(CatQUA.QUA_UNKN, new S57enum(0, ""));
312 Catqua.put(CatQUA.QUA_A, new S57enum(1, "a")); Catqua.put(CatQUA.QUA_B, new S57enum(2, "b")); Catqua.put(CatQUA.QUA_C, new S57enum(3, "c"));
313 Catqua.put(CatQUA.QUA_D, new S57enum(4, "d")); Catqua.put(CatQUA.QUA_E, new S57enum(5, "e")); Catqua.put(CatQUA.QUA_NEVL, new S57enum(6, "not_evaluated"));
314 }
315 public enum CatRAS { RAS_UNKN, RAS_SURV, RAS_COST }
316 private static final EnumMap<CatRAS, S57enum> Catras = new EnumMap<CatRAS, S57enum>(CatRAS.class); static { Catras.put(CatRAS.RAS_UNKN, new S57enum(0, ""));
317 Catras.put(CatRAS.RAS_SURV, new S57enum(1, "surveillance")); Catras.put(CatRAS.RAS_COST, new S57enum(2, "coast"));
318 }
319 public enum CatRTB { RTB_UNKN, RTB_RAMK, RTB_RACN, RTB_LDG }
320 private static final EnumMap<CatRTB, S57enum> Catrtb = new EnumMap<CatRTB, S57enum>(CatRTB.class); static {Catrtb.put(CatRTB.RTB_UNKN, new S57enum(0, ""));
321 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"));
322 }
323 public enum CatROS { ROS_UNKN, ROS_OMNI, ROS_DIRL, ROS_ROTP, ROS_CNSL, ROS_RDF, ROS_QTA, ROS_AERO, ROS_DECA, ROS_LORN, ROS_DAPS, ROS_TORN, ROS_OMGA, ROS_SYLD, ROS_CHKA }
324 private static final EnumMap<CatROS, S57enum> Catros = new EnumMap<CatROS, S57enum>(CatROS.class); static { Catros.put(CatROS.ROS_UNKN, new S57enum(0, ""));
325 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"));
326 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"));
327 Catros.put(CatROS.ROS_AERO, new S57enum(7, "aeronautical")); Catros.put(CatROS.ROS_DECA, new S57enum(8, "decca")); Catros.put(CatROS.ROS_LORN, new S57enum(9, "loran"));
328 Catros.put(CatROS.ROS_DAPS, new S57enum(10, "dgps")); Catros.put(CatROS.ROS_TORN, new S57enum(11, "toran")); Catros.put(CatROS.ROS_OMGA, new S57enum(12, "omega"));
329 Catros.put(CatROS.ROS_SYLD, new S57enum(13, "syledis")); Catros.put(CatROS.ROS_CHKA, new S57enum(14, "chaika"));
330 }
331 public enum CatTRK { TRK_UNKN, TRK_FIXM, TRK_NFXM }
332 private static final EnumMap<CatTRK, S57enum> Cattrk = new EnumMap<CatTRK, S57enum>(CatTRK.class); static { Cattrk.put(CatTRK.TRK_UNKN, new S57enum(0, ""));
333 Cattrk.put(CatTRK.TRK_FIXM, new S57enum(1, "fixed_marks")); Cattrk.put(CatTRK.TRK_NFXM, new S57enum(2, "no_fixed_marks"));
334 }
335 public enum CatRSC { RSC_UNKN, RSC_LIFB, RSC_ROKT, RSC_LBRK, RSC_RFSW, RSC_RFIT, RSC_LBOM, RSC_RDIO, RSC_FSTA }
336 private static final EnumMap<CatRSC, S57enum> Catrsc = new EnumMap<CatRSC, S57enum>(CatRSC.class); static { Catrsc.put(CatRSC.RSC_UNKN, new S57enum(0, ""));
337 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"));
338 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"));
339 Catrsc.put(CatRSC.RSC_RDIO, new S57enum(7, "radio")); Catrsc.put(CatRSC.RSC_FSTA, new S57enum(8, "first_aid"));
340 }
341 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,
342 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 }
343 private static final EnumMap<CatREA, S57enum> Catrea = new EnumMap<CatREA, S57enum>(CatREA.class); static { Catrea.put(CatREA.REA_UNKN, new S57enum(0, ""));
344 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"));
345 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"));
346 Catrea.put(CatREA.REA_SEAL, new S57enum(7, "seal_sanctuary")); Catrea.put(CatREA.REA_DEGR, new S57enum(8, "degaussing_range")); Catrea.put(CatREA.REA_MILY, new S57enum(9, "military"));
347 Catrea.put(CatREA.REA_HIST, new S57enum(10, "historic_wreck")); Catrea.put(CatREA.REA_INST, new S57enum(11, "inshore_traffic")); Catrea.put(CatREA.REA_NASF, new S57enum(12, "navigational_aid_safety"));
348 Catrea.put(CatREA.REA_STRD, new S57enum(13, "stranding_danger")); Catrea.put(CatREA.REA_MINE, new S57enum(14, "minefield")); Catrea.put(CatREA.REA_NDIV, new S57enum(15, "no_diving"));
349 Catrea.put(CatREA.REA_TBAV, new S57enum(16, "to_be_avoided")); Catrea.put(CatREA.REA_PROH, new S57enum(17, "prohibited")); Catrea.put(CatREA.REA_SWIM, new S57enum(18, "swimming"));
350 Catrea.put(CatREA.REA_WAIT, new S57enum(19, "waiting")); Catrea.put(CatREA.REA_RSCH, new S57enum(20, "research")); Catrea.put(CatREA.REA_DREG, new S57enum(21, "dredging"));
351 Catrea.put(CatREA.REA_FSNC, new S57enum(22, "fish_sanctuary")); Catrea.put(CatREA.REA_ERES, new S57enum(23, "ecological_reserve")); Catrea.put(CatREA.REA_NWAK, new S57enum(24, "no_wake"));
352 Catrea.put(CatREA.REA_SWNG, new S57enum(25, "swinging")); Catrea.put(CatREA.REA_WSKI, new S57enum(26, "water_skiing"));
353 }
354 public enum CatROD { ROD_UNKN, ROD_MWAY, ROD_MAJR, ROD_MINR, ROD_TRAK, ROD_MAJS, ROD_MINS, ROD_CRSG, ROD_PATH }
355 private static final EnumMap<CatROD, S57enum> Catrod = new EnumMap<CatROD, S57enum>(CatROD.class); static { Catrod.put(CatROD.ROD_UNKN, new S57enum(0, ""));
356 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"));
357 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"));
358 Catrod.put(CatROD.ROD_CRSG, new S57enum(7, "crossing")); Catrod.put(CatROD.ROD_PATH, new S57enum(8, "path"));
359 }
360 public enum CatRUN { RUN_UNKN, RUN_AERP, RUN_HELI }
361 private static final EnumMap<CatRUN, S57enum> Catrun = new EnumMap<CatRUN, S57enum>(CatRUN.class); static { Catrun.put(CatRUN.RUN_UNKN, new S57enum(0, ""));
362 Catrun.put(CatRUN.RUN_AERP, new S57enum(1, "aeroplane")); Catrun.put(CatRUN.RUN_HELI, new S57enum(2, "helicopter"));
363 }
364 public enum CatSEA { SEA_UNKN, SEA_GENL, SEA_GAT, SEA_BANK, SEA_DEEP, SEA_BAY, SEA_TRCH, SEA_BASN, SEA_MDFT, SEA_REEF, SEA_LEDG, SEA_CNYN, SEA_NRRW, SEA_SHOL,
365 SEA_KNOL, SEA_RIDG, SEA_SMNT, SEA_PNCL, SEA_APLN, SEA_PLTU, SEA_SPUR, SEA_SHLF, SEA_TRGH, SEA_SDDL, SEA_AHLL, SEA_APRN, SEA_AAPN, SEA_BLND, SEA_CMGN, SEA_CRIS,
366 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,
367 SEA_SEDG, SEA_SILL, SEA_SLOP, SEA_TRRC, SEA_VLLY, SEA_CANL, SEA_LAKE, SEA_RIVR, SEA_RECH }
368 private static final EnumMap<CatSEA, S57enum> Catsea = new EnumMap<CatSEA, S57enum>(CatSEA.class); static { Catsea.put(CatSEA.SEA_UNKN, new S57enum(0, ""));
369 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"));
370 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"));
371 Catsea.put(CatSEA.SEA_BASN, new S57enum(7, "basin")); Catsea.put(CatSEA.SEA_MDFT, new S57enum(8, "mud_flats")); Catsea.put(CatSEA.SEA_REEF, new S57enum(9, "reef"));
372 Catsea.put(CatSEA.SEA_LEDG, new S57enum(10, "ledge")); Catsea.put(CatSEA.SEA_CNYN, new S57enum(11, "canyon")); Catsea.put(CatSEA.SEA_NRRW, new S57enum(12, "narrows"));
373 Catsea.put(CatSEA.SEA_SHOL, new S57enum(13, "shoal")); Catsea.put(CatSEA.SEA_KNOL, new S57enum(14, "knoll")); Catsea.put(CatSEA.SEA_RIDG, new S57enum(15, "ridge"));
374 Catsea.put(CatSEA.SEA_SMNT, new S57enum(16, "seamount")); Catsea.put(CatSEA.SEA_PNCL, new S57enum(17, "pinnacle")); Catsea.put(CatSEA.SEA_APLN, new S57enum(18, "abyssal_plain"));
375 Catsea.put(CatSEA.SEA_PLTU, new S57enum(19, "plateau")); Catsea.put(CatSEA.SEA_SPUR, new S57enum(20, "spur")); Catsea.put(CatSEA.SEA_SHLF, new S57enum(21, "shelf"));
376 Catsea.put(CatSEA.SEA_TRGH, new S57enum(22, "trough")); Catsea.put(CatSEA.SEA_SDDL, new S57enum(23, "saddle")); Catsea.put(CatSEA.SEA_AHLL, new S57enum(24, "abyssal_hills"));
377 Catsea.put(CatSEA.SEA_APRN, new S57enum(25, "apron")); Catsea.put(CatSEA.SEA_AAPN, new S57enum(26, "archipelagic_apron")); Catsea.put(CatSEA.SEA_BLND, new S57enum(27, "borderland"));
378 Catsea.put(CatSEA.SEA_CMGN, new S57enum(28, "continental_margin")); Catsea.put(CatSEA.SEA_CRIS, new S57enum(29, "continental_rise")); Catsea.put(CatSEA.SEA_ESCT, new S57enum(30, "escarpment"));
379 Catsea.put(CatSEA.SEA_FAN, new S57enum(31, "fan")); Catsea.put(CatSEA.SEA_FZON, new S57enum(32, "fracture_zone")); Catsea.put(CatSEA.SEA_GAP, new S57enum(33, "gap"));
380 Catsea.put(CatSEA.SEA_GUYT, new S57enum(34, "guyot")); Catsea.put(CatSEA.SEA_HILL, new S57enum(35, "hill")); Catsea.put(CatSEA.SEA_HOLE, new S57enum(36, "hole"));
381 Catsea.put(CatSEA.SEA_LEVE, new S57enum(37, "levee")); Catsea.put(CatSEA.SEA_MVLY, new S57enum(38, "median valley")); Catsea.put(CatSEA.SEA_MOAT, new S57enum(39, "moat"));
382 Catsea.put(CatSEA.SEA_MTNS, new S57enum(40, "mountains")); Catsea.put(CatSEA.SEA_PEAK, new S57enum(41, "peak")); Catsea.put(CatSEA.SEA_PVNC, new S57enum(42, "province"));
383 Catsea.put(CatSEA.SEA_RISE, new S57enum(43, "rise")); Catsea.put(CatSEA.SEA_SCNL, new S57enum(44, "sea channel")); Catsea.put(CatSEA.SEA_SCHN, new S57enum(45, "seamount_chain"));
384 Catsea.put(CatSEA.SEA_SEDG, new S57enum(46, "shelf-edge")); Catsea.put(CatSEA.SEA_SILL, new S57enum(47, "sill")); Catsea.put(CatSEA.SEA_SLOP, new S57enum(48, "slope"));
385 Catsea.put(CatSEA.SEA_TRRC, new S57enum(49, "terrace")); Catsea.put(CatSEA.SEA_VLLY, new S57enum(50, "valley")); Catsea.put(CatSEA.SEA_CANL, new S57enum(51, "canal"));
386 Catsea.put(CatSEA.SEA_LAKE, new S57enum(52, "lake")); Catsea.put(CatSEA.SEA_RIVR, new S57enum(53, "river")); Catsea.put(CatSEA.SEA_RECH, new S57enum(54, "reach"));
387 }
388 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,
389 SLC_RAMP, SLC_SWAY, SLC_FNDR, SLC_SFWF, SLC_OFWF, SLC_LRMP, SLC_LWAL }
390 private static final EnumMap<CatSLC, S57enum> Catslc = new EnumMap<CatSLC, S57enum>(CatSLC.class); static { Catslc.put(CatSLC.SLC_UNKN, new S57enum(0, ""));
391 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"));
392 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"));
393 Catslc.put(CatSLC.SLC_TWAL, new S57enum(7, "training_wall")); Catslc.put(CatSLC.SLC_RPRP, new S57enum(8, "rip_rap")); Catslc.put(CatSLC.SLC_RVMT, new S57enum(9, "revetment"));
394 Catslc.put(CatSLC.SLC_SWAL, new S57enum(10, "sea_wall")); Catslc.put(CatSLC.SLC_LSTP, new S57enum(11, "landing_steps")); Catslc.put(CatSLC.SLC_RAMP, new S57enum(12, "ramp"));
395 Catslc.put(CatSLC.SLC_SWAY, new S57enum(13, "slipway")); Catslc.put(CatSLC.SLC_FNDR, new S57enum(14, "fender")); Catslc.put(CatSLC.SLC_SFWF, new S57enum(15, "solid_face_wharf"));
396 Catslc.put(CatSLC.SLC_OFWF, new S57enum(16, "open_face_wharf")); Catslc.put(CatSLC.SLC_LRMP, new S57enum(17, "log_ramp")); Catslc.put(CatSLC.SLC_LWAL, new S57enum(18, "lock_wall"));
397 }
398 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 }
399 private static final EnumMap<CatSIT, S57enum> Catsit = new EnumMap<CatSIT, S57enum>(CatSIT.class); static {Catsit.put(CatSIT.SIT_UNKN, new S57enum(0, ""));
400 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"));
401 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"));
402 Catsit.put(CatSIT.SIT_FLDB, new S57enum(7, "flood_barrage")); Catsit.put(CatSIT.SIT_BRDG, new S57enum(8, "bridge_passage")); Catsit.put(CatSIT.SIT_DRDG, new S57enum(9, "dredging"));
403 Catsit.put(CatSIT.SIT_TCLT, new S57enum(10, "traffic_control_light"));
404 }
405 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,
406 SIW_TIDG, SIW_TIDS, SIW_DIVE, SIW_WTLG, SIW_VRCL, SIW_DPTH }
407 private static final EnumMap<CatSIW, S57enum> Catsiw = new EnumMap<CatSIW, S57enum>(CatSIW.class); static {Catsiw.put(CatSIW.SIW_UNKN, new S57enum(0, ""));
408 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"));
409 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"));
410 Catsiw.put(CatSIW.SIW_STRM, new S57enum(7, "storm")); Catsiw.put(CatSIW.SIW_ICE, new S57enum(8, "ice")); Catsiw.put(CatSIW.SIW_TIME, new S57enum(9, "time"));
411 Catsiw.put(CatSIW.SIW_TIDE, new S57enum(10, "tide")); Catsiw.put(CatSIW.SIW_TSTR, new S57enum(11, "tidal_stream")); Catsiw.put(CatSIW.SIW_TIDG, new S57enum(12, "tide_gauge"));
412 Catsiw.put(CatSIW.SIW_TIDS, new S57enum(13, "tide_scale")); Catsiw.put(CatSIW.SIW_DIVE, new S57enum(14, "diving")); Catsiw.put(CatSIW.SIW_WTLG, new S57enum(15, "water_level_gauge"));
413 Catsiw.put(CatSIW.SIW_VRCL, new S57enum(16, "vertical_clearance")); Catsiw.put(CatSIW.SIW_DPTH, new S57enum(18, "depth"));
414 }
415 public enum CatSIL { SIL_UNKN, SIL_SILO, SIL_TANK, SIL_GRNE, SIL_WTRT }
416 private static final EnumMap<CatSIL, S57enum> Catsil = new EnumMap<CatSIL, S57enum>(CatSIL.class); static { Catsil.put(CatSIL.SIL_UNKN, new S57enum(0, ""));
417 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"));
418 Catsil.put(CatSIL.SIL_WTRT, new S57enum(4, "water_tower"));
419 }
420 public enum CatSLO { SLO_UNKN, SLO_CUTG, SLO_EMBK, SLO_DUNE, SLO_HILL, SLO_PINO, SLO_CLIF, SLO_SCRE }
421 private static final EnumMap<CatSLO, S57enum> Catslo = new EnumMap<CatSLO, S57enum>(CatSLO.class); static { Catslo.put(CatSLO.SLO_UNKN, new S57enum(0, ""));
422 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"));
423 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"));
424 }
425 public enum CatSCF { SCF_UNKN, SCF_VBTH, SCF_CLUB, SCF_BHST, SCF_SMKR, SCF_BTYD, SCF_INN, SCF_RSRT, SCF_CHDR, SCF_PROV, SCF_DCTR, SCF_PHRM,
426 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,
427 SCF_PMPO, SCF_EMRT, SCF_SLPW, SCF_VMOR, SCF_SCRB, SCF_PCNC, SCF_MECH, SCF_SECS }
428 private static final EnumMap<CatSCF, S57enum> Catscf = new EnumMap<CatSCF, S57enum>(CatSCF.class); static { Catscf.put(CatSCF.SCF_UNKN, new S57enum(0, ""));
429 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"));
430 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"));
431 Catscf.put(CatSCF.SCF_RSRT, new S57enum(7, "restaurant")); Catscf.put(CatSCF.SCF_CHDR, new S57enum(8, "chandler")); Catscf.put(CatSCF.SCF_PROV, new S57enum(9, "provisions"));
432 Catscf.put(CatSCF.SCF_DCTR, new S57enum(10, "doctor")); Catscf.put(CatSCF.SCF_PHRM, new S57enum(11, "pharmacy")); Catscf.put(CatSCF.SCF_WTRT, new S57enum(12, "water_tap"));
433 Catscf.put(CatSCF.SCF_FUEL, new S57enum(13, "fuel_station")); Catscf.put(CatSCF.SCF_ELEC, new S57enum(14, "electricity")); Catscf.put(CatSCF.SCF_BGAS, new S57enum(15, "bottle_gas"));
434 Catscf.put(CatSCF.SCF_SHWR, new S57enum(16, "showers")); Catscf.put(CatSCF.SCF_LAUN, new S57enum(17, "laundrette")); Catscf.put(CatSCF.SCF_WC, new S57enum(18, "toilets"));
435 Catscf.put(CatSCF.SCF_POST, new S57enum(19, "post_box")); Catscf.put(CatSCF.SCF_TELE, new S57enum(20, "telephone")); Catscf.put(CatSCF.SCF_REFB, new S57enum(21, "refuse_bin"));
436 Catscf.put(CatSCF.SCF_CARP, new S57enum(22, "car_park")); Catscf.put(CatSCF.SCF_BTPK, new S57enum(23, "boat_trailers_park")); Catscf.put(CatSCF.SCF_CRVN, new S57enum(24, "caravan_site"));
437 Catscf.put(CatSCF.SCF_CAMP, new S57enum(25, "camping_site")); Catscf.put(CatSCF.SCF_PMPO, new S57enum(26, "pump-out")); Catscf.put(CatSCF.SCF_EMRT, new S57enum(27, "emergency_telephone"));
438 Catscf.put(CatSCF.SCF_SLPW, new S57enum(28, "slipway")); Catscf.put(CatSCF.SCF_VMOR, new S57enum(29, "visitors_mooring")); Catscf.put(CatSCF.SCF_SCRB, new S57enum(30, "scrubbing_berth"));
439 Catscf.put(CatSCF.SCF_PCNC, new S57enum(31, "picnic_area")); Catscf.put(CatSCF.SCF_MECH, new S57enum(32, "mechanics_workshop")); Catscf.put(CatSCF.SCF_SECS, new S57enum(33, "security_service"));
440 }
441 public enum CatSPM { SPM_UNKN, SPM_FDGA, SPM_TRGT, SPM_MSHP, SPM_DGRG, SPM_BARG, SPM_CABL, SPM_SPLG, SPM_OFAL, SPM_ODAS, SPM_RCDG, SPM_SPLA, SPM_RCZN, SPM_PRVT, SPM_MOOR, SPM_LNBY, SPM_LDNG, SPM_MDST,
442 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,
443 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 }
444 private static final EnumMap<CatSPM, S57enum> Catspm = new EnumMap<CatSPM, S57enum>(CatSPM.class); static { Catspm.put(CatSPM.SPM_UNKN, new S57enum(0, ""));
445 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"));
446 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"));
447 Catspm.put(CatSPM.SPM_SPLG, new S57enum(7, "spoil_ground")); Catspm.put(CatSPM.SPM_OFAL, new S57enum(8, "outfall")); Catspm.put(CatSPM.SPM_ODAS, new S57enum(9, "odas"));
448 Catspm.put(CatSPM.SPM_RCDG, new S57enum(10, "recording")); Catspm.put(CatSPM.SPM_SPLA, new S57enum(11, "seaplane_anchorage")); Catspm.put(CatSPM.SPM_RCZN, new S57enum(12, "recreation_zone"));
449 Catspm.put(CatSPM.SPM_PRVT, new S57enum(13, "private")); Catspm.put(CatSPM.SPM_MOOR, new S57enum(14, "mooring")); Catspm.put(CatSPM.SPM_LNBY, new S57enum(15, "lanby"));
450 Catspm.put(CatSPM.SPM_LDNG, new S57enum(16, "leading")); Catspm.put(CatSPM.SPM_MDST, new S57enum(17, "measured_distance")); Catspm.put(CatSPM.SPM_NOTC, new S57enum(18, "notice"));
451 Catspm.put(CatSPM.SPM_TSS, new S57enum(19, "tss")); Catspm.put(CatSPM.SPM_NANC, new S57enum(20, "no_anchoring")); Catspm.put(CatSPM.SPM_NBRT, new S57enum(21, "no_berthing"));
452 Catspm.put(CatSPM.SPM_NOTK, new S57enum(22, "no_overtaking")); Catspm.put(CatSPM.SPM_NTWT, new S57enum(23, "no_two-way_traffic")); Catspm.put(CatSPM.SPM_RWAK, new S57enum(24, "reduced_wake"));
453 Catspm.put(CatSPM.SPM_SPDL, new S57enum(25, "speed_limit")); Catspm.put(CatSPM.SPM_STOP, new S57enum(26, "stop")); Catspm.put(CatSPM.SPM_WRNG, new S57enum(27, "warning"));
454 Catspm.put(CatSPM.SPM_SSSN, new S57enum(28, "sound_ship_siren")); Catspm.put(CatSPM.SPM_RVCL, new S57enum(29, "restricted_vertical_clearance"));
455 Catspm.put(CatSPM.SPM_MVDT, new S57enum(30, "maximum_vessel_draught")); Catspm.put(CatSPM.SPM_RHCL, new S57enum(31, "restricted_horizontal_clearance"));
456 Catspm.put(CatSPM.SPM_SCNT, new S57enum(32, "strong_current")); Catspm.put(CatSPM.SPM_BRTH, new S57enum(33, "berthing")); Catspm.put(CatSPM.SPM_OHPC, new S57enum(34, "overhead_power_cable"));
457 Catspm.put(CatSPM.SPM_CHEG, new S57enum(35, "channel_edge_gradient")); Catspm.put(CatSPM.SPM_TELE, new S57enum(36, "telephone")); Catspm.put(CatSPM.SPM_FCRS, new S57enum(37, "ferry_crossing"));
458 Catspm.put(CatSPM.SPM_MTRL, new S57enum(38, "marine_traffic_lights")); Catspm.put(CatSPM.SPM_PLIN, new S57enum(39, "pipeline")); Catspm.put(CatSPM.SPM_ANCH, new S57enum(40, "anchorage"));
459 Catspm.put(CatSPM.SPM_CLRG, new S57enum(41, "clearing")); Catspm.put(CatSPM.SPM_CTRL, new S57enum(42, "control")); Catspm.put(CatSPM.SPM_DIVG, new S57enum(43, "diving"));
460 Catspm.put(CatSPM.SPM_RBCN, new S57enum(44, "refuge_beacon")); Catspm.put(CatSPM.SPM_FGND, new S57enum(45, "foul_ground")); Catspm.put(CatSPM.SPM_YCHT, new S57enum(46, "yachting"));
461 Catspm.put(CatSPM.SPM_HPRT, new S57enum(47, "heliport")); Catspm.put(CatSPM.SPM_GPS, new S57enum(48, "gps")); Catspm.put(CatSPM.SPM_SLDG, new S57enum(49, "seaplane_landing"));
462 Catspm.put(CatSPM.SPM_NENT, new S57enum(50, "no_entry")); Catspm.put(CatSPM.SPM_WRKP, new S57enum(51, "work_in_progress")); Catspm.put(CatSPM.SPM_UKPP, new S57enum(52, "unknown_purpose"));
463 Catspm.put(CatSPM.SPM_WELH, new S57enum(53, "wellhead")); Catspm.put(CatSPM.SPM_CHSP, new S57enum(54, "channel_separation")); Catspm.put(CatSPM.SPM_MFRM, new S57enum(55, "marine_farm"));
464 Catspm.put(CatSPM.SPM_AREF, new S57enum(56, "artificial_reef"));
465 }
466 public enum CatTSS { TSS_UNKN, TSS_IMOA, TSS_NIMO }
467 private static final EnumMap<CatTSS, S57enum> Cattss = new EnumMap<CatTSS, S57enum>(CatTSS.class); static { Cattss.put(CatTSS.TSS_UNKN, new S57enum(0, ""));
468 Cattss.put(CatTSS.TSS_IMOA, new S57enum(1, "imo_adopted")); Cattss.put(CatTSS.TSS_NIMO, new S57enum(2, "not_imo_adopted"));
469 }
470 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,
471 VEG_TREE, VEG_EVGT, VEG_CONT, VEG_PLMT, VEG_NPMT, VEG_CSAT, VEG_EUCT, VEG_DCDT, VEG_MRVT, VEG_FLOT }
472 private static final EnumMap<CatVEG, S57enum> Catveg = new EnumMap<CatVEG, S57enum>(CatVEG.class); static { Catveg.put(CatVEG.VEG_UNKN, new S57enum(0, ""));
473 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"));
474 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"));
475 Catveg.put(CatVEG.VEG_MGRV, new S57enum(7, "mangroves")); Catveg.put(CatVEG.VEG_PARK, new S57enum(8, "park")); Catveg.put(CatVEG.VEG_PKLD, new S57enum(9, "parkland"));
476 Catveg.put(CatVEG.VEG_MCRP, new S57enum(10, "mixed_crops")); Catveg.put(CatVEG.VEG_REED, new S57enum(11, "reed")); Catveg.put(CatVEG.VEG_MOSS, new S57enum(12, "moss"));
477 Catveg.put(CatVEG.VEG_TREE, new S57enum(13, "tree")); Catveg.put(CatVEG.VEG_EVGT, new S57enum(14, "evergreen_tree")); Catveg.put(CatVEG.VEG_CONT, new S57enum(15, "coniferous_tree"));
478 Catveg.put(CatVEG.VEG_PLMT, new S57enum(16, "palm_tree")); Catveg.put(CatVEG.VEG_NPMT, new S57enum(17, "nipa_palm_tree")); Catveg.put(CatVEG.VEG_CSAT, new S57enum(18, "casuarina_tree"));
479 Catveg.put(CatVEG.VEG_EUCT, new S57enum(19, "eucalypt_tree")); Catveg.put(CatVEG.VEG_DCDT, new S57enum(20, "deciduous_tree")); Catveg.put(CatVEG.VEG_MRVT, new S57enum(21, "mangrove_tree"));
480 Catveg.put(CatVEG.VEG_FLOT, new S57enum(22, "filao_tree"));
481 }
482 /*
483 private static final EnumMap<, S57enum> Catwat = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "breakers")); []={2, "eddies")); []={3, "overfalls")); []={4, "tide_rips"));
484 []={5, "bombora")); }
485 private static final EnumMap<, S57enum> Catwed = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "kelp")); []={2, "sea_weed")); []={3, "sea_grass")); []={4, "saragasso")); }
486 private static final EnumMap<, S57enum> Catwrk = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "non-dangerous")); []={2, "dangerous")); []={3, "distributed_remains"));
487 []={4, "mast_showing")); []={5, "hull_showing")); }
488 private static final EnumMap<, S57enum> Catzoc = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "a1")); []={2, "a2")); []={3, "b")); []={4, "c")); []={5, "d")); []={6, "u")); }
489 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 }
490 private static final EnumMap<, S57enum> Colour = new EnumMap<, S57enum>(.class); static {[COL_UNK]={0, "")); [COL_WHT]={1, "white")); [COL_BLK]={2, "black")); [COL_RED]={3, "red"));
491 [COL_GRN]={4, "green")); [COL_BLU]={5, "blue")); [COL_YEL]={6, "yellow")); [COL_GRY]={7, "grey"));
492 [COL_BRN]={8, "brown")); [COL_AMB]={9, "amber")); [COL_VIO]={10, "violet")); [COL_ORG]={11, "orange")); [COL_MAG]={12, "magenta")); [COL_PNK]={13, "pink")); }
493 public enum ColPAT []={ PAT_UNKN, PAT_HORI, PAT_VERT, PAT_DIAG, PAT_SQUR, PAT_STRP, PAT_BRDR, PAT_CROS, PAT_SALT }
494 private static final EnumMap<, S57enum> Colpat = new EnumMap<, S57enum>(.class); static {[PAT_UNKN]={0, "")); [PAT_HORI]={1, "horizontal")); [PAT_VERT]={2, "vertical"));
495 [PAT_DIAG]={3, "diagonal")); [PAT_SQUR]={4, "squared")); [PAT_STRP]={5, "stripes")); [PAT_BRDR]={6, "border"));
496 [PAT_CROS]={7, "cross")); [PAT_SALT]={8, "saltire")); }
497 private static final EnumMap<, S57enum> Condtn = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "under_construction")); []={2, "ruined")); []={3, "under_reclamation"));
498 []={4, "wingless")); []={5, "planned_construction")); }
499 private static final EnumMap<, S57enum> Conrad = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "conspicuous")); []={2, "not_conspicuous")); []={3, "reflector")); }
500 private static final EnumMap<, S57enum> Convis = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "conspicuous")); []={2, "not_conspicuous")); }
501 private static final EnumMap<, S57enum> Dunits = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "metres")); []={2, "fathoms_feet")); []={3, "fathoms")); []={4, "fathoms_fractions")); }
502 private static final EnumMap<, S57enum> Exclit = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "24h")); []={2, "day")); []={3, "fog")); []={4, "night")); []={5, "warning")); []={6, "storm")); }
503 private static final EnumMap<, S57enum> Expsou = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "within")); []={2, "shoaler")); []={3, "deeper")); }
504 public enum FncFNC []={ FNC_UNKN, FNC_HBRM, FNC_CSTM, FNC_HLTH, FNC_HOSP, FNC_POST, FNC_HOTL, FNC_RAIL, FNC_POLC, FNC_WPOL, FNC_PILO, FNC_PILL, FNC_BANK,
505 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,
506 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 }
507 private static final EnumMap<, S57enum> Functn = new EnumMap<, S57enum>(.class); static {[FNC_UNKN]={0, "")); [FNC_HBRM]={2, "harbour-master")); [FNC_CSTM]={3, "customs")); [FNC_HLTH]={4, "health")); [FNC_HOSP]={5, "hospital")); [FNC_POST]={6, "post_office")); [FNC_HOTL]={7, "hotel"));
508 [FNC_RAIL]={8, "railway_station")); [FNC_POLC]={9, "police_station")); [FNC_WPOL]={10, "water-police_station")); [FNC_PILO]={11, "pilot_office")); [FNC_PILL]={12, "pilot_lookout")); [FNC_BANK]={13, "bank"));
509 [FNC_DIST]={14, "district_control")); [FNC_TRNS]={15, "transit_shed")); [FNC_FCTY]={16, "factory")); [FNC_POWR]={17, "power_station")); [FNC_ADMIN]={18, "administrative")); [FNC_EDUC]={19, "eduCational"));
510 [FNC_CHCH]={20, "church")); [FNC_CHPL]={21, "chapel")); [FNC_TMPL]={22, "temple")); [FNC_PGDA]={23, "pagoda")); [FNC_SHSH]={24, "shinto_shrine")); [FNC_BTMP]={25, "buddhist_temple")); [FNC_MOSQ]={26, "mosque"));
511 [FNC_MRBT]={27, "marabout")); [FNC_LOOK]={28, "lookout")); [FNC_COMM]={29, "communiCation")); [FNC_TV]={30, "television")); [FNC_RADO]={31, "radio")); [FNC_RADR]={32, "radar")); [FNC_LGHT]={33, "light_support"));
512 [FNC_MCWV]={34, "microwave")); [FNC_COOL]={35, "cooling")); [FNC_OBS]={36, "observation")); [FNC_TMBL]={37, "time_ball")); [FNC_CLOK]={38, "clock")); [FNC_CTRL]={39, "control")); [FNC_ASHM]={40, "airship_mooring"));
513 [FNC_STAD]={41, "stadium")); [FNC_BUSS]={42, "bus_station")); }
514 private static final EnumMap<, S57enum> Hunits = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "metres")); []={2, "feet")); []={3, "kilometres")); []={4, "hectometres"));
515 []={5, "statute_miles")); []={6, "nautical_miles")); }
516 private static final EnumMap<, S57enum> Jrsdtn = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "international")); []={2, "national")); []={3, "national_sub-division")); }
517 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,
518 CHR_FLLFL, CHR_OCFL, CHR_FLFL, CHR_ALOC, CHR_ALLFL, CHR_ALFL, CHR_ALGR, CHR_QLFL, CHR_VQLFL, CHR_UQLFL, CHR_AL, CHR_ALFFL }
519 private static final EnumMap<, S57enum> Litchr = new EnumMap<, S57enum>(.class); static {[CHR_UNKN]={0, "")); [CHR_F]={1, "F")); [CHR_FL]={2, "Fl")); [CHR_LFL]={3, "LFl")); [CHR_Q]={4, "Q")); [CHR_VQ]={5, "VQ")); [CHR_UQ]={6, "UQ")); [CHR_ISO]={7, "Iso")); [CHR_OC]={8, "Oc"));
520 [CHR_IQ]={9, "IQ")); [CHR_IVQ]={10, "IVQ")); [CHR_IUQ]={11, "IUQ")); [CHR_MO]={12, "Mo")); [CHR_FFL]={13, "FFl")); [CHR_FLLFL]={14, "FlLFl")); [CHR_OCFL]={15, "OcFl")); [CHR_FLFL]={16, "FLFl")); [CHR_ALOC]={17, "Al.Oc"));
521 [CHR_ALLFL]={18, "Al.LFl")); [CHR_ALFL]={19, "Al.Fl")); [CHR_ALGR]={20, "Al.Gr")); [CHR_QLFL]={25, "Q+LFl")); [CHR_VQLFL]={26, "VQ+LFl")); [CHR_UQLFL]={27, "UQ+LFl")); [CHR_AL]={28, "Al")); [CHR_ALFFL]={29, "Al.FFl")); }
522 private static final EnumMap<, S57enum> Litvis = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "high")); []={2, "low")); []={3, "faint")); []={4, "intensified"));
523 []={5, "unintensified")); []={6, "restricted")); []={7, "obscured")); []={8, "part_obscured")); }
524 private static final EnumMap<, S57enum> Marsys = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "iala-a")); []={2, "iala-b")); []={9, "none")); []={10, "other"));
525 []={11, "cevni")); []={12, "riwr")); }
526 private static final EnumMap<, S57enum> Natcon = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "masonry")); []={2, "concreted")); []={3, "loose_boulders"));
527 []={4, "hard-surfaced")); []={5, "unsurfaced")); []={6, "wooden")); []={7, "metal")); []={8, "grp")); []={9, "painted")); }
528 private static final EnumMap<, S57enum> Natsur = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "mud")); []={2, "clay")); []={3, "silt")); []={4, "sand")); []={5, "stone"));
529 []={6, "gravel")); []={7, "pebbles")); []={8, "cobbles")); []={9, "rock")); []={11, "lava")); []={14, "coral")); []={17, "shells")); []={18, "boulder")); }
530 private static final EnumMap<, S57enum> Natqua = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "fine")); []={2, "medium")); []={3, "coarse")); []={4, "broken"));
531 []={5, "sticky")); []={6, "soft")); []={7, "stiff")); []={8, "volcanic")); []={9, "calcareous")); []={10, "hard")); }
532 private static final EnumMap<, S57enum> Prodct = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "oil")); []={2, "gas")); []={3, "water")); []={4, "stone"));
533 []={5, "coal")); []={6, "ore")); []={7, "chemicals")); []={8, "drinking_water")); []={9, "milk")); []={10, "bauxite")); []={11, "coke")); []={12, "iron_ingots")); []={13, "salt"));
534 []={14, "sand")); []={15, "timber")); []={16, "sawdust")); []={17, "scrap")); []={18, "lng")); []={19, "lpg")); []={20, "wine")); []={21, "cement")); []={22, "grain")); }
535 private static final EnumMap<, S57enum> Quasou = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "known")); []={2, "unknown")); []={3, "doubtful")); []={4, "unreliable"));
536 []={5, "no_bottom_found")); []={6, "least_known")); []={7, "least_unknown")); []={8, "not_surveyed")); []={9, "not_confirmed")); []={10, "maintained"));
537 []={11, "not_maintained")); }
538 private static final EnumMap<, S57enum> Restrn = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "no_anchoring")); []={2, "restricted_anchoring")); []={3, "no_fishing"));
539 []={4, "restricted_fishing")); []={5, "no_trawling")); []={6, "restricted_trawling")); []={7, "no_entry")); []={8, "restricted_entry"));
540 []={9, "no_dredging")); []={10, "restricted_dredging")); []={11, "no_diving")); []={12, "restricted_diving")); []={13, "no_wake")); []={14, "to_be_avoided")); []={15, "no_construction"));
541 []={16, "no_discharging")); []={17, "restricted_discharging"));
542 []={18, "no_ exploration_development")); []={19, "restricted_exploration_development")); []={20, "no_drilling")); []={21, "restricted_drilling")); []={22, "no_historical_artifacts_removal"));
543 []={23, "no_lightering")); []={24, "no_dragging"));
544 []={25, "no_stopping")); []={26, "no_landing")); []={27, "restricted_speed")); []={28, "overtaking prohibited")); []={29, "overtaking of convoys by convoys prohibited"));
545 []={30, "passing or overtaking prohibited"));
546 []={31, "berthing prohibited")); []={32, "berthing restricted")); []={33, "making fast prohibited")); []={34, "making fast restricted")); []={35, "turning prohibited"));
547 []={36, "restricted fairway depth")); }
548 private static final EnumMap<, S57enum> Siggen = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "automatic")); []={2, "wave")); []={3, "hand")); []={4, "wind")); }
549 private static final EnumMap<, S57enum> Status = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "permanent")); []={2, "occasional")); []={3, "recommended"));
550 []={4, "not_in_use")); []={5, "intermittent")); []={6, "reserved")); []={7, "tempory")); []={8, "private")); []={9, "mandatory")); []={11, "extinguished"));
551 []={12, "illuminated")); []={13, "historic")); []={14, "public")); []={15, "synchronised")); []={16, "watched")); []={17, "unwatched")); []={18, "existence_doubtful"));
552 []={19, "on_request")); []={20, "drop_away")); []={21, "rising")); []={22, "increasing"));
553 []={23, "decreasing")); []={24, "strong")); []={25, "good")); []={26, "moderately")); []={27, "poor")); }
554 private static final EnumMap<, S57enum> Surtyp = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "sketch")); []={2, "controlled")); []={4, "examination"));
555 []={5, "passage")); []={6, "remote")); }
556 private static final EnumMap<, S57enum> Tecsou = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "echo-sounder")); []={2, "side-scan_sonar")); []={3, "multi-beam"));
557 []={4, "diver")); []={5, "lead-line")); []={6, "wire-drag")); []={7, "laser")); []={8, "vertical_acoustic")); []={9, "electromagnetic"));
558 []={10, "photogrammetry")); []={11, "satellite")); []={12, "levelling")); []={13, "side-scan_sonar")); []={14, "computer")); }
559 public enum TopSHP []={ TOP_UNKN, TOP_CONE, TOP_ICONE, TOP_SPHR, TOP_ISD, TOP_CAN, TOP_BORD, TOP_SALT, TOP_CROS, TOP_CUBE, TOP_WEST, TOP_EAST, TOP_RHOM,
560 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,
561 TOP_CRSS, TOP_T, TOP_TRCL, TOP_CRCL, TOP_RHCL, TOP_CLTR, TOP_OTHR }
562 private static final EnumMap<, S57enum> Topshp = new EnumMap<, S57enum>(.class); static {[TOP_UNKN]={0, "")); [TOP_CONE]={1, "cone, point up")); [TOP_ICONE]={2, "cone, point down"));
563 [TOP_SPHR]={3, "sphere")); [TOP_ISD]={4, "2 spheres")); [TOP_CAN]={5, "cylinder")); [TOP_BORD]={6, "board"));
564 [TOP_SALT]={7, "x-shape")); [TOP_CROS]={8, "cross")); [TOP_CUBE]={9, "cube, point up")); [TOP_WEST]={10, "2 cones point together")); [TOP_EAST]={11, "2 cones base together"));
565 [TOP_RHOM]={12, "rhombus"));
566 [TOP_NORTH]={13, "2 cones up")); [TOP_SOUTH]={14, "2 cones down")); [TOP_BESM]={15, "besom, point up")); [TOP_IBESM]={16, "besom, point down")); [TOP_FLAG]={17, "flag"));
567 [TOP_SPRH]={18, "sphere over rhombus"));
568 [TOP_SQUR]={19, "square")); [TOP_HRECT]={20, "rectangle, horizontal")); [TOP_VRECT]={21, "rectangle, vertical")); [TOP_TRAP]={22, "trapezium, up")); [TOP_ITRAP]={23, "trapezium, down"));
569 [TOP_TRI]={24, "triangle, point up"));
570 [TOP_ITRI]={25, "triangle, point down")); [TOP_CIRC]={26, "circle")); [TOP_CRSS]={27, "2 upright crosses")); [TOP_T]={28, "t-shape")); [TOP_TRCL]={29, "triangle, point up over circle"));
571 [TOP_CRCL]={30, "upright cross over circle"));
572 [TOP_RHCL]={31, "rhombus over circle")); [TOP_CLTR]={32, "circle over triangle, point up")); [TOP_OTHR]={33, "other")); }
573 private static final EnumMap<, S57enum> Trafic = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "inbound")); []={2, "outbbound")); []={3, "one-way")); []={4, "two-way")); }
574 private static final EnumMap<, S57enum> Watlev = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "part-submerged")); []={2, "dry")); []={3, "submerged")); []={4, "covers"));
575 []={5, "awash")); []={6, "floods")); []={7, "floating")); []={8, "above_mwl")); []={9, "below_mwl")); }
576 private static final EnumMap<, S57enum> Cat_ts = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "flood")); []={2, "ebb")); []={3, "other")); }
577 private static final EnumMap<, S57enum> Punits = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "metres")); []={2, "degrees")); []={3, "millimetres")); []={4, "feet"));
578 []={5, "cables")); }
579 private static final EnumMap<, S57enum> Quapos = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "surveyed")); []={2, "unsurveyed")); []={3, "part-surveyed"));
580 []={4, "approximate")); []={5, "doubtful")); []={6, "unreliable")); []={7, "reported_unsurveyd")); []={8, "unconfirmed")); []={9, "estimated"));
581 []={10, "precise")); []={11, "calculated")); }
582 private static final EnumMap<, S57enum> Catachi = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "unrestricted")); []={2, "deep-water")); []={3, "tanker"));
583 []={4, "explosives")); []={5, "quarantine")); []={6, "sea-plane")); []={7, "small_craft")); []={9, "24_hours")); []={10, "pushing-navigation_vessels"));
584 []={11, "non-pushing-navigation_vessels")); }
585 private static final EnumMap<, S57enum> Verdat = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "mlws")); []={2, "mllws")); []={3, "msl")); []={4, "llw"));
586 []={5, "mlw")); []={6, "llws")); []={7, "amlws")); []={8, "islw")); []={9, "lws")); []={10, "alat")); []={11, "nllw")); []={12, "mllw")); []={13, "lw")); []={14, "amlw")); []={15, "amllw"));
587 []={16, "mhw")); []={17, "mhws")); []={18, "hw")); []={19, "amsl")); []={20, "hws")); []={21, "mhhw")); []={22, "eslw")); []={23, "lat")); []={24, "local")); []={25, "igld1985"));
588 []={26, "mlw")); []={27, "llwlt")); []={28, "hhwlt")); []={29, "nhhw")); []={30, "hat"));
589 []={31, "llwrl")); []={32, "lhwrl")); []={33, "lmwrl")); []={34, "ehw_dglw")); []={35, "hshw_dhsw")); []={36, "rlwl_donau")); []={37, "hshw_donau")); []={38, "drlwrl_olr"));
590 []={39, "rpwl")); []={40, "rnbl")); []={41, "ohio_rd")); }
591 public enum AddMRK []={ MRK_UNKN, MRK_TOPB, MRK_BOTB, MRK_RTRI, MRK_LTRI, MRK_BTRI }
592 private static final EnumMap<, S57enum> Addmrk = new EnumMap<, S57enum>(.class); static {[MRK_UNKN]={0, "")); [MRK_TOPB]={1, "top_board")); [MRK_BOTB]={2, "bottom_board")); [MRK_RTRI]={3, "right_triangle")); [MRK_LTRI]={4, "left_triangle")); [MRK_BTRI]={5, "bottom_triangle")); }
593 private static final EnumMap<, S57enum> Catbnk = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "steep")); []={2, "flat")); []={3, "fastened")); []={4, "unfastened")); }
594 public enum Cat_NMK []={ NMK_UNKN, NMK_NENT, NMK_CLSA, NMK_NOVK, NMK_NCOV, NMK_NPAS, NMK_NBRT, NMK_NBLL, NMK_NANK, NMK_NMOR, NMK_NTRN, NMK_NWSH,
595 NMK_NPSL, NMK_NPSR, NMK_NMTC, NMK_NSPC, NMK_NWSK, NMK_NSLC, NMK_NUPC, NMK_NSLB, NMK_NWBK, NMK_NHSC, NMK_NLBG, NMK_MVTL, NMK_MVTR, NMK_MVTP,
596 NMK_MVTS, NMK_KPTP, NMK_KPTS, NMK_CSTP, NMK_CSTS, NMK_STOP, NMK_SPDL, NMK_SHRN, NMK_KPLO, NMK_GWJN, NMK_GWCS, NMK_MKRC, NMK_LMDP, NMK_LMHR,
597 NMK_LMWD, NMK_NAVR, NMK_CHDL, NMK_CHDR, NMK_CHTW, NMK_CHOW, NMK_OPTR, NMK_OPTL, NMK_PRTL, NMK_PRTR, NMK_ENTP, NMK_OVHC, NMK_WEIR, NMK_FERN,
598 NMK_FERI, NMK_BRTP, NMK_BTLL, NMK_BTLS, NMK_BTRL, NMK_BTUP, NMK_BTP1, NMK_BTP2, NMK_BTP3, NMK_BTUN, NMK_BTN1, NMK_BTN2, NMK_BTN3, NMK_BTUM,
599 NMK_BTU1, NMK_BTU2, NMK_BTU3, NMK_ANKP, NMK_MORP, NMK_VLBT, NMK_TRNA, NMK_SWWC, NMK_SWWR, NMK_SWWL, NMK_WRSA, NMK_WLSA, NMK_WRSL, NMK_WLSR,
600 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,
601 NMK_SLCP, NMK_UPCP, NMK_SLBP, NMK_RADI, NMK_WTBP, NMK_HSCP, NMK_LBGP }
602 private static final EnumMap<, S57enum> Catnmk = new EnumMap<, S57enum>(.class); static {[NMK_UNKN]={0, "")); [NMK_NENT]={1, "no_entry")); [NMK_CLSA]={2, "closed_area")); [NMK_NOVK]={3, "no_overtaking")); [NMK_NCOV]={4, "no_convoy_overtaking")); [NMK_NPAS]={5, "no_passing"));
603 [NMK_NBRT]={6, "no_berthing")); [NMK_NBLL]={7, "no_berthing_lateral_limit")); [NMK_NANK]={8, "no_anchoring")); [NMK_NMOR]={9, "no_mooring")); [NMK_NTRN]={10, "no_turning")); [NMK_NWSH]={11, "no_wash"));
604 [NMK_NPSL]={12, "no_passage_left")); [NMK_NPSR]={13, "no_passage_right")); [NMK_NMTC]={14, "no_motor_craft")); [NMK_NSPC]={15, "no_sports_craft")); [NMK_NWSK]={16, "no_waterskiing")); [NMK_NSLC]={17, "no_sailing_craft"));
605 [NMK_NUPC]={18, "no_unpowered_craft")); [NMK_NSLB]={19, "no_sailboards")); [NMK_NWBK]={20, "no_waterbikes")); [NMK_NHSC]={21, "no_high_speeds")); [NMK_NLBG]={22, "no_launching_beaching")); [NMK_MVTL]={23, "move_to_left"));
606 [NMK_MVTR]={24, "move_to_right")); [NMK_MVTP]={25, "move_to_port")); [NMK_MVTS]={26, "move_to_starboard")); [NMK_KPTP]={27, "keep_to_port")); [NMK_KPTS]={28, "keep_to_starboard")); [NMK_CSTP]={29, "cross_to_port"));
607 [NMK_CSTS]={30, "cross_to_starboard")); [NMK_STOP]={31, "stop")); [NMK_SPDL]={32, "speed_limit")); [NMK_SHRN]={33, "sound_horn")); [NMK_KPLO]={34, "keep_lookout")); [NMK_GWJN]={35, "give_way_junction"));
608 [NMK_GWCS]={36, "give_way_crossing")); [NMK_MKRC]={37, "make_radio_contact")); [NMK_LMDP]={38, "limited_depth")); [NMK_LMHR]={39, "limited_headroom")); [NMK_LMWD]={40, "limited_width")); [NMK_NAVR]={41, "navigation_restrictions"));
609 [NMK_CHDL]={42, "channel_distance_left")); [NMK_CHDR]={43, "channel_distance_right")); [NMK_CHTW]={44, "channel_two_way")); [NMK_CHOW]={45, "channel_one_way")); [NMK_OPTR]={46, "opening_to_right"));
610 [NMK_OPTL]={47, "opening_to_left")); [NMK_PRTL]={48, "proceed_to_left")); [NMK_PRTR]={49, "proceed_to_right")); [NMK_ENTP]={50, "entry_permitted")); [NMK_OVHC]={51, "overhead_cable")); [NMK_WEIR]={52, "weir"));
611 [NMK_FERN]={53, "ferry_non_independent")); [NMK_FERI]={54, "ferry_independent")); [NMK_BRTP]={55, "berthing_permitted")); [NMK_BTLL]={56, "berthing_lateral_limit")); [NMK_BTLS]={57, "berthing_lateral_limits"));
612 [NMK_BTRL]={58, "berth_rafting_limit")); [NMK_BTUP]={59, "berthing_unmarked_pushing")); [NMK_BTP1]={60, "berthing_marked_pushing_1")); [NMK_BTP2]={61, "berthing_marked_pushing_2")); [NMK_BTP3]={62, "berthing_marked_pushing_3"));
613 [NMK_BTUN]={63, "berthing_unmarked_non-pushing")); [NMK_BTN1]={64, "berthing_marked_non-pushing_1")); [NMK_BTN2]={65, "berthing_marked_non-pushing_2")); [NMK_BTN3]={66, "berthing_marked_non-pushing_3"));
614 [NMK_BTUM]={67, "berthing_unmarked")); [NMK_BTU1]={68, "berthing_marked_1")); [NMK_BTU2]={69, "berthing_marked_2")); [NMK_BTU3]={70, "berthing_marked_3")); [NMK_ANKP]={71, "anchoring_permitted"));[NMK_MORP]={72, "mooring_permitted"));
615 [NMK_VLBT]={73, "vehicle_loading_berth")); [NMK_TRNA]={74, "turning_area")); [NMK_SWWC]={75, "secondary_waterway_crossing")); [NMK_SWWR]={76, "secondary_waterway_right")); [NMK_SWWL]={77, "secondary_waterway_left"));
616 [NMK_WRSA]={78, "main_waterway_right_secondary_ahead")); [NMK_WLSA]={79, "main_waterway_left_secondary_ahead")); [NMK_WRSL]={80, "main_waterway_right_secondary_left")); [NMK_WLSR]={81, "main_waterway_left_secondary_right"));
617 [NMK_WRAL]={82, "main_waterway_right_secondary_ahead_left")); [NMK_WLAR]={83, "main_waterway_left_secondary waterway_ahead_right")); [NMK_MWWC]={84, "main_waterway_crossing")); [NMK_MWWJ]={85, "main_waterway_junction"));
618 [NMK_MWAR]={86, "main_waterway_ahead_right")); [NMK_MWAL]={87, "main_waterway_ahead_left")); [NMK_WARL]={88, "main_waterway_ahead_right_secondary_left")); [NMK_WALR]={89, "main_waterway_ahead_left_secondary_right"));
619 [NMK_PEND]={90, "prohibition_ends")); [NMK_DWTR]={91, "drinking_water")); [NMK_TELE]={92, "telephone")); [NMK_MTCP]={93, "motor_craft_permitted")); [NMK_SPCP]={94, "sport_craft_permitted")); [NMK_WSKP]={95, "waterskiing_permitted"));
620 [NMK_SLCP]={96, "sailing_craft_permitted")); [NMK_UPCP]={97, "unpowered_craft_permitted")); [NMK_SLBP]={98, "sailboards_permitted")); [NMK_RADI]={99, "radio_information"));
621 [NMK_WTBP]={100, "waterbikes_permitted")); [NMK_HSCP]={101, "high_speeds_permitted")); [NMK_LBGP]={102, "launching_beaching_permitted")); }
622 private static final EnumMap<, S57enum> Clsdng = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "one_blue")); []={2, "two_blue")); []={3, "three_blue")); []={4, "no_blue")); }
623 private static final EnumMap<, S57enum> Dirimp = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "upstream")); []={2, "downstream")); []={3, "left_bank")); []={4, "right_bank")); []={5, "to_harbour")); }
624 private static final EnumMap<, S57enum> Fnctnm = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "prohibition")); []={2, "regulation")); []={3, "restriction"));
625 []={4, "recommendation")); []={5, "information")); }
626 private static final EnumMap<, S57enum> Bunves = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "bunker_vessel_available")); []={2, "no_bunker_vessel_available")); }
627 private static final EnumMap<, S57enum> Catbrt = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "loading")); []={2, "unloading")); []={3, "overnight_accommodation"));
628 []={4, "pushing-navigation")); []={5, "non-pushing-navigation")); []={6, "fleeting")); []={7, "first_class")); []={8, "second_class")); }
629 private static final EnumMap<, S57enum> Catbun = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "diesel oil")); []={2, "water")); []={3, "ballast")); }
630 private static final EnumMap<, S57enum> Catccl = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "small_vessels")); []={2, "peniche")); []={3, "campine_barge"));
631 []={4, "dortmund-ems_barge")); []={5, "rhine-herne_barge")); []={6, "1-barge_push-tow"));
632 []={7, "2-barge_push-tow_long")); []={8, "2-barge_push-tow_wide")); []={9, "4-barge_push-tow")); []={10, "6-barge_push-tow")); []={11, "no_cemt_class")); }
633 private static final EnumMap<, S57enum> Catcom = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "vts_centre")); []={2, "vts_sector")); []={3, "ivs_point")); []={4, "mid")); []={5, "lock")); []={6, "bridge")); []={7, "custom")); []={8, "harbour")); }
634 private static final EnumMap<, S57enum> Cathbr = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "custom")); []={2, "refuge")); []={3, "marina")); []={4, "fishing")); []={5, "private")); }
635 private static final EnumMap<, S57enum> Catrfd = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "cargo_residue")); []={2, "waste_oil")); []={3, "grey_black_water")); []={4, "domestic_refuse")); }
636 private static final EnumMap<, S57enum> Cattml = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "passenger")); []={2, "ferry")); []={3, "transhipment")); []={4, "roro")); }
637 private static final EnumMap<, S57enum> Trshgd = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "containers")); []={2, "bulk")); []={3, "oil")); []={4, "fuel"));
638 []={5, "chemicals")); []={6, "liquid")); []={7, "explosive")); []={8, "fish")); []={9, "cars")); []={10, "general")); }
639 private static final EnumMap<, S57enum> Catgag = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "staff")); []={2, "recording")); []={3, "recording_remote_access"));
640 []={4, "recording_external_indiCator")); []={5, "recording_remote_access_indiCator")); }
641 private static final EnumMap<, S57enum> Reflev = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "baltic")); []={2, "adriatic")); []={3, "amsterdam")); []={4, "msl"));
642 []={5, "other")); []={6, "ngvd29")); []={7, "navd88")); []={8, "msl1912")); []={9, "msl1929")); }
643 private static final EnumMap<, S57enum> Catvtr = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "official")); []={2, "private")); []={3, "car_cranes")); []={4, "car_planks")); []={5, "permission_required")); []={6, "locked_gate")); }
644 private static final EnumMap<, S57enum> Cattab = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "operational_period")); []={2, "non-operational_period")); }
645 private static final EnumMap<, S57enum> Useshp = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "liner_trade")); []={2, "occasional_professional_shipping")); []={3, "leisure")); }
646 private static final EnumMap<, S57enum> Catexs = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "lift-lock")); []={2, "aqueduct")); []={3, "sloping_plane_lock"));
647 []={4, "water_slope_lock")); []={5, "other")); }
648 private static final EnumMap<, S57enum> Catwwm = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "waterway_right")); []={2, "waterway_left")); []={3, "waterway_separation"));
649 []={4, "channel_right")); []={5, "channel_left")); []={6, "channel_separation")); []={7, "channel_right_bank")); []={8, "channel_left_bank"));
650 []={9, "crossover_right")); []={10, "crossover_left")); []={11, "danger_right")); []={12, "danger_left")); []={13, "turnoff_right")); []={14, "turnoff_left")); []={15, "junction_right"));
651 []={16, "junction_left")); []={17, "harbour_right"));
652 []={18, "harbour_left")); []={19, "bridge_pier")); }
653 private static final EnumMap<, S57enum> Lg_spr = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "other")); []={2, "speed_over_ground")); []={3, "speed_through_water")); }
654 private static final EnumMap<, S57enum> Lg_wdu = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "other")); []={2, "cubic_metres")); []={3, "tonnes")); }
655 private static final EnumMap<, S57enum> Lg_rel = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "other")); []={2, "usage_of_waterway")); []={3, "carriage_of_equipment"));
656 []={4, "task_operation")); }
657 private static final EnumMap<, S57enum> Lg_fnc = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "other")); []={2, "prohibited")); []={3, "prohibited_with_exceptions"));
658 []={4, "permitted")); []={5, "permitted_with_exceptions")); []={6, "recommended")); []={7, "not_recommended")); }
659 private static final EnumMap<, S57enum> Lc_csi = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "all")); []={2, "other")); []={3, "non-motorized")); []={5, "craft"));
660 []={6, "vessel")); []={7, "inland_waterway")); []={8, "sea-going")); []={9, "motor")); []={10, "motor_tanker")); []={11, "motor_cargo")); []={12, "canal_barge"));
661 []={13, "tug")); []={14, "pusher")); []={15, "barge")); []={16, "tank_barge")); []={17, "dumb_barge")); []={18, "lighter")); []={19, "tank_lighter")); []={20, "cargo_lighter"));
662 []={21, "ship_borne_lighter")); []={22, "passenger")); []={23, "passenger_sailing"));
663 []={24, "day_trip")); []={25, "cabin")); []={26, "high-speed")); []={27, "floating_equipment")); []={28, "worksite")); []={29, "recreational")); []={30, "dinghy"));
664 []={31, "floating_establishment")); []={32, "floating_object")); }
665 private static final EnumMap<, S57enum> Lc_cse = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "all")); []={2, "other")); []={3, "non-motorized")); []={5, "craft"));
666 []={6, "vessel")); []={7, "inland_waterway")); []={8, "sea-going")); []={9, "motor")); []={10, "motor_tanker")); []={11, "motor_cargo")); []={12, "canal_barge"));
667 []={13, "tug")); []={14, "pusher")); []={15, "barge")); []={16, "tank_barge")); []={17, "dumb_barge")); []={18, "lighter")); []={19, "tank_lighter")); []={20, "cargo_lighter"));
668 []={21, "ship_borne_lighter")); []={22, "passenger")); []={23, "passenger_sailing"));
669 []={24, "day_trip")); []={25, "cabin")); []={26, "high-speed")); []={27, "floating_equipment")); []={28, "worksite")); []={29, "recreational")); []={30, "dinghy"));
670 []={31, "floating_establishment")); []={32, "floating_object")); }
671 private static final EnumMap<, S57enum> Lc_asi = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "all")); []={2, "other")); []={3, "single")); []={5, "convoy"));
672 []={6, "formation")); []={7, "rigid_convoy")); []={8, "pushed_convoy")); []={9, "breasted")); []={10, "towed_convoy")); }
673 private static final EnumMap<, S57enum> Lc_ase = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "all")); []={2, "other")); []={3, "single")); []={5, "convoy"));
674 []={6, "formation")); []={7, "rigid_convoy")); []={8, "pushed_convoy")); []={9, "breasted")); []={10, "towed_convoy")); }
675 private static final EnumMap<, S57enum> Lc_cci = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "all")); []={2, "other")); []={4, "bulk")); []={5, "dry"));
676 []={6, "liquid")); []={7, "liquid_n")); []={8, "liquid_c")); []={9, "gas")); }
677 private static final EnumMap<, S57enum> Lc_cce = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "all")); []={2, "other")); []={4, "bulk")); []={5, "dry"));
678 []={6, "liquid")); []={7, "liquid_n")); []={8, "liquid_c")); []={9, "gas")); }
679 private static final EnumMap<, S57enum> Shptyp = new EnumMap<, S57enum>(.class); static { []={0, "")); []={1, "cargo")); []={2, "container")); []={3, "tanker")); []={4, "sailing"));
680 []={5, "fishing")); []={6, "special_purpose.")); []={7, "man_of_war")); []={8, "submarine")); []={9, "high-speed")); []={10, "bulk_carrier"));
681 []={11, "seaplane")); []={12, "tugboat")); []={13, "passenger")); []={14, "ferry")); []={15, "boat")); }
682*/
683 private static final EnumMap<Att, S57key> keys = new EnumMap<Att, S57key>(Att.class);
684 static {
685 keys.put(Att.UNKATT, new S57key(Conv.A, null)); keys.put(Att.AGENCY, new S57key(Conv.A, null)); keys.put(Att.BCNSHP, new S57key(Conv.E, Bcnshp));
686 keys.put(Att.BUISHP, new S57key(Conv.E, Buishp)); keys.put(Att.BOYSHP, new S57key(Conv.E, Boyshp)); keys.put(Att.BURDEP, new S57key(Conv.F, null));
687 keys.put(Att.CALSGN, new S57key(Conv.S, null)); keys.put(Att.CATAIR, new S57key(Conv.L, Catair)); keys.put(Att.CATACH, new S57key(Conv.L, Catach));
688 keys.put(Att.CATBRG, new S57key(Conv.L, Catbrg)); keys.put(Att.CATBUA, new S57key(Conv.E, Catbua)); keys.put(Att.CATCBL, new S57key(Conv.E, Catcbl));
689 keys.put(Att.CATCAN, new S57key(Conv.E, Catcan)); keys.put(Att.CATCAM, new S57key(Conv.E, Catcam)); keys.put(Att.CATCHP, new S57key(Conv.E, Catchp));
690 keys.put(Att.CATCOA, new S57key(Conv.E, Catcoa)); keys.put(Att.CATCTR, new S57key(Conv.E, Catctr)); keys.put(Att.CATCON, new S57key(Conv.E, Catcon));
691 keys.put(Att.CATCOV, new S57key(Conv.E, Catcov)); keys.put(Att.CATCRN, new S57key(Conv.E, Catcrn)); keys.put(Att.CATDAM, new S57key(Conv.E, Catdam));
692 keys.put(Att.CATDIS, new S57key(Conv.E, Catdis)); keys.put(Att.CATDOC, new S57key(Conv.E, Catdoc)); keys.put(Att.CATDPG, new S57key(Conv.L, Catdpg));
693 keys.put(Att.CATFNC, new S57key(Conv.E, Catfnc)); keys.put(Att.CATFRY, new S57key(Conv.E, Catfry)); keys.put(Att.CATFIF, new S57key(Conv.E, Catfif));
694 keys.put(Att.CATFOG, new S57key(Conv.E, Catfog)); keys.put(Att.CATFOR, new S57key(Conv.E, Catfor)); keys.put(Att.CATGAT, new S57key(Conv.E, Catgat));
695 keys.put(Att.CATHAF, new S57key(Conv.L, Cathaf)); keys.put(Att.CATHLK, new S57key(Conv.L, Cathlk)); keys.put(Att.CATICE, new S57key(Conv.E, Catice));
696 keys.put(Att.CATINB, new S57key(Conv.E, Catinb)); keys.put(Att.CATLND, new S57key(Conv.L, Catlnd)); keys.put(Att.CATLMK, new S57key(Conv.L, Catlmk));
697 keys.put(Att.CATLAM, new S57key(Conv.E, Catlam)); keys.put(Att.CATLIT, new S57key(Conv.L, Catlit)); keys.put(Att.CATMFA, new S57key(Conv.E, Catmfa));
698 keys.put(Att.CATMPA, new S57key(Conv.L, Catmpa)); keys.put(Att.CATMOR, new S57key(Conv.E, Catmor)); keys.put(Att.CATNAV, new S57key(Conv.E, Catnav));
699 keys.put(Att.CATOBS, new S57key(Conv.E, Catobs)); keys.put(Att.CATOFP, new S57key(Conv.L, Catofp)); keys.put(Att.CATOLB, new S57key(Conv.E, Catolb));
700 keys.put(Att.CATPLE, new S57key(Conv.E, Catple)); keys.put(Att.CATPIL, new S57key(Conv.E, Catpil)); keys.put(Att.CATPIP, new S57key(Conv.L, Catpip));
701 keys.put(Att.CATPRA, new S57key(Conv.E, Catpra)); keys.put(Att.CATPYL, new S57key(Conv.E, Catpyl)); keys.put(Att.CATQUA, new S57key(Conv.E, Catqua));
702 keys.put(Att.CATRAS, new S57key(Conv.E, Catras)); keys.put(Att.CATRTB, new S57key(Conv.E, Catrtb)); keys.put(Att.CATROS, new S57key(Conv.L, Catros));
703 keys.put(Att.CATTRK, new S57key(Conv.E, Cattrk)); keys.put(Att.CATRSC, new S57key(Conv.L, Catrsc)); keys.put(Att.CATREA, new S57key(Conv.L, Catrea));
704 keys.put(Att.CATROD, new S57key(Conv.E, Catrod)); keys.put(Att.CATRUN, new S57key(Conv.E, Catrun)); keys.put(Att.CATSEA, new S57key(Conv.E, Catsea));
705 keys.put(Att.CATSIL, new S57key(Conv.E, Catsil)); keys.put(Att.CATSLO, new S57key(Conv.E, Catslo)); keys.put(Att.CATSCF, new S57key(Conv.L, Catscf));
706 keys.put(Att.CATSLC, new S57key(Conv.E, Catslc)); keys.put(Att.CATSIT, new S57key(Conv.L, Catsit)); keys.put(Att.CATSIW, new S57key(Conv.L, Catsiw));
707 keys.put(Att.CATSPM, new S57key(Conv.L, Catspm)); keys.put(Att.CATTSS, new S57key(Conv.E, Cattss)); keys.put(Att.CATVEG, new S57key(Conv.L, Catveg));
708 /*
709 keys.put(Att.CATWAT, new S57key(Conv.E, Catwat)); keys.put(Att.CATWED, new S57key(Conv.E, Catwed)); keys.put(Att.CATWRK, new S57key(Conv.E, Catwrk));
710 keys.put(Att.CATZOC, new S57key(Conv.E, Catzoc)); keys.put(Att.$SPACE, new S57key(Conv.E, null)); keys.put(Att.$CHARS, new S57key(Conv.A, null));
711 keys.put(Att.COLOUR, new S57key(Conv.L, Colour)); keys.put(Att.COLPAT, new S57key(Conv.L, Colpat)); keys.put(Att.COMCHA, new S57key(Conv.A, null));
712 keys.put(Att.$CSIZE, new S57key(Conv.F, null)); keys.put(Att.CPDATE, new S57key(Conv.A, null)); keys.put(Att.CSCALE, new S57key(Conv.I, null));
713 keys.put(Att.CONDTN, new S57key(Conv.E, Condtn)); keys.put(Att.CONRAD, new S57key(Conv.E, Conrad)); keys.put(Att.CONVIS, new S57key(Conv.E, Convis));
714 keys.put(Att.CURVEL, new S57key(Conv.F, null)); keys.put(Att.DATEND, new S57key(Conv.A, null)); keys.put(Att.DATSTA, new S57key(Conv.A, null));
715 keys.put(Att.DRVAL1, new S57key(Conv.F, null)); keys.put(Att.DRVAL2, new S57key(Conv.F, null)); keys.put(Att.DUNITS, new S57key(Conv.E, Dunits));
716 keys.put(Att.ELEVAT, new S57key(Conv.F, null)); keys.put(Att.ESTRNG, new S57key(Conv.F, null)); keys.put(Att.EXCLIT, new S57key(Conv.E, Exclit));
717 keys.put(Att.EXPSOU, new S57key(Conv.E, Expsou)); keys.put(Att.FUNCTN, new S57key(Conv.L, Functn)); keys.put(Att.HEIGHT, new S57key(Conv.A, null));
718 keys.put(Att.HUNITS, new S57key(Conv.E, Hunits)); keys.put(Att.HORACC, new S57key(Conv.F, null)); keys.put(Att.HORCLR, new S57key(Conv.F, null));
719 keys.put(Att.HORLEN, new S57key(Conv.F, null)); keys.put(Att.HORWID, new S57key(Conv.F, null)); keys.put(Att.ICEFAC, new S57key(Conv.F, null));
720 keys.put(Att.INFORM, new S57key(Conv.S, null)); keys.put(Att.JRSDTN, new S57key(Conv.E, Jrsdtn)); keys.put(Att.$JUSTH, new S57key(Conv.E, null));
721 keys.put(Att.$JUSTV, new S57key(Conv.E, null)); keys.put(Att.LIFCAP, new S57key(Conv.F, null)); keys.put(Att.LITCHR, new S57key(Conv.E, Litchr));
722 keys.put(Att.LITVIS, new S57key(Conv.L, Litvis)); keys.put(Att.MARSYS, new S57key(Conv.E, Marsys)); keys.put(Att.MLTYLT, new S57key(Conv.I, null));
723 keys.put(Att.NATION, new S57key(Conv.A, null)); keys.put(Att.NATCON, new S57key(Conv.L, Natcon)); keys.put(Att.NATSUR, new S57key(Conv.L, Natsur));
724 keys.put(Att.NATQUA, new S57key(Conv.L, Natqua)); keys.put(Att.NMDATE, new S57key(Conv.A, null)); keys.put(Att.OBJNAM, new S57key(Conv.S, null));
725 keys.put(Att.ORIENT, new S57key(Conv.F, null)); keys.put(Att.PEREND, new S57key(Conv.A, null)); keys.put(Att.PERSTA, new S57key(Conv.A, null));
726 keys.put(Att.PICREP, new S57key(Conv.S, null)); keys.put(Att.PILDST, new S57key(Conv.S, null)); keys.put(Att.PRCTRY, new S57key(Conv.A, null));
727 keys.put(Att.PRODCT, new S57key(Conv.L, Prodct)); keys.put(Att.PUBREF, new S57key(Conv.S, null)); keys.put(Att.QUASOU, new S57key(Conv.L, Quasou));
728 keys.put(Att.RADWAL, new S57key(Conv.A, null)); keys.put(Att.RADIUS, new S57key(Conv.F, null)); keys.put(Att.RECDAT, new S57key(Conv.A, null));
729 keys.put(Att.RECIND, new S57key(Conv.A, null)); keys.put(Att.RYRMGV, new S57key(Conv.A, null)); keys.put(Att.RESTRN, new S57key(Conv.L, Restrn));
730 keys.put(Att.SCAMAX, new S57key(Conv.I, null)); keys.put(Att.SCAMIN, new S57key(Conv.I, null)); keys.put(Att.SCVAL1, new S57key(Conv.I, null));
731 keys.put(Att.SCVAL2, new S57key(Conv.I, null)); keys.put(Att.SECTR1, new S57key(Conv.F, null)); keys.put(Att.SECTR2, new S57key(Conv.F, null));
732 keys.put(Att.SHIPAM, new S57key(Conv.A, null)); keys.put(Att.SIGFRQ, new S57key(Conv.I, null)); keys.put(Att.SIGGEN, new S57key(Conv.E, Siggen));
733 keys.put(Att.SIGGRP, new S57key(Conv.A, null)); keys.put(Att.SIGPER, new S57key(Conv.F, null)); keys.put(Att.SIGSEQ, new S57key(Conv.A, null));
734 keys.put(Att.SOUACC, new S57key(Conv.F, null)); keys.put(Att.SDISMX, new S57key(Conv.I, null)); keys.put(Att.SDISMN, new S57key(Conv.I, null));
735 keys.put(Att.SORDAT, new S57key(Conv.A, null)); keys.put(Att.SORIND, new S57key(Conv.A, null)); keys.put(Att.STATUS, new S57key(Conv.L, Status));
736 keys.put(Att.SURATH, new S57key(Conv.S, null)); keys.put(Att.SUREND, new S57key(Conv.A, null)); keys.put(Att.SURSTA, new S57key(Conv.A, null));
737 keys.put(Att.SURTYP, new S57key(Conv.L, Surtyp)); keys.put(Att.$SCALE, new S57key(Conv.F, null)); keys.put(Att.$SCODE, new S57key(Conv.A, null));
738 keys.put(Att.TECSOU, new S57key(Conv.L, Tecsou)); keys.put(Att.$TXSTR, new S57key(Conv.S, null)); keys.put(Att.TXTDSC, new S57key(Conv.S, null));
739 keys.put(Att.TS_TSP, new S57key(Conv.A, null)); keys.put(Att.TS_TSV, new S57key(Conv.A, null)); keys.put(Att.T_ACWL, new S57key(Conv.E, null));
740 keys.put(Att.T_HWLW, new S57key(Conv.A, null)); keys.put(Att.T_MTOD, new S57key(Conv.E, null)); keys.put(Att.T_THDF, new S57key(Conv.A, null));
741 keys.put(Att.T_TINT, new S57key(Conv.I, null)); keys.put(Att.T_TSVL, new S57key(Conv.A, null)); keys.put(Att.T_VAHC, new S57key(Conv.A, null));
742 keys.put(Att.TIMEND, new S57key(Conv.A, null)); keys.put(Att.TIMSTA, new S57key(Conv.A, null)); keys.put(Att.$TINTS, new S57key(Conv.E, null));
743 keys.put(Att.TOPSHP, new S57key(Conv.E, Topshp)); keys.put(Att.TRAFIC, new S57key(Conv.E, Trafic)); keys.put(Att.VALACM, new S57key(Conv.F, null));
744 keys.put(Att.VALDCO, new S57key(Conv.F, null)); keys.put(Att.VALLMA, new S57key(Conv.F, null)); keys.put(Att.VALMAG, new S57key(Conv.F, null));
745 keys.put(Att.VALMXR, new S57key(Conv.F, null)); keys.put(Att.VALNMR, new S57key(Conv.F, null)); keys.put(Att.VALSOU, new S57key(Conv.F, null));
746 keys.put(Att.VERACC, new S57key(Conv.F, null)); keys.put(Att.VERCLR, new S57key(Conv.F, null)); keys.put(Att.VERCCL, new S57key(Conv.F, null));
747 keys.put(Att.VERCOP, new S57key(Conv.F, null)); keys.put(Att.VERCSA, new S57key(Conv.F, null)); keys.put(Att.VERDAT, new S57key(Conv.E, null));
748 keys.put(Att.VERLEN, new S57key(Conv.F, null)); keys.put(Att.WATLEV, new S57key(Conv.E, Watlev)); keys.put(Att.CAT_TS, new S57key(Conv.E, Cat_ts));
749 keys.put(Att.PUNITS, new S57key(Conv.E, Punits)); keys.put(Att.NINFOM, new S57key(Conv.S, null)); keys.put(Att.NOBJNM, new S57key(Conv.S, null));
750 keys.put(Att.NPLDST, new S57key(Conv.S, null)); keys.put(Att.$NTXST, new S57key(Conv.S, null)); keys.put(Att.NTXTDS, new S57key(Conv.S, null));
751 keys.put(Att.HORDAT, new S57key(Conv.E, null)); keys.put(Att.POSACC, new S57key(Conv.F, null)); keys.put(Att.QUAPOS, new S57key(Conv.E, Quapos));
752 keys.put(Att.CLSDNG, new S57key(Conv.E, Clsdng)); keys.put(Att.DIRIMP, new S57key(Conv.L, Dirimp)); keys.put(Att.DISBK1, new S57key(Conv.F, null));
753 keys.put(Att.DISBK2, new S57key(Conv.F, null)); keys.put(Att.DISIPU, new S57key(Conv.F, null)); keys.put(Att.DISIPD, new S57key(Conv.F, null));
754 keys.put(Att.ELEVA1, new S57key(Conv.F, null)); keys.put(Att.ELEVA2, new S57key(Conv.F, null)); keys.put(Att.FNCTNM, new S57key(Conv.E, Fnctnm));
755 keys.put(Att.WTWDIS, new S57key(Conv.F, null)); keys.put(Att.BUNVES, new S57key(Conv.E, Bunves)); keys.put(Att.COMCTN, new S57key(Conv.S, null));
756 keys.put(Att.HORCLL, new S57key(Conv.F, null)); keys.put(Att.HORCLW, new S57key(Conv.F, null)); keys.put(Att.TRSHGD, new S57key(Conv.L, Trshgd));
757 keys.put(Att.UNLOCD, new S57key(Conv.S, null)); keys.put(Att.HIGWAT, new S57key(Conv.F, null)); keys.put(Att.HIGNAM, new S57key(Conv.S, null));
758 keys.put(Att.LOWWAT, new S57key(Conv.F, null)); keys.put(Att.LOWNAM, new S57key(Conv.S, null)); keys.put(Att.MEAWAT, new S57key(Conv.F, null));
759 keys.put(Att.MEANAM, new S57key(Conv.S, null)); keys.put(Att.OTHWAT, new S57key(Conv.F, null)); keys.put(Att.OTHNAM, new S57key(Conv.S, null));
760 keys.put(Att.REFLEV, new S57key(Conv.E, Reflev)); keys.put(Att.SDRLEV, new S57key(Conv.S, null)); keys.put(Att.VCRLEV, new S57key(Conv.S, null));
761 keys.put(Att.SCHREF, new S57key(Conv.S, null)); keys.put(Att.USESHP, new S57key(Conv.E, Useshp)); keys.put(Att.CURVHW, new S57key(Conv.F, null));
762 keys.put(Att.CURVLW, new S57key(Conv.F, null)); keys.put(Att.CURVMW, new S57key(Conv.F, null)); keys.put(Att.CURVOW, new S57key(Conv.F, null));
763 keys.put(Att.APTREF, new S57key(Conv.S, null)); keys.put(Att.SHPTYP, new S57key(Conv.E, Shptyp)); keys.put(Att.UPDMSG, new S57key(Conv.S, null));
764 keys.put(Att.ADDMRK, new S57key(Conv.L, Addmrk)); keys.put(Att.CATBNK, new S57key(Conv.E, Catbnk)); keys.put(Att.CATNMK, new S57key(Conv.E, Catnmk));
765 keys.put(Att.CATBRT, new S57key(Conv.L, Catbrt)); keys.put(Att.CATBUN, new S57key(Conv.L, Catbun)); keys.put(Att.CATCCL, new S57key(Conv.L, Catccl));
766 keys.put(Att.CATCOM, new S57key(Conv.L, Catcom)); keys.put(Att.CATHBR, new S57key(Conv.L, Cathbr)); keys.put(Att.CATRFD, new S57key(Conv.L, Catrfd));
767 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));
768 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));
769 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));
770 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));
771 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));
772 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));
773 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));
774 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));
775 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));
776 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));
777 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));
778 keys.put(Att.LITRAD, new S57key(Conv.A, null));
779*/
780 }
781
782 public static String decodeValue(String val, Integer attl) { // Convert S57 attribute value string to OSeaM attribute value string
783 Att att = S57att.lookupAttribute(attl);
784 switch (keys.get(att).conv) {
785 case A:
786 case S:
787 return val;
788 case E:
789 case L:
790 return (String)(keys.get(att).map).get(val);
791 case I:
792 return (Integer.valueOf(val.trim())).toString();
793 case F:
794 return (Float.valueOf(val.trim())).toString();
795 }
796 return "";
797 }
798
799 public static Integer encodeValue(String val, Att att) { // Convert OSeaM attribute value string to S57 attribute value
800 EnumMap map = keys.get(att).map;
801 for (Object item : map.keySet()) {
802 if (((S57enum)map.get(item)).val.equals(val))
803 return ((S57enum)map.get(item)).atvl;
804 }
805 return 0;
806 }
807
808
809 public static String stringValue(AttVal attval) { // Convert OSeaM value struct to OSeaM attribute value string
810 switch (attval.conv) {
811 case A:
812 case S:
813 return (String)attval.val;
814 case E:
815 return (String)((EnumMap)attval.val).get(attval.att);
816 case L:
817 String str = "";
818 for (Object item : (ArrayList)attval.val) {
819 if (!str.isEmpty()) str += ";";
820 str += keys.get(attval.att).map.get(item);
821 }
822 return str;
823 case I:
824 return ((Integer)attval.val).toString();
825 case F:
826 return ((Float)attval.val).toString();
827 }
828 return "";
829 }
830
831 public static Enum enumValue(String val, Att att) { // Convert OSeaM attribute value string to OSeaM enumeration
832 EnumMap map = keys.get(att).map;
833 Enum unkn = null;
834 for (Object item : map.keySet()) {
835 if (unkn == null) unkn = (Enum)item;
836 if (((S57enum)map.get(item)).val.equals(val))
837 return (Enum)item;
838 }
839 return unkn;
840 }
841
842 public static AttVal convertValue(String val, Att att) { // Convert OSeaM attribute value string to OSeaM value struct
843 switch (keys.get(att).conv) {
844 case A:
845 case S:
846 return new AttVal(att, keys.get(att).conv, val);
847 case E:
848 return new AttVal(att, keys.get(att).conv, enumValue(val, att));
849 case L:
850 ArrayList list = new ArrayList();
851 for (String item : val.split(";")) {
852 list.add(enumValue(item, att));
853 }
854 return new AttVal(att, keys.get(att).conv, list);
855 case I:
856 return new AttVal(att, keys.get(att).conv, Integer.parseInt(val));
857 case F:
858 return new AttVal(att, keys.get(att).conv, Float.parseFloat(val));
859 }
860 return new AttVal(att, keys.get(att).conv, null);
861 }
862
863}
Note: See TracBrowser for help on using the repository browser.