games.strategy.triplea.delegate
Class Matches

java.lang.Object
  extended by games.strategy.triplea.delegate.Matches

public class Matches
extends java.lang.Object

Useful match interfaces. Rather than writing code like,

 boolean hasLand = false;
 Iterator iter = someCollection.iterator();

 while(iter.hasNext())
 {
       Unit unit = (Unit) iter.next();
    UnitAttatchment ua = UnitAttatchment.get(unit.getType());
      if(ua.isAir)
      {
        hasAir = true;
        break;
      }
 }

 
You can write code like, boolean hasLand = Match.someMatch(someCollection, Matches.UnitIsAir); The benefits should be obvious to any right minded person.

Version:
1.0
Author:
Sean Bridges

Field Summary
static Match<games.strategy.triplea.delegate.Battle> BattleIsAmphibious
           
static Match<games.strategy.triplea.delegate.Battle> BattleIsEmpty
           
static Match<java.lang.Object> IsTerritory
           
static Match<Territory> TerritoryIsEmpty
           
static Match<Territory> TerritoryIsImpassable
           
static Match<Territory> TerritoryIsLand
           
static Match<Territory> TerritoryIsNeutral
           
static Match<Territory> TerritoryIsNotImpassable
           
static Match<Territory> TerritoryIsNotNeutral
           
static Match<Territory> TerritoryIsVictoryCity
           
static Match<Territory> TerritoryIsWater
           
static Match<Unit> UnitCanBeTransported
           
static Match<Unit> UnitCanBlitz
           
static Match<Unit> UnitCanLandOnCarrier
           
static Match<Unit> UnitCanMove
           
static Match<Unit> UnitCanNotBeTransported
           
static Match<Unit> UnitCanTransport
           
static Match<Unit> unitHasMoved
           
static Match<Unit> unitHasNotMoved
           
static Match<Unit> UnitIsAA
           
static Match<Unit> UnitIsAAOrFactory
           
static Match<Unit> UnitIsAir
           
static Match<Unit> UnitIsArtillery
           
static Match<Unit> UnitIsArtillerySupportable
           
static Match<Unit> UnitIsBB
           
static Match<Unit> UnitIsCarrier
           
static Match<Unit> UnitIsCruiser
           
static Match<Unit> UnitIsDamaged
           
static Match<Unit> UnitIsDestroyer
           
static Match<Unit> UnitIsDestructible
           
static Match<Unit> UnitIsFactory
           
static Match<Unit> UnitIsInfantry
           
static Match<Unit> UnitIsLand
           
static Match<Unit> UnitIsMarine
           
static Match<Unit> UnitIsNotAA
           
static Match<Unit> UnitIsNotAir
           
static Match<Unit> UnitIsNotArmour
           
static Match<Unit> UnitIsNotDamaged
           
static Match<Unit> UnitIsNotFactory
           
static Match<Unit> UnitIsNotInfantry
           
static Match<Unit> UnitIsNotLand
           
static Match<Unit> UnitIsNotMarine
           
static Match<Unit> UnitIsNotParatroop
           
static Match<Unit> UnitIsNotSea
           
static Match<Unit> UnitIsNotStrategicBomber
           
static Match<Unit> UnitIsNotSub
           
static Match<Unit> UnitIsNotTransport
           
static Match<Unit> UnitIsParatroop
           
static Match<Unit> UnitIsRadarAA
           
static Match<Unit> UnitIsSea
           
static Match<Unit> UnitIsStrategicBomber
           
static Match<Unit> UnitIsSub
           
static Match<Unit> UnitIsTransport
           
static Match<Unit> UnitIsTransportAndNotDestroyer
           
static Match<Unit> UnitIsTwoHit
           
static Match<UnitType> UnitTypeCanBeTransported
           
static Match<UnitType> UnitTypeCanLandOnCarrier
           
static Match<UnitType> UnitTypeCannotLandOnCarrier
           
static Match<UnitType> UnitTypeCanTransport
           
static Match<UnitType> UnitTypeIsAA
           
static Match<UnitType> UnitTypeIsAAOrFactory
           
static Match<UnitType> UnitTypeIsAir
           
static Match<UnitType> UnitTypeIsArtillery
           
static Match<UnitType> UnitTypeIsBB
           
static Match<UnitType> UnitTypeIsCarrier
           
static Match<UnitType> UnitTypeIsDestroyer
           
static Match<UnitType> UnitTypeIsFactory
           
static Match<UnitType> UnitTypeIsInfantry
           
static Match<UnitType> UnitTypeIsNotAir
           
static Match<UnitType> UnitTypeIsNotSea
           
static Match<UnitType> UnitTypeIsSea
           
static Match<UnitType> UnitTypeIsSeaOrAir
           
static Match<UnitType> UnitTypeIsSub
           
static Match<Unit> UnitWasAmphibious
           
static Match<Unit> UnitWasInCombat
           
static Match<Unit> UnitWasNotAmphibious
           
static Match<Unit> UnitWasUnloadedThisTurn
           
 
Method Summary
static Match<Unit> alliedUnit(PlayerID player, GameData data)
           
static Match<Unit> enemyUnit(PlayerID player, GameData data)
           
static Match<Territory> isTerritoryAllied(PlayerID player, GameData data)
           
static Match<Territory> isTerritoryEnemy(PlayerID player, GameData data)
           
static Match<Territory> isTerritoryEnemyAndNotNeutral(PlayerID player, GameData data)
           
static Match<Territory> isTerritoryEnemyAndNotNuetralWater(PlayerID player, GameData data)
           
static Match<Territory> isTerritoryFreeNeutral(GameData data)
           
static Match<Territory> isTerritoryFriendly(PlayerID player, GameData data)
           
static Match<Territory> isTerritoryOwnedBy(PlayerID player)
           
static Match<Unit> isUnitAllied(PlayerID player, GameData data)
           
static Match<Territory> territoryHasAlliedFactory(GameData data, PlayerID player)
           
static Match<Territory> territoryHasAlliedFactoryNeighbor(GameData data, PlayerID player)
           
static Match<Territory> territoryHasConvoyOwnedBy(PlayerID player, GameData data, Territory origTerr)
           
static Match<Territory> territoryHasConvoyRoute(Territory current)
           
static Match<Territory> territoryHasEnemyAA(PlayerID player, GameData data)
           
static Match<Territory> territoryHasEnemyBlitzUnits(PlayerID player, GameData data)
           
static Match<Territory> territoryHasEnemyFactory(GameData data, PlayerID player)
           
static Match<Territory> territoryHasEnemyFactoryNeighbor(GameData data, PlayerID player)
           
static Match<Territory> territoryHasEnemyLandNeighbor(GameData data, PlayerID player)
           
static Match<Territory> territoryHasEnemyLandUnits(PlayerID player, GameData data)
           
static Match<Territory> territoryHasEnemyUnits(PlayerID player, GameData data)
           
static Match<Territory> territoryHasLandUnitsOwnedBy(PlayerID player)
           
static Match<Territory> territoryHasNoAlliedUnits(PlayerID player, GameData data)
           
static Match<Territory> territoryHasNoEnemyUnits(PlayerID player, GameData data)
           
static Match<Territory> territoryHasNonSubmergedEnemyUnits(PlayerID player, GameData data)
           
static Match<Territory> TerritoryHasOwnedDestroyer(PlayerID player)
           
static Match<Territory> territoryHasOwnedFactory(GameData data, PlayerID player)
           
static Match<Territory> territoryHasOwnedTransportingUnits(PlayerID player)
           
static Match<Territory> TerritoryHasProductionValueAtLeast(int prodVal)
           
static Match<Territory> territoryHasRouteToEnemyCapital(GameData data, PlayerID player)
           
static Match<Territory> territoryHasUnitsOwnedBy(PlayerID player)
           
static Match<Territory> territoryHasValidLandRouteTo(GameData data, Territory goTerr)
           
static Match<Territory> territoryHasWaterNeighbor(GameData data)
           
static Match<Territory> territoryIs(Territory test)
           
static Match<Territory> TerritoryIsBlitzable(PlayerID player, GameData data)
           
static Match<Territory> territoryIsEmptyOfCombatUnits(GameData data, PlayerID player)
           
static Match<Territory> TerritoryIsImpassableToLandUnits(PlayerID player)
           
static Match<Territory> TerritoryIsNotImpassableToLandUnits(PlayerID player)
           
static Match<Territory> TerritoryIsPassableAndNotRestricted(PlayerID player)
           
static Match<Territory> territoryWasFoughOver(BattleTracker tracker)
           
static Match<Unit> transportCannotUnload(Territory territory)
           
static Match<Unit> transportIsNotTransporting()
           
static Match<Unit> transportIsTransporting()
           
static Match<Unit> unitCanAttack(PlayerID id)
           
static Match<Unit> unitCanBombard(PlayerID id)
           
static Match<Unit> unitHasEnoughMovement(int lowerLimit, IntegerMap<Unit> movement)
          Match units that have at least lower limit movement
static Match<Unit> unitIsEnemyAA(PlayerID player, GameData data)
           
static Match<Unit> unitIsInTerritory(Territory territory)
           
static Match<Unit> unitIsLandAndOwnedBy(PlayerID player)
           
static Match<Unit> unitIsNotSubmerged(GameData data)
           
static Match<Unit> unitIsOfType(UnitType type)
           
static Match<Unit> unitIsOwnedBy(PlayerID player)
           
static Match<Unit> unitIsSubmerged(GameData data)
           
static Match<Unit> unitIsTransportingSomeCategories(java.util.Collection<Unit> units)
           
static Match<Unit> unitOwnedBy(PlayerID player)
           
static Match<UnitType> unitTypeCanAttack(PlayerID id)
           
static Match<UnitType> unitTypeCanBombard(PlayerID id)
           
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

IsTerritory

public static final Match<java.lang.Object> IsTerritory

UnitIsTwoHit

public static final Match<Unit> UnitIsTwoHit

UnitIsDamaged

public static final Match<Unit> UnitIsDamaged

UnitIsNotDamaged

public static final Match<Unit> UnitIsNotDamaged

UnitIsSea

public static final Match<Unit> UnitIsSea

UnitIsSub

public static final Match<Unit> UnitIsSub

UnitIsNotSub

public static final Match<Unit> UnitIsNotSub

UnitCanMove

public static final Match<Unit> UnitCanMove

UnitIsDestroyer

public static final Match<Unit> UnitIsDestroyer

UnitTypeIsDestroyer

public static final Match<UnitType> UnitTypeIsDestroyer

UnitIsCruiser

public static final Match<Unit> UnitIsCruiser

UnitIsBB

public static final Match<Unit> UnitIsBB

UnitIsRadarAA

public static final Match<Unit> UnitIsRadarAA

UnitIsTransport

public static final Match<Unit> UnitIsTransport

UnitIsNotTransport

public static final Match<Unit> UnitIsNotTransport

UnitIsTransportAndNotDestroyer

public static final Match<Unit> UnitIsTransportAndNotDestroyer

UnitIsStrategicBomber

public static final Match<Unit> UnitIsStrategicBomber

UnitIsNotStrategicBomber

public static final Match<Unit> UnitIsNotStrategicBomber

UnitTypeCanLandOnCarrier

public static final Match<UnitType> UnitTypeCanLandOnCarrier

UnitTypeCannotLandOnCarrier

public static final Match<UnitType> UnitTypeCannotLandOnCarrier

unitHasMoved

public static final Match<Unit> unitHasMoved

unitHasNotMoved

public static final Match<Unit> unitHasNotMoved

UnitIsNotSea

public static final Match<Unit> UnitIsNotSea

UnitTypeIsSea

public static final Match<UnitType> UnitTypeIsSea

UnitTypeIsNotSea

public static final Match<UnitType> UnitTypeIsNotSea

UnitTypeIsSeaOrAir

public static final Match<UnitType> UnitTypeIsSeaOrAir

UnitTypeIsCarrier

public static final Match<UnitType> UnitTypeIsCarrier

UnitIsAir

public static final Match<Unit> UnitIsAir

UnitIsNotAir

public static final Match<Unit> UnitIsNotAir

UnitCanBlitz

public static final Match<Unit> UnitCanBlitz

UnitIsDestructible

public static final Match<Unit> UnitIsDestructible

UnitTypeIsAir

public static final Match<UnitType> UnitTypeIsAir

UnitTypeIsNotAir

public static final Match<UnitType> UnitTypeIsNotAir

UnitCanLandOnCarrier

public static final Match<Unit> UnitCanLandOnCarrier

UnitIsCarrier

public static final Match<Unit> UnitIsCarrier

UnitCanBeTransported

public static final Match<Unit> UnitCanBeTransported

UnitCanNotBeTransported

public static final Match<Unit> UnitCanNotBeTransported

UnitWasAmphibious

public static final Match<Unit> UnitWasAmphibious

UnitWasNotAmphibious

public static final Match<Unit> UnitWasNotAmphibious

UnitWasInCombat

public static final Match<Unit> UnitWasInCombat

UnitWasUnloadedThisTurn

public static final Match<Unit> UnitWasUnloadedThisTurn

UnitCanTransport

public static final Match<Unit> UnitCanTransport

UnitTypeCanTransport

public static final Match<UnitType> UnitTypeCanTransport

UnitTypeCanBeTransported

public static final Match<UnitType> UnitTypeCanBeTransported

UnitTypeIsFactory

public static final Match<UnitType> UnitTypeIsFactory

UnitTypeIsInfantry

public static final Match<UnitType> UnitTypeIsInfantry

UnitTypeIsArtillery

public static final Match<UnitType> UnitTypeIsArtillery

UnitIsFactory

public static final Match<Unit> UnitIsFactory

UnitIsNotFactory

public static final Match<Unit> UnitIsNotFactory

UnitTypeIsAA

public static final Match<UnitType> UnitTypeIsAA

UnitTypeIsAAOrFactory

public static final Match<UnitType> UnitTypeIsAAOrFactory

UnitIsAA

public static final Match<Unit> UnitIsAA

UnitIsNotAA

public static final Match<Unit> UnitIsNotAA

UnitIsNotArmour

public static final Match<Unit> UnitIsNotArmour

UnitIsInfantry

public static final Match<Unit> UnitIsInfantry

UnitIsNotInfantry

public static final Match<Unit> UnitIsNotInfantry

UnitIsMarine

public static final Match<Unit> UnitIsMarine

UnitIsNotMarine

public static final Match<Unit> UnitIsNotMarine

UnitIsParatroop

public static final Match<Unit> UnitIsParatroop

UnitIsNotParatroop

public static final Match<Unit> UnitIsNotParatroop

UnitIsArtillery

public static final Match<Unit> UnitIsArtillery

UnitIsArtillerySupportable

public static final Match<Unit> UnitIsArtillerySupportable

TerritoryIsWater

public static final Match<Territory> TerritoryIsWater

TerritoryIsVictoryCity

public static final Match<Territory> TerritoryIsVictoryCity

TerritoryIsLand

public static final Match<Territory> TerritoryIsLand

TerritoryIsEmpty

public static final Match<Territory> TerritoryIsEmpty

TerritoryIsNeutral

public static final Match<Territory> TerritoryIsNeutral

TerritoryIsNotNeutral

public static final Match<Territory> TerritoryIsNotNeutral

TerritoryIsImpassable

public static final Match<Territory> TerritoryIsImpassable

TerritoryIsNotImpassable

public static final Match<Territory> TerritoryIsNotImpassable

BattleIsEmpty

public static final Match<games.strategy.triplea.delegate.Battle> BattleIsEmpty

BattleIsAmphibious

public static final Match<games.strategy.triplea.delegate.Battle> BattleIsAmphibious

UnitIsLand

public static final Match<Unit> UnitIsLand

UnitIsNotLand

public static final Match<Unit> UnitIsNotLand

UnitTypeIsSub

public static final Match<UnitType> UnitTypeIsSub

UnitTypeIsBB

public static final Match<UnitType> UnitTypeIsBB

UnitIsAAOrFactory

public static final Match<Unit> UnitIsAAOrFactory
Method Detail

unitCanAttack

public static Match<Unit> unitCanAttack(PlayerID id)

unitTypeCanAttack

public static Match<UnitType> unitTypeCanAttack(PlayerID id)

unitTypeCanBombard

public static Match<UnitType> unitTypeCanBombard(PlayerID id)

unitCanBombard

public static Match<Unit> unitCanBombard(PlayerID id)

territoryHasConvoyRoute

public static Match<Territory> territoryHasConvoyRoute(Territory current)

territoryHasConvoyOwnedBy

public static Match<Territory> territoryHasConvoyOwnedBy(PlayerID player,
                                                         GameData data,
                                                         Territory origTerr)

territoryHasEnemyLandNeighbor

public static Match<Territory> territoryHasEnemyLandNeighbor(GameData data,
                                                             PlayerID player)

TerritoryHasOwnedDestroyer

public static Match<Territory> TerritoryHasOwnedDestroyer(PlayerID player)

territoryHasAlliedFactoryNeighbor

public static Match<Territory> territoryHasAlliedFactoryNeighbor(GameData data,
                                                                 PlayerID player)

territoryHasValidLandRouteTo

public static Match<Territory> territoryHasValidLandRouteTo(GameData data,
                                                            Territory goTerr)

territoryHasRouteToEnemyCapital

public static Match<Territory> territoryHasRouteToEnemyCapital(GameData data,
                                                               PlayerID player)

territoryHasEnemyFactoryNeighbor

public static Match<Territory> territoryHasEnemyFactoryNeighbor(GameData data,
                                                                PlayerID player)

territoryHasWaterNeighbor

public static Match<Territory> territoryHasWaterNeighbor(GameData data)

territoryHasAlliedFactory

public static Match<Territory> territoryHasAlliedFactory(GameData data,
                                                         PlayerID player)

territoryHasOwnedFactory

public static Match<Territory> territoryHasOwnedFactory(GameData data,
                                                        PlayerID player)

territoryHasEnemyFactory

public static Match<Territory> territoryHasEnemyFactory(GameData data,
                                                        PlayerID player)

territoryIsEmptyOfCombatUnits

public static Match<Territory> territoryIsEmptyOfCombatUnits(GameData data,
                                                             PlayerID player)

TerritoryHasProductionValueAtLeast

public static Match<Territory> TerritoryHasProductionValueAtLeast(int prodVal)

TerritoryIsPassableAndNotRestricted

public static final Match<Territory> TerritoryIsPassableAndNotRestricted(PlayerID player)

TerritoryIsImpassableToLandUnits

public static final Match<Territory> TerritoryIsImpassableToLandUnits(PlayerID player)

TerritoryIsNotImpassableToLandUnits

public static final Match<Territory> TerritoryIsNotImpassableToLandUnits(PlayerID player)

unitHasEnoughMovement

public static Match<Unit> unitHasEnoughMovement(int lowerLimit,
                                                IntegerMap<Unit> movement)
Match units that have at least lower limit movement


unitIsLandAndOwnedBy

public static Match<Unit> unitIsLandAndOwnedBy(PlayerID player)

unitIsOwnedBy

public static Match<Unit> unitIsOwnedBy(PlayerID player)

unitIsTransportingSomeCategories

public static Match<Unit> unitIsTransportingSomeCategories(java.util.Collection<Unit> units)

isTerritoryAllied

public static Match<Territory> isTerritoryAllied(PlayerID player,
                                                 GameData data)

isTerritoryOwnedBy

public static Match<Territory> isTerritoryOwnedBy(PlayerID player)

isUnitAllied

public static Match<Unit> isUnitAllied(PlayerID player,
                                       GameData data)

isTerritoryFriendly

public static Match<Territory> isTerritoryFriendly(PlayerID player,
                                                   GameData data)

unitIsEnemyAA

public static Match<Unit> unitIsEnemyAA(PlayerID player,
                                        GameData data)

unitIsInTerritory

public static Match<Unit> unitIsInTerritory(Territory territory)

isTerritoryEnemy

public static Match<Territory> isTerritoryEnemy(PlayerID player,
                                                GameData data)

isTerritoryEnemyAndNotNuetralWater

public static Match<Territory> isTerritoryEnemyAndNotNuetralWater(PlayerID player,
                                                                  GameData data)

isTerritoryEnemyAndNotNeutral

public static Match<Territory> isTerritoryEnemyAndNotNeutral(PlayerID player,
                                                             GameData data)

TerritoryIsBlitzable

public static Match<Territory> TerritoryIsBlitzable(PlayerID player,
                                                    GameData data)

isTerritoryFreeNeutral

public static Match<Territory> isTerritoryFreeNeutral(GameData data)

enemyUnit

public static Match<Unit> enemyUnit(PlayerID player,
                                    GameData data)

unitOwnedBy

public static Match<Unit> unitOwnedBy(PlayerID player)

alliedUnit

public static Match<Unit> alliedUnit(PlayerID player,
                                     GameData data)

territoryIs

public static Match<Territory> territoryIs(Territory test)

territoryHasLandUnitsOwnedBy

public static Match<Territory> territoryHasLandUnitsOwnedBy(PlayerID player)

territoryHasUnitsOwnedBy

public static Match<Territory> territoryHasUnitsOwnedBy(PlayerID player)

territoryHasEnemyAA

public static Match<Territory> territoryHasEnemyAA(PlayerID player,
                                                   GameData data)

territoryHasNoEnemyUnits

public static Match<Territory> territoryHasNoEnemyUnits(PlayerID player,
                                                        GameData data)

territoryHasNoAlliedUnits

public static Match<Territory> territoryHasNoAlliedUnits(PlayerID player,
                                                         GameData data)

territoryHasNonSubmergedEnemyUnits

public static Match<Territory> territoryHasNonSubmergedEnemyUnits(PlayerID player,
                                                                  GameData data)

territoryHasEnemyLandUnits

public static Match<Territory> territoryHasEnemyLandUnits(PlayerID player,
                                                          GameData data)

territoryHasEnemyBlitzUnits

public static Match<Territory> territoryHasEnemyBlitzUnits(PlayerID player,
                                                           GameData data)

territoryHasEnemyUnits

public static Match<Territory> territoryHasEnemyUnits(PlayerID player,
                                                      GameData data)

territoryHasOwnedTransportingUnits

public static Match<Territory> territoryHasOwnedTransportingUnits(PlayerID player)

transportCannotUnload

public static Match<Unit> transportCannotUnload(Territory territory)

transportIsNotTransporting

public static Match<Unit> transportIsNotTransporting()

transportIsTransporting

public static Match<Unit> transportIsTransporting()

unitIsOfType

public static Match<Unit> unitIsOfType(UnitType type)

territoryWasFoughOver

public static Match<Territory> territoryWasFoughOver(BattleTracker tracker)

unitIsSubmerged

public static Match<Unit> unitIsSubmerged(GameData data)

unitIsNotSubmerged

public static Match<Unit> unitIsNotSubmerged(GameData data)