rename Map to BWEMMap to avoid collision with stdlib

JasperGeurtz · Bytekeeper · commit 448d1cbc5151 · 2019-04-08T21:29:57.000+02:00
diff --git a/src/main/java/bwapi/Game.java b/src/main/java/bwapi/Game.java
@@ -679,7 +679,7 @@ public boolean canBuildHere(final TilePosition position, final UnitType type, fi
                 position;
         final TilePosition rb = lt.add(type.tileSize());
 
-        // Map limit check
+        // BWEMMap limit check
         if (!lt.isValid(this) || !(rb.toPosition().subtract(new Position(1, 1)).isValid(this))) {
             return false;
         }
diff --git a/src/main/java/bwem/AreaInitializer.java b/src/main/java/bwem/AreaInitializer.java
@@ -30,10 +30,10 @@ class AreaInitializer extends Area {
     private static final StaticMarkable staticMarkable = new StaticMarkable();
     private final Markable markable;
 
-    private final Map map;
+    private final BWEMMap map;
 
     AreaInitializer(
-        final Map map, final AreaId areaId, final WalkPosition top, final int miniTileCount) {
+            final BWEMMap map, final AreaId areaId, final WalkPosition top, final int miniTileCount) {
         super(areaId, top, miniTileCount);
 
         this.map = map;
diff --git a/src/main/java/bwem/BWEM.java b/src/main/java/bwem/BWEM.java
@@ -15,16 +15,16 @@
 import bwapi.Game;
 
 public final class BWEM {
-    private final Map map;
+    private final BWEMMap map;
 
     public BWEM(final Game game) {
-        this.map = new MapInitializer(game);
+        this.map = new BWEMMapInitializer(game);
     }
 
     /**
      * Returns the root internal data container.
      */
-    public Map getMap() {
+    public BWEMMap getMap() {
         return this.map;
     }
 
@@ -33,10 +33,10 @@ public Map getMap() {
      * Initializes and pre-computes all of the internal data.
      */
     public void initialize() {
-        if (!(this.map instanceof MapInitializer)) {
+        if (!(this.map instanceof BWEMMapInitializer)) {
             throw new IllegalStateException("BWEM was not instantiated properly.");
         }
-        ((MapInitializer) this.map).initialize();
+        ((BWEMMapInitializer) this.map).initialize();
         this.map.assignStartingLocationsToSuitableBases();
     }
 }
diff --git a/src/main/java/bwem/BWEMMap.java b/src/main/java/bwem/BWEMMap.java
@@ -22,7 +22,7 @@
 
 import static bwem.AreaId.UNINITIALIZED;
 
-public abstract class Map {
+public abstract class BWEMMap {
 
     final List<Pair<Pair<AreaId, AreaId>, WalkPosition>> rawFrontier =
             new ArrayList<>();
@@ -38,7 +38,7 @@ public abstract class Map {
     NeutralData neutralData = null;
     Altitude highestAltitude;
 
-    Map(final Game game) {
+    BWEMMap(final Game game) {
         this.game = game;
         this.players = game.getPlayers();
         this.mineralPatches = game.getMinerals();
@@ -204,7 +204,7 @@ public Area getMainArea(final TilePosition topLeft, final TilePosition size) {
         //        //----------------------------------------------------------------------
         //        // Area with the highest frequency.
         //        //----------------------------------------------------------------------
-        //        final java.util.Map<Area, Integer> areaFrequency = new HashMap<>();
+        //        final java.util.BWEMMap<Area, Integer> areaFrequency = new HashMap<>();
         //        for (int dy = 0; dy < size.getY(); ++dy)
         //        for (int dx = 0; dx < size.getX(); ++dx) {
         //            final Area area = getArea(topLeft.add(new TilePosition(dx, dy)));
@@ -218,8 +218,8 @@ public Area getMainArea(final TilePosition topLeft, final TilePosition size) {
         //        }
         //
         //        if (!areaFrequency.isEmpty()) {
-        //            java.util.Map.Entry<Area, Integer> highestFreqEntry = null;
-        //            for (final java.util.Map.Entry<Area, Integer> currentEntry :
+        //            java.util.BWEMMap.Entry<Area, Integer> highestFreqEntry = null;
+        //            for (final java.util.BWEMMap.Entry<Area, Integer> currentEntry :
         // areaFrequency.entrySet()) {
         //                if (highestFreqEntry == null || (currentEntry.getValue() >
         // highestFreqEntry.getValue())) {
diff --git a/src/main/java/bwem/BWEMMapInitializer.java b/src/main/java/bwem/BWEMMapInitializer.java
@@ -19,8 +19,8 @@
 import java.util.Collections;
 import java.util.List;
 
-class MapInitializer extends Map {
-    MapInitializer(final Game game) {
+class BWEMMapInitializer extends BWEMMap {
+    BWEMMapInitializer(final Game game) {
         super(game);
     }
 
@@ -83,7 +83,7 @@ private void initializeTerrainData(
     }
 
     ////////////////////////////////////////////////////////////////////////
-    // Map::InitializeNeutrals
+    // BWEMMap::InitializeNeutrals
     ////////////////////////////////////////////////////////////////////////
 
     private void initializeNeutralData(
@@ -96,7 +96,7 @@ private void initializeNeutralData(
     ////////////////////////////////////////////////////////////////////////
 
     ////////////////////////////////////////////////////////////////////////
-    // Map::ComputeAltitude
+    // BWEMMap::ComputeAltitude
     ////////////////////////////////////////////////////////////////////////
 
     // Assigns MiniTile::m_altitude foar each miniTile having AltitudeMissing()
@@ -233,7 +233,7 @@ private Altitude setAltitudesAndGetUpdatedHighestAltitude(
     ////////////////////////////////////////////////////////////////////////
 
     ////////////////////////////////////////////////////////////////////////
-    // Map::processBlockingNeutrals
+    // BWEMMap::processBlockingNeutrals
     ////////////////////////////////////////////////////////////////////////
 
     private void processBlockingNeutrals(final List<Neutral> candidates) {
@@ -413,7 +413,7 @@ private void markBlockingStackedNeutrals(
     ////////////////////////////////////////////////////////////////////////
 
     ////////////////////////////////////////////////////////////////////////
-    // Map::ComputeAreas
+    // BWEMMap::ComputeAreas
     ////////////////////////////////////////////////////////////////////////
 
     // Assigns MiniTile::m_areaId for each miniTile having AreaIdMissing()
@@ -589,7 +589,7 @@ private void createAreas(final List<TempAreaInfo> tempAreaList, final int areaMi
         getGraph().createAreas(areasList);
     }
 
-    // Renamed from "Map::SetAltitudeInTile"
+    // Renamed from "BWEMMap::SetAltitudeInTile"
     private void setLowestAltitudeInTile(final TilePosition t) {
         Altitude lowestAltitude = new Altitude(Integer.MAX_VALUE);
 
@@ -609,7 +609,7 @@ private void setLowestAltitudeInTile(final TilePosition t) {
         getData().getTile(t).setLowestAltitude(lowestAltitude);
     }
 
-    // Renamed from "Map::SetAreaIdInTiles"
+    // Renamed from "BWEMMap::SetAreaIdInTiles"
     private void setAreaIdAndLowestAltitudeInTiles() {
         for (int y = 0; y < getData().getMapData().getTileSize().getY(); ++y)
             for (int x = 0; x < getData().getMapData().getTileSize().getX(); ++x) {
@@ -619,7 +619,7 @@ private void setAreaIdAndLowestAltitudeInTiles() {
             }
     }
 
-    public void onBlockingNeutralDestroyed(Neutral pBlocking) {
+    void onBlockingNeutralDestroyed(Neutral pBlocking) {
         if (!(pBlocking != null && pBlocking.isBlocking())) {
             throw new IllegalArgumentException();
         }
diff --git a/src/main/java/bwem/CPPath.java b/src/main/java/bwem/CPPath.java
@@ -17,7 +17,7 @@
 import java.util.List;
 
 /**
- * Type of all the Paths used in BWEM (Cf. Map::GetPath).
+ * Type of all the Paths used in BWEM (Cf. BWEMMap::GetPath).
  *
  * <p>cp.h:68:typedef std::vector<const ChokePoint *> Path; cp.h:168:typedef ChokePoint::Path
  * CPPath;
diff --git a/src/main/java/bwem/ChokePoint.java b/src/main/java/bwem/ChokePoint.java
@@ -30,7 +30,7 @@
  * Pos(middle), Pos(end1) and Pos(end2).<br>
  * ChokePoints play an important role in BWEM:<br>
  * - they define accessibility between Areas.<br>
- * - the Paths provided by Map::GetPath are made of ChokePoints.<br>
+ * - the Paths provided by BWEMMap::GetPath are made of ChokePoints.<br>
  * Like Areas and Bases, the number and the addresses of ChokePoint instances remain unchanged.<br>
  * <br>
  * Pseudo ChokePoints:<br>
@@ -99,7 +99,7 @@ > getMap().getData().getMiniTile(geometry.get(i)).getAltitude().intValue())) {
         }
         this.nodes[Node.MIDDLE.ordinal()] = geometry.get(i);
 
-        Map map = getMap();
+        BWEMMap map = getMap();
         for (int n = 0; n < Node.NODE_COUNT.ordinal(); ++n) {
             for (final Area area : new Area[]{area1, area2}) {
                 final WalkPosition nodeInArea =
@@ -150,7 +150,7 @@ > getMap().getData().getMiniTile(geometry.get(i)).getAltitude().intValue())) {
         this(graph, index, area1, area2, geometry, null);
     }
 
-    private Map getMap() {
+    private BWEMMap getMap() {
         return this.graph.getMap();
     }
 
@@ -193,7 +193,7 @@ public WalkPosition getNodePosition(final Node node) {
 
     /**
      * Pretty much the same as pos(n), except that the returned MiniTile position is guaranteed to be
-     * part of pArea. That is: Map::getArea(positionOfNodeInArea(n, pArea)) == pArea.
+     * part of pArea. That is: BWEMMap::getArea(positionOfNodeInArea(n, pArea)) == pArea.
      */
     public WalkPosition getNodePositionInArea(final Node node, final Area area) {
         if (!(area.equals(this.areas.getLeft()) || area.equals(this.areas.getRight()))) {
@@ -219,7 +219,7 @@ public List<WalkPosition> getGeometry() {
      * If !isPseudo(), returns false. Otherwise, returns whether this ChokePoint is considered
      * blocked. Normally, a pseudo ChokePoint either remains blocked, or switches to not isBlocked
      * when blockingNeutral() is destroyed and there is no remaining Neutral stacked with it. However,
-     * in the case where Map::automaticPathUpdate() == false, blocked() will always return true
+     * in the case where BWEMMap::automaticPathUpdate() == false, blocked() will always return true
      * whatever blockingNeutral() returns. Cf. Area::AccessibleNeighbors().
      */
     public boolean isBlocked() {
@@ -265,7 +265,7 @@ public boolean accessibleFrom(final ChokePoint chokePoint) {
      * - Note: if this == cp, returns [cp].<br>
      * Time complexity: O(1)<br>
      * To get the length of the path returned in pixels, use distanceFrom(cp).<br>
-     * - Note: all the possible Paths are precomputed during Map::initialize().<br>
+     * - Note: all the possible Paths are precomputed during BWEMMap::initialize().<br>
      * The best one is then stored for each pair of getChokePoints. However, only the center of the
      * getChokePoints is considered. As a consequence, the returned path may not be the shortest one.
      */
diff --git a/src/main/java/bwem/Geyser.java b/src/main/java/bwem/Geyser.java
@@ -20,7 +20,7 @@
  * Resource_Vespene_Geyser.
  */
 public final class Geyser extends Resource {
-    Geyser(final Unit unit, final Map map) {
+    Geyser(final Unit unit, final BWEMMap map) {
         super(unit, map);
 
         if (!unit.getType().equals(UnitType.Resource_Vespene_Geyser)) {
diff --git a/src/main/java/bwem/Graph.java b/src/main/java/bwem/Graph.java
@@ -24,7 +24,7 @@
 import java.util.*;
 
 public final class Graph {
-    private final Map map;
+    private final BWEMMap map;
     private final List<Area> areas = new ArrayList<>();
     private final List<ChokePoint> chokePoints = new ArrayList<>();
     private final List<List<List<ChokePoint>>> chokePointsMatrix =
@@ -35,11 +35,11 @@ public final class Graph {
             new ArrayList<>(); // index == ChokePoint::index x ChokePoint::index
     private final List<Base> bases = new ArrayList<>();
 
-    public Graph(Map map) {
+    public Graph(BWEMMap map) {
         this.map = map;
     }
 
-    public Map getMap() {
+    public BWEMMap getMap() {
         return map;
     }
 
@@ -104,7 +104,7 @@ public Area getNearestArea(final TilePosition tilePosition) {
         return getArea(t);
     }
 
-    // Returns the list of all the getChokePoints in the Map.
+    // Returns the list of all the getChokePoints in the BWEMMap.
     public List<ChokePoint> getChokePoints() {
         return chokePoints;
     }
@@ -345,8 +345,8 @@ public void createChokePoints(
             final List<WalkPosition> rawFrontierAB = entry.getValue();
 
             // Because our dispatching preserved order,
-            // and because Map::m_RawFrontier was populated in descending order of the altitude (see
-            // Map::computeAreas),
+            // and because BWEMMap::m_RawFrontier was populated in descending order of the altitude (see
+            // BWEMMap::computeAreas),
             // we know that rawFrontierAB is also ordered the same way, but let's check it:
             {
                 final List<Altitude> altitudes = new ArrayList<>();
@@ -498,7 +498,7 @@ public void computeChokePointDistanceMatrix() {
     }
 
     public void collectInformation() {
-        // 1) Process the whole Map:
+        // 1) Process the whole BWEMMap:
 
         for (final Mineral mineral : getMap().getNeutralData().getMinerals()) {
             final Area area = getMap().getMainArea(mineral.getTopLeft(), mineral.getSize());
diff --git a/src/main/java/bwem/Mineral.java b/src/main/java/bwem/Mineral.java
@@ -19,7 +19,7 @@
  * getType().isMineralField().
  */
 public final class Mineral extends Resource {
-    Mineral(final Unit unit, final Map map) {
+    Mineral(final Unit unit, final BWEMMap map) {
         super(unit, map);
 
         //        bwem_assert(Type().isMineralField());
diff --git a/src/main/java/bwem/MiniTile.java b/src/main/java/bwem/MiniTile.java
@@ -19,13 +19,13 @@
 /**
  * Corresponds to BWAPI/Starcraft's concept of walk tile (8x8 pixels).<br>
  * - MiniTiles are accessed using WalkPositions {@link TerrainData#getMiniTile(WalkPosition)}<br>
- * - A Map holds Map::WalkSize().x * Map::WalkSize().y MiniTiles as its "MiniTile map".<br>
+ * - A BWEMMap holds BWEMMap::WalkSize().x * BWEMMap::WalkSize().y MiniTiles as its "MiniTile map".<br>
  * - A MiniTile contains essentialy 3 pieces of information:<br>
  * i) its Walkability<br>
  * ii) its altitude (distance from the nearest non walkable MiniTile, except those which are part of
  * small enough zones (lakes))<br>
  * iii) the id of the Area it is part of, if ever.<br>
- * - The whole process of analysis of a Map relies on the walkability information<br>
+ * - The whole process of analysis of a BWEMMap relies on the walkability information<br>
  * from which are derived successively: altitudes, Areas, ChokePoints.
  */
 public class MiniTile {
@@ -110,12 +110,12 @@ public boolean isTerrain() {
      * For Sea and Lake miniTiles, returns 0<br>
      * For Terrain miniTiles, returns a non zero id:<br>
      * - if (id > 0), id uniquely identifies the Area A that contains this MiniTile.<br>
-     * Moreover we have: A.id() == id and Map::getArea(id) == A<br>
+     * Moreover we have: A.id() == id and BWEMMap::getArea(id) == A<br>
      * - For more information about positive Area::ids, see Area::id()<br>
      * - if (id < 0), then this MiniTile is part of a Terrain-zone that was considered too small to
      * create an Area for it.<br>
      * - Note: negative Area::ids start from -2<br>
-     * - Note: because of the lakes, Map::getNearestArea should be prefered over Map::getArea.
+     * - Note: because of the lakes, BWEMMap::getNearestArea should be prefered over BWEMMap::getArea.
      */
     public AreaId getAreaId() {
         return this.areaId;
diff --git a/src/main/java/bwem/Neutral.java b/src/main/java/bwem/Neutral.java
@@ -30,11 +30,11 @@ public abstract class Neutral {
     private final Position pos;
     private final TilePosition topLeft;
     private final TilePosition tileSize;
-    private final Map map;
+    private final BWEMMap map;
     private Neutral nextStacked = null;
     private List<WalkPosition> blockedAreas = new ArrayList<>();
 
-    Neutral(final Unit unit, final Map map) {
+    Neutral(final Unit unit, final BWEMMap map) {
         this.bwapiUnit = unit;
         this.map = map;
         this.pos = unit.getInitialPosition();
@@ -48,7 +48,7 @@ void simulateCPPObjectDestructor() {
         removeFromTiles();
 
         if (isBlocking()) {
-            MapInitializer map = (MapInitializer) getMap();
+            BWEMMapInitializer map = (BWEMMapInitializer) getMap();
             map.onBlockingNeutralDestroyed(this);
         }
     }
@@ -124,7 +124,7 @@ public List<Area> getBlockedAreas() {
     /**
      * Returns the next Neutral stacked over this Neutral, if ever.<br>
      * - To iterate through the whole stack, one can use the following:<br>
-     * <code>for (const Neutral * n = Map::GetTile(topLeft()).GetNeutral() ; n ; n = n->nextStacked())
+     * <code>for (const Neutral * n = BWEMMap::GetTile(topLeft()).GetNeutral() ; n ; n = n->nextStacked())
      * </code>
      */
     public Neutral getNextStacked() {
@@ -230,7 +230,7 @@ private void removeFromTiles() {
         this.nextStacked = null;
     }
 
-    private Map getMap() {
+    private BWEMMap getMap() {
         return this.map;
     }
 
diff --git a/src/main/java/bwem/NeutralData.java b/src/main/java/bwem/NeutralData.java
@@ -23,12 +23,12 @@ public class NeutralData {
     private final List<StaticBuilding> staticBuildings;
 
     public NeutralData(
-            final Map map,
+            final BWEMMap map,
             final List<Unit> mineralPatches,
             final List<Unit> vespeneGeysers,
             final List<Unit> neutralUnits) {
         ////////////////////////////////////////////////////////////////////////
-        // Map::InitializeNeutrals
+        // BWEMMap::InitializeNeutrals
         ////////////////////////////////////////////////////////////////////////
 
         this.minerals = new ArrayList<>();
diff --git a/src/main/java/bwem/Resource.java b/src/main/java/bwem/Resource.java
@@ -18,7 +18,7 @@
  * A Resource is either a Mineral or a Geyser.
  */
 public abstract class Resource extends Neutral {
-    Resource(final Unit unit, final Map map) {
+    Resource(final Unit unit, final BWEMMap map) {
         super(unit, map);
     }
 
diff --git a/src/main/java/bwem/StaticBuilding.java b/src/main/java/bwem/StaticBuilding.java
diff --git a/src/main/java/bwem/TempAreaInfo.java b/src/main/java/bwem/TempAreaInfo.java
diff --git a/src/main/java/bwem/TerrainDataInitializer.java b/src/main/java/bwem/TerrainDataInitializer.java
diff --git a/src/main/java/bwem/Tile.java b/src/main/java/bwem/Tile.java
diff --git a/src/main/java/bwem/util/BwemExt.java b/src/main/java/bwem/util/BwemExt.java
diff --git a/src/test/java/marinehell/MarineHell.java b/src/test/java/marinehell/MarineHell.java

Original file line number	Diff line number	Diff line change
`@@ -679,7 +679,7 @@ public boolean canBuildHere(final TilePosition position, final UnitType type, fi`
`679`	`679`	`position;`
`680`	`680`	`final TilePosition rb = lt.add(type.tileSize());`
`681`	`681`
`682`		`- // Map limit check`
	`682`	`+ // BWEMMap limit check`
`683`	`683`	`if (!lt.isValid(this) \|\| !(rb.toPosition().subtract(new Position(1, 1)).isValid(this))) {`
`684`	`684`	`return false;`
`685`	`685`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,16 +15,16 @@`
`15`	`15`	`import bwapi.Game;`
`16`	`16`
`17`	`17`	`public final class BWEM {`
`18`		`- private final Map map;`
	`18`	`+ private final BWEMMap map;`
`19`	`19`
`20`	`20`	`public BWEM(final Game game) {`
`21`		`- this.map = new MapInitializer(game);`
	`21`	`+ this.map = new BWEMMapInitializer(game);`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`/**`
`25`	`25`	`* Returns the root internal data container.`
`26`	`26`	`*/`
`27`		`- public Map getMap() {`
	`27`	`+ public BWEMMap getMap() {`
`28`	`28`	`return this.map;`
`29`	`29`	`}`
`30`	`30`
`@@ -33,10 +33,10 @@ public Map getMap() {`
`33`	`33`	`* Initializes and pre-computes all of the internal data.`
`34`	`34`	`*/`
`35`	`35`	`public void initialize() {`
`36`		`- if (!(this.map instanceof MapInitializer)) {`
	`36`	`+ if (!(this.map instanceof BWEMMapInitializer)) {`
`37`	`37`	`throw new IllegalStateException("BWEM was not instantiated properly.");`
`38`	`38`	`}`
`39`		`- ((MapInitializer) this.map).initialize();`
	`39`	`+ ((BWEMMapInitializer) this.map).initialize();`
`40`	`40`	`this.map.assignStartingLocationsToSuitableBases();`
`41`	`41`	`}`
`42`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@`
`17`	`17`	`import java.util.List;`
`18`	`18`
`19`	`19`	`/**`
`20`		`- * Type of all the Paths used in BWEM (Cf. Map::GetPath).`
	`20`	`+ * Type of all the Paths used in BWEM (Cf. BWEMMap::GetPath).`
`21`	`21`	`*`
`22`	`22`	`* <p>cp.h:68:typedef std::vector<const ChokePoint *> Path; cp.h:168:typedef ChokePoint::Path`
`23`	`23`	`* CPPath;`