/** * The equals method will only return true if both the keys and values match exactly. If a has * entries that b doesn't have or vice versa, then a and b are not equal. */ @Override @SuppressWarnings("unchecked") public boolean equals(final Object o) { if (this == o) return true; if (o == null || !(o instanceof IntegerMap)) return false; final IntegerMap<T> map = (IntegerMap<T>) o; if (!map.keySet().equals(this.keySet())) return false; if (!map.m_values.equals(this.m_values)) return false; for (final T key : map.keySet()) { if (!(this.getInt(key) == map.getInt(key))) return false; } return true; }
/** * @param units a HashMap in the form RepairRule -> number of units assumes that each repair rule * has 1 result, which is simply the number of units */ public void setUnitsFromRepairRuleMap( final HashMap<Unit, IntegerMap<RepairRule>> units, final PlayerID player, final GameData data) { removeAll(); final Set<Unit> entries = units.keySet(); for (final Unit unit : entries) { final IntegerMap<RepairRule> rules = units.get(unit); final TreeSet<RepairRule> repairRules = new TreeSet<RepairRule>(repairRuleComparator); repairRules.addAll(rules.keySet()); for (final RepairRule repairRule : repairRules) { final int quantity = rules.getInt(repairRule); if (games.strategy.triplea.Properties.getDamageFromBombingDoneToUnitsInsteadOfTerritories( data)) { // check to see if the repair rule matches the damaged unit if (unit.getType().equals((repairRule.getResults().keySet().iterator().next()))) addUnits( player, data, quantity, unit.getType(), Matches.UnitHasTakenSomeBombingUnitDamage.match(unit), Matches.UnitIsDisabled.match(unit)); } } } }
/** * This will make a new IntegerMap. The Objects will be linked, but the integers mapped to them * will not be linked. * * @param integerMap */ public IntegerMap(final IntegerMap<T> integerMap) { /* this will also work: m_values = new HashMap<T,Integer>(integerMap.m_values); */ m_values = new HashMap<T, Integer>(integerMap.size()); for (final T t : integerMap.keySet()) { m_values.put(t, integerMap.getInt(t)); } }
/** * @param units a HashMap in the form ProductionRule -> number of units assumes that each * production rule has 1 result, which is simple the number of units */ public void setUnitsFromProductionRuleMap( final IntegerMap<ProductionRule> units, final PlayerID player, final GameData data) { removeAll(); final TreeSet<ProductionRule> productionRules = new TreeSet<ProductionRule>(productionRuleComparator); productionRules.addAll(units.keySet()); for (final ProductionRule productionRule : productionRules) { final int quantity = units.getInt(productionRule); for (final NamedAttachable resourceOrUnit : productionRule.getResults().keySet()) { addUnits( player, data, quantity * productionRule.getResults().getInt(resourceOrUnit), resourceOrUnit, false, false); } } }
/** Add map * multiple */ public void addMultiple(final IntegerMap<T> map, final int multiple) { for (final T key : map.keySet()) { add(key, map.getInt(key) * multiple); } }
/** * By >= we mean that each of our entries is greater than or equal to each entry in the other map. * We do not take into account entries that are in our map but not in the second map. <br> * It is possible that for two maps a and b a.greaterThanOrEqualTo(b) is false, and * b.greaterThanOrEqualTo(a) is false, and that a and b are not equal. */ public boolean greaterThanOrEqualTo(final IntegerMap<T> map) { for (final T key : map.keySet()) { if (!(this.getInt(key) >= map.getInt(key))) return false; } return true; }
public void subtract(final IntegerMap<T> map) { for (final T key : map.keySet()) { add(key, -map.getInt(key)); } }
public void add(final IntegerMap<T> map) { for (final T key : map.keySet()) { add(key, map.getInt(key)); } }