org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser クラス

org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser の継承関係図

org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser 連携図

クラス
class	AndFilterContext
class	AttrexpContext
class	AttrpathContext
class	CompareopContext
class	CompvalueContext
class	FilterContext
class	NegatedFilterContext
class	OrFilterContext
class	SimpleExprContext

公開メンバ関数
String []	getTokenNames ()
Vocabulary	getVocabulary ()
String	getGrammarFileName ()
String []	getRuleNames ()
String	getSerializedATN ()
ATN	getATN ()
	ScimFilterParser (TokenStream input)
final AttrpathContext	attrpath () throws RecognitionException
final CompareopContext	compareop () throws RecognitionException
final CompvalueContext	compvalue () throws RecognitionException
final AttrexpContext	attrexp () throws RecognitionException
final FilterContext	filter () throws RecognitionException
boolean	sempred (RuleContext _localctx, int ruleIndex, int predIndex)

静的公開変数類
static final int	T__0 =1
static final int	RULE_attrpath = 0
static final String []	ruleNames
static final Vocabulary	VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES)
static final String []	tokenNames
static final String	_serializedATN
static final ATN	_ATN

静的限定公開変数類
static final DFA []	_decisionToDFA
static final PredictionContextCache	_sharedContextCache

静的関数
	[static initializer]
	[static initializer]
	[static initializer]

静的変数
static final int	T__1 =2
static final int	T__2 =3
static final int	T__3 =4
static final int	T__4 =5
static final int	T__5 =6
static final int	T__6 =7
static final int	T__7 =8
static final int	T__8 =9
static final int	T__9 =10
static final int	T__10 =11
static final int	T__11 =12
static final int	T__12 =13
static final int	T__13 =14
static final int	T__14 =15
static final int	WHITESPACE =16
static final int	ALPHA =17
static final int	NUMBER =18
static final int	BOOLEAN =19
static final int	NULL =20
static final int	NAMECHAR =21
static final int	URI =22
static final int	ATTRNAME =23
static final int	SUBATTR =24
static final int	STRING =25
static final int	RULE_compareop = 1
static final int	RULE_compvalue = 2
static final int	RULE_attrexp = 3
static final int	RULE_filter = 4

非公開メンバ関数
FilterContext	filter (int _p) throws RecognitionException
boolean	filter_sempred (FilterContext _localctx, int predIndex)

静的非公開変数類
static final String []	_LITERAL_NAMES
static final String []	_SYMBOLIC_NAMES

詳解

構築子と解体子

ScimFilterParser()

org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.ScimFilterParser ( TokenStream  input )

inline

                                                   {
                super(input);
                _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
        }

関数詳解

[static initializer]() [1/3]

org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.[static initializer] ( )

inlinestaticpackage

[static initializer]() [2/3]

org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.[static initializer] ( )

inlinestaticpackage

[static initializer]() [3/3]

org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.[static initializer] ( )

inlinestaticpackage

attrexp()

final AttrexpContext org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.attrexp ( ) throws RecognitionException

inline

                                                                          {
                AttrexpContext _localctx = new AttrexpContext(_ctx, getState());
                enterRule(_localctx, 6, RULE_attrexp);
                try {
                        setState(25);
                        _errHandler.sync(this);
                        switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
                        case 1:
                                enterOuterAlt(_localctx, 1);
                                {
                                setState(18);
                                attrpath();
                                setState(19);
                                match(T__9);
                                }
                                break;
                        case 2:
                                enterOuterAlt(_localctx, 2);
                                {
                                setState(21);
                                attrpath();
                                setState(22);
                                compareop();
                                setState(23);
                                compvalue();
                                }
                                break;
                        }
                }
                catch (RecognitionException re) {
                        _localctx.exception = re;
                        _errHandler.reportError(this, re);
                        _errHandler.recover(this, re);
                }
                finally {
                        exitRule();
                }
                return _localctx;
        }

attrpath()

final AttrpathContext org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.attrpath ( ) throws RecognitionException

inline

                                                                            {
                AttrpathContext _localctx = new AttrpathContext(_ctx, getState());
                enterRule(_localctx, 0, RULE_attrpath);
                int _la;
                try {
                        enterOuterAlt(_localctx, 1);
                        {
                        setState(10);
                        match(ATTRNAME);
                        setState(12);
                        _la = _input.LA(1);
                        if (_la==SUBATTR) {
                                {
                                setState(11);
                                match(SUBATTR);
                                }
                        }

                        }
                }
                catch (RecognitionException re) {
                        _localctx.exception = re;
                        _errHandler.reportError(this, re);
                        _errHandler.recover(this, re);
                }
                finally {
                        exitRule();
                }
                return _localctx;
        }

compareop()

final CompareopContext org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.compareop ( ) throws RecognitionException

inline

                                                                              {
                CompareopContext _localctx = new CompareopContext(_ctx, getState());
                enterRule(_localctx, 2, RULE_compareop);
                int _la;
                try {
                        enterOuterAlt(_localctx, 1);
                        {
                        setState(14);
                        _la = _input.LA(1);
                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8))) != 0)) ) {
                        _errHandler.recoverInline(this);
                        } else {
                                consume();
                        }
                        }
                }
                catch (RecognitionException re) {
                        _localctx.exception = re;
                        _errHandler.reportError(this, re);
                        _errHandler.recover(this, re);
                }
                finally {
                        exitRule();
                }
                return _localctx;
        }

compvalue()

final CompvalueContext org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.compvalue ( ) throws RecognitionException

inline

                                                                              {
                CompvalueContext _localctx = new CompvalueContext(_ctx, getState());
                enterRule(_localctx, 4, RULE_compvalue);
                int _la;
                try {
                        enterOuterAlt(_localctx, 1);
                        {
                        setState(16);
                        _la = _input.LA(1);
                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NUMBER) | (1L << BOOLEAN) | (1L << NULL) | (1L << STRING))) != 0)) ) {
                        _errHandler.recoverInline(this);
                        } else {
                                consume();
                        }
                        }
                }
                catch (RecognitionException re) {
                        _localctx.exception = re;
                        _errHandler.reportError(this, re);
                        _errHandler.recover(this, re);
                }
                finally {
                        exitRule();
                }
                return _localctx;
        }

filter() [1/2]

final FilterContext org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.filter ( ) throws RecognitionException

inline

                                                                        {
                return filter(0);
        }

filter() [2/2]

FilterContext org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.filter ( int  _p ) throws RecognitionException

inlineprivate

                                                                         {
                ParserRuleContext _parentctx = _ctx;
                int _parentState = getState();
                FilterContext _localctx = new FilterContext(_ctx, _parentState);
                FilterContext _prevctx = _localctx;
                int _startState = 8;
                enterRecursionRule(_localctx, 8, RULE_filter, _p);
                int _la;
                try {
                        int _alt;
                        enterOuterAlt(_localctx, 1);
                        {
                        setState(36);
                        switch (_input.LA(1)) {
                        case T__10:
                        case T__11:
                                {
                                _localctx = new NegatedFilterContext(_localctx);
                                _ctx = _localctx;
                                _prevctx = _localctx;

                                setState(29);
                                _la = _input.LA(1);
                                if (_la==T__10) {
                                        {
                                        setState(28);
                                        match(T__10);
                                        }
                                }

                                setState(31);
                                match(T__11);
                                setState(32);
                                filter(0);
                                setState(33);
                                match(T__12);
                                }
                                break;
                        case ATTRNAME:
                                {
                                _localctx = new SimpleExprContext(_localctx);
                                _ctx = _localctx;
                                _prevctx = _localctx;
                                setState(35);
                                attrexp();
                                }
                                break;
                        default:
                                throw new NoViableAltException(this);
                        }
                        _ctx.stop = _input.LT(-1);
                        setState(46);
                        _errHandler.sync(this);
                        _alt = getInterpreter().adaptivePredict(_input,5,_ctx);
                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
                                if ( _alt==1 ) {
                                        if ( _parseListeners!=null ) triggerExitRuleEvent();
                                        _prevctx = _localctx;
                                        {
                                        setState(44);
                                        _errHandler.sync(this);
                                        switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
                                        case 1:
                                                {
                                                _localctx = new AndFilterContext(new FilterContext(_parentctx, _parentState));
                                                pushNewRecursionContext(_localctx, _startState, RULE_filter);
                                                setState(38);
                                                if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
                                                setState(39);
                                                match(T__13);
                                                setState(40);
                                                filter(4);
                                                }
                                                break;
                                        case 2:
                                                {
                                                _localctx = new OrFilterContext(new FilterContext(_parentctx, _parentState));
                                                pushNewRecursionContext(_localctx, _startState, RULE_filter);
                                                setState(41);
                                                if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
                                                setState(42);
                                                match(T__14);
                                                setState(43);
                                                filter(3);
                                                }
                                                break;
                                        }
                                        }
                                }
                                setState(48);
                                _errHandler.sync(this);
                                _alt = getInterpreter().adaptivePredict(_input,5,_ctx);
                        }
                        }
                }
                catch (RecognitionException re) {
                        _localctx.exception = re;
                        _errHandler.reportError(this, re);
                        _errHandler.recover(this, re);
                }
                finally {
                        unrollRecursionContexts(_parentctx);
                }
                return _localctx;
        }

filter_sempred()

boolean org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.filter_sempred ( FilterContext  _localctx, int  predIndex  )

inlineprivate

                                                                               {
                switch (predIndex) {
                case 0:
                        return precpred(_ctx, 3);
                case 1:
                        return precpred(_ctx, 2);
                }
                return true;
        }

getATN()

ATN org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.getATN ( )

inline

{ return _ATN; }

getGrammarFileName()

String org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.getGrammarFileName ( )

inline

{ return "ScimFilter.g4"; }

getRuleNames()

String [] org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.getRuleNames ( )

inline

{ return ruleNames; }

getSerializedATN()

String org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.getSerializedATN ( )

inline

{ return _serializedATN; }

getTokenNames()

String [] org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.getTokenNames ( )

inline

                                        {
                return tokenNames;
        }

getVocabulary()

Vocabulary org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.getVocabulary ( )

inline

                                          {
                return VOCABULARY;
        }

sempred()

boolean org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.sempred ( RuleContext  _localctx, int  ruleIndex, int  predIndex  )

inline

                                                                                    {
                switch (ruleIndex) {
                case 4:
                        return filter_sempred((FilterContext)_localctx, predIndex);
                }
                return true;
        }

メンバ詳解

_ATN

final ATN org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser._ATN

static

初期値:

=
                new ATNDeserializer().deserialize(_serializedATN.toCharArray())

_decisionToDFA

final DFA [] org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser._decisionToDFA

staticprotected

_LITERAL_NAMES

final String [] org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser._LITERAL_NAMES

staticprivate

初期値:

= {
                null, "'eq'", "'ne'", "'co'", "'sw'", "'ew'", "'gt'", "'lt'", "'ge'",
                "'le'", "'pr'", "'not'", "'('", "')'", "'and'", "'or'", null, null, null,
                null, "'null'"
        }

_serializedATN

final String org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser._serializedATN

static

初期値:

=
                "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\33\64\4\2\t\2\4\3"+
                "\t\3\4\4\t\4\4\5\t\5\4\6\t\6\3\2\3\2\5\2\17\n\2\3\3\3\3\3\4\3\4\3\5\3"+
                "\5\3\5\3\5\3\5\3\5\3\5\5\5\34\n\5\3\6\3\6\5\6 \n\6\3\6\3\6\3\6\3\6\3\6"+
                "\5\6\'\n\6\3\6\3\6\3\6\3\6\3\6\3\6\7\6/\n\6\f\6\16\6\62\13\6\3\6\2\3\n"+
                "\7\2\4\6\b\n\2\4\3\2\3\13\4\2\24\26\33\33\64\2\f\3\2\2\2\4\20\3\2\2\2"+
                "\6\22\3\2\2\2\b\33\3\2\2\2\n&\3\2\2\2\f\16\7\31\2\2\r\17\7\32\2\2\16\r"+
                "\3\2\2\2\16\17\3\2\2\2\17\3\3\2\2\2\20\21\t\2\2\2\21\5\3\2\2\2\22\23\t"+
                "\3\2\2\23\7\3\2\2\2\24\25\5\2\2\2\25\26\7\f\2\2\26\34\3\2\2\2\27\30\5"+
                "\2\2\2\30\31\5\4\3\2\31\32\5\6\4\2\32\34\3\2\2\2\33\24\3\2\2\2\33\27\3"+
                "\2\2\2\34\t\3\2\2\2\35\37\b\6\1\2\36 \7\r\2\2\37\36\3\2\2\2\37 \3\2\2"+
                "\2 !\3\2\2\2!\"\7\16\2\2\"#\5\n\6\2#$\7\17\2\2$\'\3\2\2\2%\'\5\b\5\2&"+
                "\35\3\2\2\2&%\3\2\2\2\'\60\3\2\2\2()\f\5\2\2)*\7\20\2\2*/\5\n\6\6+,\f"+
                "\4\2\2,-\7\21\2\2-/\5\n\6\5.(\3\2\2\2.+\3\2\2\2/\62\3\2\2\2\60.\3\2\2"+
                "\2\60\61\3\2\2\2\61\13\3\2\2\2\62\60\3\2\2\2\b\16\33\37&.\60"

_sharedContextCache

final PredictionContextCache org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser._sharedContextCache

staticprotected

初期値:

=
                new PredictionContextCache()

_SYMBOLIC_NAMES

final String [] org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser._SYMBOLIC_NAMES

staticprivate

初期値:

= {
                null, null, null, null, null, null, null, null, null, null, null, null,
                null, null, null, null, "WHITESPACE", "ALPHA", "NUMBER", "BOOLEAN", "NULL",
                "NAMECHAR", "URI", "ATTRNAME", "SUBATTR", "STRING"
        }

ALPHA

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.ALPHA =17

staticpackage

ATTRNAME

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.ATTRNAME =23

staticpackage

BOOLEAN

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.BOOLEAN =19

staticpackage

NAMECHAR

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.NAMECHAR =21

staticpackage

NULL

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.NULL =20

staticpackage

NUMBER

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.NUMBER =18

staticpackage

RULE_attrexp

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.RULE_attrexp = 3

staticpackage

RULE_attrpath

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.RULE_attrpath = 0

static

RULE_compareop

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.RULE_compareop = 1

staticpackage

RULE_compvalue

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.RULE_compvalue = 2

staticpackage

RULE_filter

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.RULE_filter = 4

staticpackage

ruleNames

final String [] org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.ruleNames

static

初期値:

= {
                "attrpath", "compareop", "compvalue", "attrexp", "filter"
        }

STRING

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.STRING =25

staticpackage

SUBATTR

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.SUBATTR =24

staticpackage

T__0

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.T__0 =1

static

T__1

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.T__1 =2

staticpackage

T__10

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.T__10 =11

staticpackage

T__11

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.T__11 =12

staticpackage

T__12

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.T__12 =13

staticpackage

T__13

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.T__13 =14

staticpackage

T__14

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.T__14 =15

staticpackage

T__2

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.T__2 =3

staticpackage

T__3

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.T__3 =4

staticpackage

T__4

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.T__4 =5

staticpackage

T__5

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.T__5 =6

staticpackage

T__6

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.T__6 =7

staticpackage

T__7

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.T__7 =8

staticpackage

T__8

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.T__8 =9

staticpackage

T__9

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.T__9 =10

staticpackage

tokenNames

final String [] org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.tokenNames

static

非推奨:

Use VOCABULARY instead.

URI

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.URI =22

staticpackage

VOCABULARY

final Vocabulary org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES)

static

WHITESPACE

final int org.gluu.oxtrust.service.antlr.scimFilter.antlr4.ScimFilterParser.WHITESPACE =16

staticpackage

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/OpenId/gluu/src/oxTrust/server/src/main/java/org/gluu/oxtrust/service/antlr/scimFilter/antlr4/ScimFilterParser.java