Ignore:
Timestamp:
2016-08-18T03:39:22+02:00 (3 years ago)
Author:
Don-vip
Message:

see #11924 - extract MapCSS conditions to new class ConditionFactory (on the same model than ExpressionFactory) - should workaround Groovy bug with Java 9 (https://issues.apache.org/jira/browse/GROOVY-7879 ?)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/gui/mappaint/mapcss/MapCSSParser.jj

    r9958 r10837  
    2222import org.openstreetmap.josm.gui.mappaint.mapcss.Condition;
    2323import org.openstreetmap.josm.gui.mappaint.mapcss.Condition.Context;
     24import org.openstreetmap.josm.gui.mappaint.mapcss.ConditionFactory;
     25import org.openstreetmap.josm.gui.mappaint.mapcss.ConditionFactory.KeyMatchType;
     26import org.openstreetmap.josm.gui.mappaint.mapcss.ConditionFactory.Op;
    2427import org.openstreetmap.josm.gui.mappaint.mapcss.Expression;
    2528import org.openstreetmap.josm.gui.mappaint.mapcss.ExpressionFactory;
     
    744747            c=simple_key_value_condition(context) s() <RSQUARE> { return c; }
    745748        |
    746             e=expression() <RSQUARE> { return Condition.createExpressionCondition(e, context); }
     749            e=expression() <RSQUARE> { return ConditionFactory.createExpressionCondition(e, context); }
    747750    )
    748751}
     
    762765{
    763766    boolean not = false;
    764     Condition.KeyMatchType matchType = null;;
     767    KeyMatchType matchType = null;;
    765768    String key;
    766769}
     
    768771    ( <EXCLAMATION> { not = true; } )?
    769772    (
    770         { matchType = Condition.KeyMatchType.REGEX; } key = regex()
     773        { matchType = KeyMatchType.REGEX; } key = regex()
    771774    |
    772775        key = tag_key()
    773776    )
    774     ( LOOKAHEAD(2) <QUESTION> <EXCLAMATION> { matchType = Condition.KeyMatchType.FALSE; } )?
    775     (              <QUESTION>               { matchType = Condition.KeyMatchType.TRUE;  } )?
    776     { return Condition.createKeyCondition(key, not, matchType, context); }
     777    ( LOOKAHEAD(2) <QUESTION> <EXCLAMATION> { matchType = KeyMatchType.FALSE; } )?
     778    (              <QUESTION>               { matchType = KeyMatchType.TRUE;  } )?
     779    { return ConditionFactory.createKeyCondition(key, not, matchType, context); }
    777780}
    778781
     
    783786    float f;
    784787    int i;
    785     Condition.KeyMatchType matchType = null;;
    786     Condition.Op op;
     788    KeyMatchType matchType = null;;
     789    Op op;
    787790    boolean considerValAsKey = false;
    788791}
    789792{
    790793    (
    791         key = regex() s() { matchType = Condition.KeyMatchType.REGEX; }
     794        key = regex() s() { matchType = KeyMatchType.REGEX; }
    792795    |
    793796        key=tag_key() s()
     
    796799        LOOKAHEAD(3)
    797800            (
    798                     <EQUAL> <TILDE> { op=Condition.Op.REGEX; }
     801                    <EQUAL> <TILDE> { op=Op.REGEX; }
    799802                |
    800                     <EXCLAMATION> <TILDE> { op=Condition.Op.NREGEX; }
     803                    <EXCLAMATION> <TILDE> { op=Op.NREGEX; }
    801804            )
    802805            s()
     
    805808        |
    806809            (
    807                     <EXCLAMATION> <EQUAL> { op=Condition.Op.NEQ; }
     810                    <EXCLAMATION> <EQUAL> { op=Op.NEQ; }
    808811                |
    809                     <EQUAL> { op=Condition.Op.EQ; }
     812                    <EQUAL> { op=Op.EQ; }
    810813                |
    811                     <TILDE> <EQUAL> { op=Condition.Op.ONE_OF; }
     814                    <TILDE> <EQUAL> { op=Op.ONE_OF; }
    812815                |
    813                     <CARET> <EQUAL> { op=Condition.Op.BEGINS_WITH; }
     816                    <CARET> <EQUAL> { op=Op.BEGINS_WITH; }
    814817                |
    815                     <DOLLAR> <EQUAL> { op=Condition.Op.ENDS_WITH; }
     818                    <DOLLAR> <EQUAL> { op=Op.ENDS_WITH; }
    816819                |
    817                     <STAR> <EQUAL> { op=Condition.Op.CONTAINS; }
     820                    <STAR> <EQUAL> { op=Op.CONTAINS; }
    818821            )
    819822            s()
     
    829832        |
    830833            (
    831                     <GREATER_EQUAL> { op=Condition.Op.GREATER_OR_EQUAL; }
     834                    <GREATER_EQUAL> { op=Op.GREATER_OR_EQUAL; }
    832835                |
    833                     <GREATER> { op=Condition.Op.GREATER; }
     836                    <GREATER> { op=Op.GREATER; }
    834837                |
    835                     <LESS_EQUAL> { op=Condition.Op.LESS_OR_EQUAL; }
     838                    <LESS_EQUAL> { op=Op.LESS_OR_EQUAL; }
    836839                |
    837                     <LESS> { op=Condition.Op.LESS; }
     840                    <LESS> { op=Op.LESS; }
    838841            )
    839842            s()
    840843            f=float_() { val=Float.toString(f); }
    841844    )
    842     { return Condition.KeyMatchType.REGEX == matchType
    843             ? Condition.createRegexpKeyRegexpValueCondition(key, val, op)
    844             : Condition.createKeyValueCondition(key, val, op, context, considerValAsKey); }
     845    { return KeyMatchType.REGEX == matchType
     846            ? ConditionFactory.createRegexpKeyRegexpValueCondition(key, val, op)
     847            : ConditionFactory.createKeyValueCondition(key, val, op, context, considerValAsKey); }
    845848}
    846849
     
    860863    s=ident()
    861864    { return pseudo
    862         ? Condition.createPseudoClassCondition(s, not, context)
    863         : Condition.createClassCondition(s, not, context); }
     865        ? ConditionFactory.createPseudoClassCondition(s, not, context)
     866        : ConditionFactory.createClassCondition(s, not, context); }
    864867}
    865868
Note: See TracChangeset for help on using the changeset viewer.