View Javadoc
1   /*
2    *  Licensed to the Apache Software Foundation (ASF) under one
3    *  or more contributor license agreements.  See the NOTICE file
4    *  distributed with this work for additional information
5    *  regarding copyright ownership.  The ASF licenses this file
6    *  to you under the Apache License, Version 2.0 (the
7    *  "License"); you may not use this file except in compliance
8    *  with the License.  You may obtain a copy of the License at
9    *
10   *    http://www.apache.org/licenses/LICENSE-2.0
11   *
12   *  Unless required by applicable law or agreed to in writing,
13   *  software distributed under the License is distributed on an
14   *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   *  KIND, either express or implied.  See the License for the
16   *  specific language governing permissions and limitations
17   *  under the License.
18   *
19   */
20  package org.apache.directory.api.ldap.codec;
21  
22  
23  import static org.apache.directory.api.asn1.ber.tlv.UniversalTag.BOOLEAN;
24  import static org.apache.directory.api.asn1.ber.tlv.UniversalTag.ENUMERATED;
25  import static org.apache.directory.api.asn1.ber.tlv.UniversalTag.INTEGER;
26  import static org.apache.directory.api.asn1.ber.tlv.UniversalTag.OCTET_STRING;
27  import static org.apache.directory.api.asn1.ber.tlv.UniversalTag.SEQUENCE;
28  import static org.apache.directory.api.asn1.ber.tlv.UniversalTag.SET;
29  
30  import org.apache.directory.api.asn1.DecoderException;
31  import org.apache.directory.api.asn1.actions.CheckNotNullLength;
32  import org.apache.directory.api.asn1.ber.grammar.AbstractGrammar;
33  import org.apache.directory.api.asn1.ber.grammar.Grammar;
34  import org.apache.directory.api.asn1.ber.grammar.GrammarAction;
35  import org.apache.directory.api.asn1.ber.grammar.GrammarTransition;
36  import org.apache.directory.api.asn1.ber.tlv.TLV;
37  import org.apache.directory.api.i18n.I18n;
38  import org.apache.directory.api.ldap.codec.actions.AllowGrammarEnd;
39  import org.apache.directory.api.ldap.codec.actions.CheckLengthNotNull;
40  import org.apache.directory.api.ldap.codec.actions.abandonRequest.InitAbandonRequest;
41  import org.apache.directory.api.ldap.codec.actions.addRequest.AddAddRequestAttributeType;
42  import org.apache.directory.api.ldap.codec.actions.addRequest.AddAttributeValue;
43  import org.apache.directory.api.ldap.codec.actions.addRequest.InitAddRequest;
44  import org.apache.directory.api.ldap.codec.actions.addRequest.StoreAddRequestEntryName;
45  import org.apache.directory.api.ldap.codec.actions.addResponse.InitAddResponse;
46  import org.apache.directory.api.ldap.codec.actions.bindRequest.InitBindRequest;
47  import org.apache.directory.api.ldap.codec.actions.bindRequest.InitSaslBind;
48  import org.apache.directory.api.ldap.codec.actions.bindRequest.StoreName;
49  import org.apache.directory.api.ldap.codec.actions.bindRequest.StoreSaslCredentials;
50  import org.apache.directory.api.ldap.codec.actions.bindRequest.StoreSaslMechanism;
51  import org.apache.directory.api.ldap.codec.actions.bindRequest.StoreSimpleAuth;
52  import org.apache.directory.api.ldap.codec.actions.bindRequest.StoreVersion;
53  import org.apache.directory.api.ldap.codec.actions.bindResponse.InitBindResponse;
54  import org.apache.directory.api.ldap.codec.actions.bindResponse.StoreServerSASLCreds;
55  import org.apache.directory.api.ldap.codec.actions.compareRequest.InitCompareRequest;
56  import org.apache.directory.api.ldap.codec.actions.compareRequest.StoreCompareRequestAssertionValue;
57  import org.apache.directory.api.ldap.codec.actions.compareRequest.StoreCompareRequestAttributeDesc;
58  import org.apache.directory.api.ldap.codec.actions.compareRequest.StoreCompareRequestEntryName;
59  import org.apache.directory.api.ldap.codec.actions.compareResponse.InitCompareResponse;
60  import org.apache.directory.api.ldap.codec.actions.controls.AddControl;
61  import org.apache.directory.api.ldap.codec.actions.controls.InitControls;
62  import org.apache.directory.api.ldap.codec.actions.controls.StoreControlCriticality;
63  import org.apache.directory.api.ldap.codec.actions.controls.StoreControlValue;
64  import org.apache.directory.api.ldap.codec.actions.delRequest.InitDelRequest;
65  import org.apache.directory.api.ldap.codec.actions.delResponse.InitDelResponse;
66  import org.apache.directory.api.ldap.codec.actions.extendedRequest.InitExtendedRequest;
67  import org.apache.directory.api.ldap.codec.actions.extendedRequest.StoreExtendedRequestName;
68  import org.apache.directory.api.ldap.codec.actions.extendedRequest.StoreExtendedRequestValue;
69  import org.apache.directory.api.ldap.codec.actions.extendedResponse.InitExtendedResponse;
70  import org.apache.directory.api.ldap.codec.actions.extendedResponse.StoreExtendedResponseName;
71  import org.apache.directory.api.ldap.codec.actions.extendedResponse.StoreExtendedResponseValue;
72  import org.apache.directory.api.ldap.codec.actions.intermediateResponse.InitIntermediateResponse;
73  import org.apache.directory.api.ldap.codec.actions.intermediateResponse.StoreIntermediateResponseName;
74  import org.apache.directory.api.ldap.codec.actions.intermediateResponse.StoreIntermediateResponseValue;
75  import org.apache.directory.api.ldap.codec.actions.ldapMessage.InitLdapMessage;
76  import org.apache.directory.api.ldap.codec.actions.ldapMessage.StoreMessageId;
77  import org.apache.directory.api.ldap.codec.actions.ldapResult.AddReferral;
78  import org.apache.directory.api.ldap.codec.actions.ldapResult.InitReferrals;
79  import org.apache.directory.api.ldap.codec.actions.ldapResult.StoreErrorMessage;
80  import org.apache.directory.api.ldap.codec.actions.ldapResult.StoreMatchedDN;
81  import org.apache.directory.api.ldap.codec.actions.ldapResult.StoreResultCode;
82  import org.apache.directory.api.ldap.codec.actions.modifyDnRequest.InitModifyDnRequest;
83  import org.apache.directory.api.ldap.codec.actions.modifyDnRequest.StoreModifyDnRequestDeleteOldRdn;
84  import org.apache.directory.api.ldap.codec.actions.modifyDnRequest.StoreModifyDnRequestEntryName;
85  import org.apache.directory.api.ldap.codec.actions.modifyDnRequest.StoreModifyDnRequestNewRdn;
86  import org.apache.directory.api.ldap.codec.actions.modifyDnRequest.StoreModifyDnRequestNewSuperior;
87  import org.apache.directory.api.ldap.codec.actions.modifyDnResponse.InitModifyDnResponse;
88  import org.apache.directory.api.ldap.codec.actions.modifyRequest.AddModifyRequestAttribute;
89  import org.apache.directory.api.ldap.codec.actions.modifyRequest.InitAttributeVals;
90  import org.apache.directory.api.ldap.codec.actions.modifyRequest.InitModifyRequest;
91  import org.apache.directory.api.ldap.codec.actions.modifyRequest.StoreModifyRequestAttributeValue;
92  import org.apache.directory.api.ldap.codec.actions.modifyRequest.StoreModifyRequestObjectName;
93  import org.apache.directory.api.ldap.codec.actions.modifyRequest.StoreOperationType;
94  import org.apache.directory.api.ldap.codec.actions.modifyResponse.InitModifyResponse;
95  import org.apache.directory.api.ldap.codec.actions.searchRequest.InitSearchRequest;
96  import org.apache.directory.api.ldap.codec.actions.searchRequest.InitSearchRequestAttributeDescList;
97  import org.apache.directory.api.ldap.codec.actions.searchRequest.StoreSearchRequestAttributeDesc;
98  import org.apache.directory.api.ldap.codec.actions.searchRequest.StoreSearchRequestBaseObject;
99  import org.apache.directory.api.ldap.codec.actions.searchRequest.StoreSearchRequestDerefAlias;
100 import org.apache.directory.api.ldap.codec.actions.searchRequest.StoreSearchRequestScope;
101 import org.apache.directory.api.ldap.codec.actions.searchRequest.StoreSearchRequestSizeLimit;
102 import org.apache.directory.api.ldap.codec.actions.searchRequest.StoreSearchRequestTimeLimit;
103 import org.apache.directory.api.ldap.codec.actions.searchRequest.StoreSearchRequestTypesOnly;
104 import org.apache.directory.api.ldap.codec.actions.searchRequest.StoreTypeMatchingRule;
105 import org.apache.directory.api.ldap.codec.actions.searchRequest.filter.InitAndFilter;
106 import org.apache.directory.api.ldap.codec.actions.searchRequest.filter.InitApproxMatchFilter;
107 import org.apache.directory.api.ldap.codec.actions.searchRequest.filter.InitAssertionValueFilter;
108 import org.apache.directory.api.ldap.codec.actions.searchRequest.filter.InitAttributeDescFilter;
109 import org.apache.directory.api.ldap.codec.actions.searchRequest.filter.InitEqualityMatchFilter;
110 import org.apache.directory.api.ldap.codec.actions.searchRequest.filter.InitExtensibleMatchFilter;
111 import org.apache.directory.api.ldap.codec.actions.searchRequest.filter.InitGreaterOrEqualFilter;
112 import org.apache.directory.api.ldap.codec.actions.searchRequest.filter.InitLessOrEqualFilter;
113 import org.apache.directory.api.ldap.codec.actions.searchRequest.filter.InitNotFilter;
114 import org.apache.directory.api.ldap.codec.actions.searchRequest.filter.InitOrFilter;
115 import org.apache.directory.api.ldap.codec.actions.searchRequest.filter.InitPresentFilter;
116 import org.apache.directory.api.ldap.codec.actions.searchRequest.filter.InitSubstringsFilter;
117 import org.apache.directory.api.ldap.codec.actions.searchRequest.filter.StoreAny;
118 import org.apache.directory.api.ldap.codec.actions.searchRequest.filter.StoreFinal;
119 import org.apache.directory.api.ldap.codec.actions.searchRequest.filter.StoreInitial;
120 import org.apache.directory.api.ldap.codec.actions.searchRequest.filter.StoreMatchValue;
121 import org.apache.directory.api.ldap.codec.actions.searchRequest.filter.StoreMatchingRuleDnAttributes;
122 import org.apache.directory.api.ldap.codec.actions.searchRequest.filter.StoreSubstringFilterType;
123 import org.apache.directory.api.ldap.codec.actions.searchResultDone.InitSearchResultDone;
124 import org.apache.directory.api.ldap.codec.actions.searchResultEntry.AddAttributeType;
125 import org.apache.directory.api.ldap.codec.actions.searchResultEntry.InitSearchResultEntry;
126 import org.apache.directory.api.ldap.codec.actions.searchResultEntry.StoreSearchResultAttributeValue;
127 import org.apache.directory.api.ldap.codec.actions.searchResultEntry.StoreSearchResultEntryObjectName;
128 import org.apache.directory.api.ldap.codec.actions.searchResultReference.InitSearchResultReference;
129 import org.apache.directory.api.ldap.codec.actions.searchResultReference.StoreReference;
130 import org.apache.directory.api.ldap.codec.actions.unbindRequest.InitUnbindRequest;
131 import org.apache.directory.api.ldap.codec.api.LdapConstants;
132 import org.apache.directory.api.ldap.codec.api.LdapMessageContainer;
133 import org.apache.directory.api.ldap.codec.api.MessageDecorator;
134 import org.apache.directory.api.ldap.codec.decorators.SearchRequestDecorator;
135 import org.apache.directory.api.ldap.codec.search.ExtensibleMatchFilter;
136 import org.apache.directory.api.ldap.model.message.Message;
137 import org.apache.directory.api.util.Strings;
138 import org.slf4j.Logger;
139 import org.slf4j.LoggerFactory;
140 
141 
142 /**
143  * This class implements the LdapMessage message. All the actions are declared
144  * in this class. As it is a singleton, these declaration are only done once. If
145  * an action is to be added or modified, this is where the work is to be done !
146  *
147  * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
148  */
149 public final class LdapMessageGrammar<E> extends
150     AbstractGrammar<LdapMessageContainer<MessageDecorator<? extends Message>>>
151 {
152     /** The logger */
153     static final Logger LOG = LoggerFactory.getLogger( LdapMessageGrammar.class );
154 
155     /** A speedup for logger */
156     static final boolean IS_DEBUG = LOG.isDebugEnabled();
157 
158     /** The instance of grammar. LdapMessageGrammar is a singleton */
159     private static Grammar<LdapMessageContainer<MessageDecorator<? extends Message>>> instance =
160         new LdapMessageGrammar<LdapMessageContainer<MessageDecorator<? extends Message>>>();
161 
162 
163     /**
164      * Creates a new LdapMessageGrammar object.
165      */
166     @SuppressWarnings(
167         { "unchecked", "rawtypes" })
168     private LdapMessageGrammar()
169     {
170 
171         setName( LdapMessageGrammar.class.getName() );
172 
173         // Create the transitions table
174         super.transitions = new GrammarTransition[LdapStatesEnum.LAST_LDAP_STATE.ordinal()][256];
175 
176         // ============================================================================================
177         // Transition from START to LdapMessage
178         // ============================================================================================
179         // This is the starting state :
180         // LDAPMessage --> SEQUENCE { ...
181         //
182         // We have a LDAPMessage, and the tag must be 0x30.
183         //
184         // The next state will be LDAP_MESSAGE_STATE
185         //
186         // We will just check that the length is not null
187         super.transitions[LdapStatesEnum.START_STATE.ordinal()][SEQUENCE.getValue()] =
188             new GrammarTransition<LdapMessageContainer<MessageDecorator<? extends Message>>>(
189                 LdapStatesEnum.START_STATE,
190                 LdapStatesEnum.LDAP_MESSAGE_STATE,
191                 SEQUENCE,
192                 new InitLdapMessage() );
193 
194         // --------------------------------------------------------------------------------------------
195         // Transition from LdapMessage to Message ID
196         // --------------------------------------------------------------------------------------------
197         // LDAPMessage --> ... MessageId ...
198         //
199         // Checks that MessageId is in [0 .. 2147483647] and store the value in
200         // the LdapMessage Object
201         //
202         // (2147483647 = Integer.MAX_VALUE)
203         // The next state will be MESSAGE_ID_STATE
204         //
205         // The message ID will be temporarily stored in the container, because we can't store it
206         // into an object.
207         super.transitions[LdapStatesEnum.LDAP_MESSAGE_STATE.ordinal()][INTEGER.getValue()] =
208             new GrammarTransition<LdapMessageContainer<MessageDecorator<? extends Message>>>(
209                 LdapStatesEnum.LDAP_MESSAGE_STATE,
210                 LdapStatesEnum.MESSAGE_ID_STATE,
211                 INTEGER,
212                 new StoreMessageId() );
213 
214         // ********************************************************************************************
215         // We have a ProtocolOp :
216         // If the Tag is 0x42, then it's an UnBindRequest.
217         // If the Tag is 0x4A, then it's a DelRequest.
218         // If the Tag is 0x50, then it's an AbandonRequest.
219         // If the Tag is 0x60, then it's a BindRequest.
220         // If the Tag is 0x61, then it's a BindResponse.
221         // If the Tag is 0x63, then it's a SearchRequest.
222         // If the Tag is 0x64, then it's a SearchResultEntry.
223         // If the Tag is 0x65, then it's a SearchResultDone
224         // If the Tag is 0x66, then it's a ModifyRequest
225         // If the Tag is 0x67, then it's a ModifyResponse.
226         // If the Tag is 0x68, then it's an AddRequest.
227         // If the Tag is 0x69, then it's an AddResponse.
228         // If the Tag is 0x6B, then it's a DelResponse.
229         // If the Tag is 0x6C, then it's a ModifyDNRequest.
230         // If the Tag is 0x6D, then it's a ModifyDNResponse.
231         // If the Tag is 0x6E, then it's a CompareRequest
232         // If the Tag is 0x6F, then it's a CompareResponse.
233         // If the Tag is 0x73, then it's a SearchResultReference.
234         // If the Tag is 0x77, then it's an ExtendedRequest.
235         // If the Tag is 0x78, then it's an ExtendedResponse.
236         //
237         // We create the associated object in this transition, and store it into the container.
238         // ********************************************************************************************
239 
240         // --------------------------------------------------------------------------------------------
241         // Transition from Message ID to UnBindRequest Message.
242         // --------------------------------------------------------------------------------------------
243         // LdapMessage ::= ... UnBindRequest ...
244         // unbindRequest ::= [APPLICATION 2] NULL
245         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.UNBIND_REQUEST_TAG] =
246             new GrammarTransition(
247                 LdapStatesEnum.MESSAGE_ID_STATE,
248                 LdapStatesEnum.UNBIND_REQUEST_STATE,
249                 LdapConstants.UNBIND_REQUEST_TAG,
250                 new InitUnbindRequest() );
251 
252         // --------------------------------------------------------------------------------------------
253         // transition from UnBindRequest Message to Controls.
254         // --------------------------------------------------------------------------------------------
255         //         unbindRequest   UnbindRequest,
256         //         ... },
257         //     controls       [0] Controls OPTIONAL }
258         //
259         super.transitions[LdapStatesEnum.UNBIND_REQUEST_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
260             new GrammarTransition(
261                 LdapStatesEnum.UNBIND_REQUEST_STATE,
262                 LdapStatesEnum.CONTROLS_STATE,
263                 LdapConstants.CONTROLS_TAG,
264                 new InitControls() );
265 
266         // --------------------------------------------------------------------------------------------
267         // Transition from Message ID to DelRequest Message.
268         // --------------------------------------------------------------------------------------------
269         // LdapMessage ::= ... DelRequest ...
270         // delRequest ::= [APPLICATION 10] LDAPDN
271         //
272         // We store the Dn to bve deleted into the DelRequest object
273         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.DEL_REQUEST_TAG] =
274             new GrammarTransition(
275                 LdapStatesEnum.MESSAGE_ID_STATE,
276                 LdapStatesEnum.DEL_REQUEST_STATE,
277                 LdapConstants.DEL_REQUEST_TAG,
278                 new InitDelRequest() );
279 
280         // --------------------------------------------------------------------------------------------
281         // transition from DelRequest Message to Controls.
282         // --------------------------------------------------------------------------------------------
283         //         delRequest   DelRequest,
284         //         ... },
285         //     controls       [0] Controls OPTIONAL }
286         //
287         super.transitions[LdapStatesEnum.DEL_REQUEST_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
288             new GrammarTransition(
289                 LdapStatesEnum.DEL_REQUEST_STATE,
290                 LdapStatesEnum.CONTROLS_STATE,
291                 LdapConstants.CONTROLS_TAG,
292                 new InitControls() );
293 
294         // --------------------------------------------------------------------------------------------
295         // Transition from Message ID to AbandonRequest Message.
296         // --------------------------------------------------------------------------------------------
297         // LdapMessage ::= ... AbandonRequest ...
298         // AbandonRequest ::= [APPLICATION 16] MessageID
299         //
300         // Create the AbandonRequest object, and store the ID in it
301         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.ABANDON_REQUEST_TAG] =
302             new GrammarTransition(
303                 LdapStatesEnum.MESSAGE_ID_STATE,
304                 LdapStatesEnum.ABANDON_REQUEST_STATE,
305                 LdapConstants.ABANDON_REQUEST_TAG,
306                 new InitAbandonRequest() );
307 
308         // --------------------------------------------------------------------------------------------
309         // transition from AbandonRequest Message to Controls.
310         // --------------------------------------------------------------------------------------------
311         //         abandonRequest   AbandonRequest,
312         //         ... },
313         //     controls       [0] Controls OPTIONAL }
314         //
315         super.transitions[LdapStatesEnum.ABANDON_REQUEST_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
316             new GrammarTransition(
317                 LdapStatesEnum.ABANDON_REQUEST_STATE,
318                 LdapStatesEnum.CONTROLS_STATE,
319                 LdapConstants.CONTROLS_TAG,
320                 new InitControls() );
321 
322         // --------------------------------------------------------------------------------------------
323         // Transition from Message ID to BindRequest Message.
324         // --------------------------------------------------------------------------------------------
325         // LdapMessage ::= ... BindRequest ...
326         // BindRequest ::= [APPLICATION 0] SEQUENCE { ...
327         //
328         // We have to allocate a BindRequest
329         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.BIND_REQUEST_TAG] =
330             new GrammarTransition(
331                 LdapStatesEnum.MESSAGE_ID_STATE,
332                 LdapStatesEnum.BIND_REQUEST_STATE,
333                 LdapConstants.BIND_REQUEST_TAG,
334                 new InitBindRequest() );
335 
336         // --------------------------------------------------------------------------------------------
337         // Transition from BindRequest to version
338         // --------------------------------------------------------------------------------------------
339         // BindRequest ::= [APPLICATION 0] SEQUENCE {
340         //     version                 INTEGER (1 ..  127),
341         //     ....
342         //
343         // The Ldap version is parsed and stored into the BindRequest object
344         super.transitions[LdapStatesEnum.BIND_REQUEST_STATE.ordinal()][INTEGER.getValue()] =
345             new GrammarTransition(
346                 LdapStatesEnum.BIND_REQUEST_STATE,
347                 LdapStatesEnum.VERSION_STATE,
348                 INTEGER,
349                 new StoreVersion() );
350 
351         // --------------------------------------------------------------------------------------------
352         // Transition from version to name
353         // --------------------------------------------------------------------------------------------
354         // BindRequest ::= [APPLICATION 0] SEQUENCE {
355         //     ....
356         //     name                    LDAPDN,
357         //     ....
358         //
359         // The Ldap name is stored into the BindRequest object
360         super.transitions[LdapStatesEnum.VERSION_STATE.ordinal()][OCTET_STRING.getValue()] =
361             new GrammarTransition(
362                 LdapStatesEnum.VERSION_STATE,
363                 LdapStatesEnum.NAME_STATE,
364                 OCTET_STRING,
365                 new StoreName() );
366 
367         // --------------------------------------------------------------------------------------------
368         // Transition from name to Simple Authentication
369         // --------------------------------------------------------------------------------------------
370         // BindRequest ::= [APPLICATION 0] SEQUENCE {
371         //     ....
372         //     authentication          AuthenticationChoice }
373         //
374         // AuthenticationChoice ::= CHOICE {
375         //     simple                  [0] OCTET STRING,
376         //     ...
377         //
378         // We have to create an Authentication Object to store the credentials.
379         super.transitions[LdapStatesEnum.NAME_STATE.ordinal()][LdapConstants.BIND_REQUEST_SIMPLE_TAG] =
380             new GrammarTransition(
381                 LdapStatesEnum.NAME_STATE,
382                 LdapStatesEnum.SIMPLE_STATE,
383                 LdapConstants.BIND_REQUEST_SIMPLE_TAG,
384                 new StoreSimpleAuth() );
385 
386         // --------------------------------------------------------------------------------------------
387         // transition from Simple Authentication to Controls.
388         // --------------------------------------------------------------------------------------------
389         //         bindRequest   BindRequest,
390         //         ... },
391         //     controls       [0] Controls OPTIONAL }
392         //
393         super.transitions[LdapStatesEnum.SIMPLE_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
394             new GrammarTransition(
395                 LdapStatesEnum.SIMPLE_STATE,
396                 LdapStatesEnum.CONTROLS_STATE,
397                 LdapConstants.CONTROLS_TAG,
398                 new InitControls() );
399 
400         // --------------------------------------------------------------------------------------------
401         // Transition from name to SASL Authentication
402         // --------------------------------------------------------------------------------------------
403         // BindRequest ::= [APPLICATION 0] SEQUENCE {
404         //     ....
405         //     authentication          AuthenticationChoice }
406         //
407         // AuthenticationChoice ::= CHOICE {
408         //     ...
409         //     sasl                  [3] SaslCredentials }
410         //     ...
411         //
412         // We have to create an Authentication Object to store the credentials.
413         super.transitions[LdapStatesEnum.NAME_STATE.ordinal()][LdapConstants.BIND_REQUEST_SASL_TAG] =
414             new GrammarTransition(
415                 LdapStatesEnum.NAME_STATE,
416                 LdapStatesEnum.SASL_STATE,
417                 LdapConstants.BIND_REQUEST_SASL_TAG,
418                 new InitSaslBind() );
419 
420         // --------------------------------------------------------------------------------------------
421         // Transition from SASL Authentication to Mechanism
422         // --------------------------------------------------------------------------------------------
423         // SaslCredentials ::= SEQUENCE {
424         //     mechanism   LDAPSTRING,
425         //     ...
426         //
427         // We have to store the mechanism.
428         super.transitions[LdapStatesEnum.SASL_STATE.ordinal()][OCTET_STRING.getValue()] =
429             new GrammarTransition(
430                 LdapStatesEnum.SASL_STATE,
431                 LdapStatesEnum.MECHANISM_STATE,
432                 OCTET_STRING,
433                 new StoreSaslMechanism() );
434 
435         // --------------------------------------------------------------------------------------------
436         // Transition from Mechanism to Credentials
437         // --------------------------------------------------------------------------------------------
438         // SaslCredentials ::= SEQUENCE {
439         //     ...
440         //     credentials OCTET STRING OPTIONAL }
441         //
442         // We have to store the mechanism.
443         super.transitions[LdapStatesEnum.MECHANISM_STATE.ordinal()][OCTET_STRING.getValue()] =
444             new GrammarTransition(
445                 LdapStatesEnum.MECHANISM_STATE,
446                 LdapStatesEnum.CREDENTIALS_STATE,
447                 OCTET_STRING,
448                 new StoreSaslCredentials() );
449 
450         // --------------------------------------------------------------------------------------------
451         // transition from from Mechanism to Controls.
452         // --------------------------------------------------------------------------------------------
453         //         bindRequest   BindRequest,
454         //         ... },
455         //     controls       [0] Controls OPTIONAL }
456         //
457         super.transitions[LdapStatesEnum.MECHANISM_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
458             new GrammarTransition(
459                 LdapStatesEnum.MECHANISM_STATE,
460                 LdapStatesEnum.CONTROLS_STATE,
461                 LdapConstants.CONTROLS_TAG,
462                 new InitControls() );
463 
464         // --------------------------------------------------------------------------------------------
465         // transition from credentials to Controls.
466         // --------------------------------------------------------------------------------------------
467         //         bindRequest   BindRequest,
468         //         ... },
469         //     controls       [0] Controls OPTIONAL }
470         //
471         super.transitions[LdapStatesEnum.CREDENTIALS_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
472             new GrammarTransition(
473                 LdapStatesEnum.CREDENTIALS_STATE,
474                 LdapStatesEnum.CONTROLS_STATE,
475                 LdapConstants.CONTROLS_TAG,
476                 new InitControls() );
477 
478         // --------------------------------------------------------------------------------------------
479         // Transition from MessageId to BindResponse message
480         // --------------------------------------------------------------------------------------------
481         // LdapMessage ::= ... BindResponse ...
482         // BindResponse ::= [APPLICATION 1] SEQUENCE { ...
483         // We have to switch to the BindResponse grammar
484         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.BIND_RESPONSE_TAG] =
485             new GrammarTransition(
486                 LdapStatesEnum.MESSAGE_ID_STATE,
487                 LdapStatesEnum.BIND_RESPONSE_STATE,
488                 LdapConstants.BIND_RESPONSE_TAG,
489                 new InitBindResponse() );
490 
491         // --------------------------------------------------------------------------------------------
492         // Transition from BindResponse message to Result Code BR
493         // --------------------------------------------------------------------------------------------
494         // BindResponse ::= [APPLICATION 1] SEQUENCE {
495         //     COMPONENTS OF LDAPResult,
496         //     ...
497         //
498         // LDAPResult ::= SEQUENCE {
499         //     resultCode ENUMERATED {
500         //         ...
501         //
502         // Stores the result code into the Bind Response object
503         super.transitions[LdapStatesEnum.BIND_RESPONSE_STATE.ordinal()][ENUMERATED.getValue()] =
504             new GrammarTransition(
505                 LdapStatesEnum.BIND_RESPONSE_STATE,
506                 LdapStatesEnum.RESULT_CODE_BR_STATE,
507                 ENUMERATED,
508                 new StoreResultCode() );
509 
510         // --------------------------------------------------------------------------------------------
511         // Transition from Result Code BR to Matched Dn BR
512         // --------------------------------------------------------------------------------------------
513         // LDAPResult ::= SEQUENCE {
514         //     ...
515         //     matchedDN LDAPDN,
516         //     ...
517         //
518         // Stores the matched Dn
519         super.transitions[LdapStatesEnum.RESULT_CODE_BR_STATE.ordinal()][OCTET_STRING.getValue()] =
520             new GrammarTransition(
521                 LdapStatesEnum.RESULT_CODE_BR_STATE,
522                 LdapStatesEnum.MATCHED_DN_BR_STATE,
523                 OCTET_STRING,
524                 new StoreMatchedDN() );
525 
526         // --------------------------------------------------------------------------------------------
527         // Transition from Matched Dn BR to Error Message BR
528         // --------------------------------------------------------------------------------------------
529         // LDAPResult ::= SEQUENCE {
530         //     ...
531         //     errorMessage LDAPString,
532         //     ...
533         //
534         // Stores the error message
535         super.transitions[LdapStatesEnum.MATCHED_DN_BR_STATE.ordinal()][OCTET_STRING.getValue()] =
536             new GrammarTransition(
537                 LdapStatesEnum.MATCHED_DN_BR_STATE,
538                 LdapStatesEnum.ERROR_MESSAGE_BR_STATE,
539                 OCTET_STRING,
540                 new StoreErrorMessage() );
541 
542         // --------------------------------------------------------------------------------------------
543         // Transition from Error Message BR to Server SASL credentials
544         // --------------------------------------------------------------------------------------------
545         // BindResponse ::= APPLICATION 1] SEQUENCE {
546         //     ...
547         //     serverSaslCreds [7] OCTET STRING OPTIONAL }
548         //
549         // Stores the sasl credentials
550         super.transitions[LdapStatesEnum.ERROR_MESSAGE_BR_STATE.ordinal()][LdapConstants.SERVER_SASL_CREDENTIAL_TAG] =
551             new GrammarTransition(
552                 LdapStatesEnum.ERROR_MESSAGE_BR_STATE,
553                 LdapStatesEnum.SERVER_SASL_CREDENTIALS_STATE,
554                 LdapConstants.SERVER_SASL_CREDENTIAL_TAG,
555                 new StoreServerSASLCreds() );
556 
557         // --------------------------------------------------------------------------------------------
558         // Transition from Error Message BR to Referrals BR
559         // --------------------------------------------------------------------------------------------
560         // LDAPResult ::= SEQUENCE {
561         //     ...
562         //     referral   [3] Referral OPTIONNAL }
563         //
564         // Initialiaze the referrals list
565         super.transitions[LdapStatesEnum.ERROR_MESSAGE_BR_STATE.ordinal()][LdapConstants.LDAP_RESULT_REFERRAL_SEQUENCE_TAG] =
566             new GrammarTransition(
567                 LdapStatesEnum.ERROR_MESSAGE_BR_STATE,
568                 LdapStatesEnum.REFERRALS_BR_STATE,
569                 LdapConstants.LDAP_RESULT_REFERRAL_SEQUENCE_TAG,
570                 new InitReferrals() );
571 
572         // --------------------------------------------------------------------------------------------
573         // Transition from Referrals BR to Referral BR
574         // --------------------------------------------------------------------------------------------
575         // Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI (RFC 4511)
576         // URI ::= LDAPString
577         //
578         // Add a first Referral
579         super.transitions[LdapStatesEnum.REFERRALS_BR_STATE.ordinal()][OCTET_STRING.getValue()] =
580             new GrammarTransition(
581                 LdapStatesEnum.REFERRALS_BR_STATE,
582                 LdapStatesEnum.REFERRAL_BR_STATE,
583                 OCTET_STRING,
584                 new AddReferral() );
585 
586         // --------------------------------------------------------------------------------------------
587         // Transition from Referral BR to Referral BR
588         // --------------------------------------------------------------------------------------------
589         // Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI (RFC 4511)
590         // URI ::= LDAPString
591         //
592         // Adda new Referral
593         super.transitions[LdapStatesEnum.REFERRAL_BR_STATE.ordinal()][OCTET_STRING.getValue()] =
594             new GrammarTransition(
595                 LdapStatesEnum.REFERRAL_BR_STATE,
596                 LdapStatesEnum.REFERRAL_BR_STATE,
597                 OCTET_STRING,
598                 new AddReferral() );
599 
600         // --------------------------------------------------------------------------------------------
601         // Transition from Referral BR to Server SASL Credentials
602         // --------------------------------------------------------------------------------------------
603         // Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI (RFC 4511)
604         // URI ::= LDAPString
605         //
606         // Adda new Referral
607         super.transitions[LdapStatesEnum.REFERRAL_BR_STATE.ordinal()][LdapConstants.SERVER_SASL_CREDENTIAL_TAG] =
608             new GrammarTransition(
609                 LdapStatesEnum.REFERRAL_BR_STATE,
610                 LdapStatesEnum.SERVER_SASL_CREDENTIALS_STATE,
611                 LdapConstants.SERVER_SASL_CREDENTIAL_TAG,
612                 new StoreServerSASLCreds() );
613 
614         // --------------------------------------------------------------------------------------------
615         // Transition from Referral BR to Controls
616         // --------------------------------------------------------------------------------------------
617         //         bindResponse   BindResponse,
618         //         ... },
619         //     controls       [0] Controls OPTIONAL }
620         //
621         // Adda new Referral
622         super.transitions[LdapStatesEnum.REFERRAL_BR_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
623             new GrammarTransition(
624                 LdapStatesEnum.REFERRAL_BR_STATE,
625                 LdapStatesEnum.CONTROLS_STATE,
626                 LdapConstants.CONTROLS_TAG,
627                 new InitControls() );
628 
629         // --------------------------------------------------------------------------------------------
630         // Transition from Error Message BR to controls
631         // --------------------------------------------------------------------------------------------
632         //         bindResponse   BindResponse,
633         //         ... },
634         //     controls       [0] Controls OPTIONAL }
635         //
636         //
637         super.transitions[LdapStatesEnum.ERROR_MESSAGE_BR_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
638             new GrammarTransition(
639                 LdapStatesEnum.ERROR_MESSAGE_BR_STATE,
640                 LdapStatesEnum.CONTROLS_STATE,
641                 LdapConstants.CONTROLS_TAG,
642                 new InitControls() );
643 
644         // --------------------------------------------------------------------------------------------
645         // Transition from Server SASL credentials to Controls
646         // --------------------------------------------------------------------------------------------
647         //         bindResponse   BindResponse,
648         //         ... },
649         //     controls       [0] Controls OPTIONAL }
650         //
651         super.transitions[LdapStatesEnum.SERVER_SASL_CREDENTIALS_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
652             new GrammarTransition(
653                 LdapStatesEnum.SERVER_SASL_CREDENTIALS_STATE,
654                 LdapStatesEnum.CONTROLS_STATE,
655                 LdapConstants.CONTROLS_TAG,
656                 new InitControls() );
657 
658         // --------------------------------------------------------------------------------------------
659         // Transition from Result Code to Matched Dn
660         // --------------------------------------------------------------------------------------------
661         // LDAPResult ::= SEQUENCE {
662         //     ...
663         //     matchedDN LDAPDN,
664         //     ...
665         //
666         // Stores the matched Dn
667         super.transitions[LdapStatesEnum.RESULT_CODE_STATE.ordinal()][OCTET_STRING.getValue()] =
668             new GrammarTransition(
669                 LdapStatesEnum.RESULT_CODE_STATE,
670                 LdapStatesEnum.MATCHED_DN_STATE,
671                 OCTET_STRING,
672                 new StoreMatchedDN() );
673 
674         // --------------------------------------------------------------------------------------------
675         // Transition from Matched Dn to Error Message
676         // --------------------------------------------------------------------------------------------
677         // LDAPResult ::= SEQUENCE {
678         //     ...
679         //     errorMessage LDAPString,
680         //     ...
681         //
682         // Stores the error message
683         super.transitions[LdapStatesEnum.MATCHED_DN_STATE.ordinal()][OCTET_STRING.getValue()] =
684             new GrammarTransition(
685                 LdapStatesEnum.MATCHED_DN_STATE,
686                 LdapStatesEnum.ERROR_MESSAGE_STATE,
687                 OCTET_STRING,
688                 new StoreErrorMessage() );
689 
690         // --------------------------------------------------------------------------------------------
691         // Transition from Error Message to Referrals
692         // --------------------------------------------------------------------------------------------
693         // LDAPResult ::= SEQUENCE {
694         //     ...
695         //     referral   [3] Referral OPTIONNAL }
696         //
697         // Initialize the referrals list
698         super.transitions[LdapStatesEnum.ERROR_MESSAGE_STATE.ordinal()][LdapConstants.LDAP_RESULT_REFERRAL_SEQUENCE_TAG] =
699             new GrammarTransition(
700                 LdapStatesEnum.ERROR_MESSAGE_STATE,
701                 LdapStatesEnum.REFERRALS_STATE,
702                 LdapConstants.LDAP_RESULT_REFERRAL_SEQUENCE_TAG,
703                 new InitReferrals() );
704 
705         // --------------------------------------------------------------------------------------------
706         // Transition from Referrals to Referral
707         // --------------------------------------------------------------------------------------------
708         // Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI (RFC 4511)
709         // URI ::= LDAPString
710         //
711         // Add a first Referral
712         super.transitions[LdapStatesEnum.REFERRALS_STATE.ordinal()][OCTET_STRING.getValue()] =
713             new GrammarTransition(
714                 LdapStatesEnum.REFERRALS_STATE,
715                 LdapStatesEnum.REFERRAL_STATE,
716                 OCTET_STRING,
717                 new AddReferral() );
718 
719         // --------------------------------------------------------------------------------------------
720         // Transition from Referral to Referral
721         // --------------------------------------------------------------------------------------------
722         // Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI (RFC 4511)
723         // URI ::= LDAPString
724         //
725         // Adda new Referral
726         super.transitions[LdapStatesEnum.REFERRAL_STATE.ordinal()][OCTET_STRING.getValue()] =
727             new GrammarTransition(
728                 LdapStatesEnum.REFERRAL_STATE,
729                 LdapStatesEnum.REFERRAL_STATE,
730                 OCTET_STRING,
731                 new AddReferral() );
732 
733         // --------------------------------------------------------------------------------------------
734         // Transition from Referral to Controls
735         // --------------------------------------------------------------------------------------------
736         //         xxxResponse   xxxResponse,
737         //         ... },
738         //     controls       [0] Controls OPTIONAL }
739         //
740         // Adda new Referral
741         super.transitions[LdapStatesEnum.REFERRAL_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
742             new GrammarTransition(
743                 LdapStatesEnum.REFERRAL_STATE,
744                 LdapStatesEnum.CONTROLS_STATE,
745                 LdapConstants.CONTROLS_TAG,
746                 new InitControls() );
747 
748         // --------------------------------------------------------------------------------------------
749         // Transition from Error Message to controls
750         // --------------------------------------------------------------------------------------------
751         //         xxxResponse   xxxResponse,
752         //         ... },
753         //     controls       [0] Controls OPTIONAL }
754         //
755         //
756         super.transitions[LdapStatesEnum.ERROR_MESSAGE_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
757             new GrammarTransition(
758                 LdapStatesEnum.ERROR_MESSAGE_STATE,
759                 LdapStatesEnum.CONTROLS_STATE,
760                 LdapConstants.CONTROLS_TAG,
761                 new InitControls() );
762 
763         // --------------------------------------------------------------------------------------------
764         // Transition from MessageId to SearchResultEntry Message.
765         // --------------------------------------------------------------------------------------------
766         // LdapMessage ::= ... SearchResultEntry ...
767         // SearchResultEntry ::= [APPLICATION 4] SEQUENCE { ...
768         //
769         // Initialize the searchResultEntry object
770         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.SEARCH_RESULT_ENTRY_TAG] =
771             new GrammarTransition(
772                 LdapStatesEnum.MESSAGE_ID_STATE,
773                 LdapStatesEnum.SEARCH_RESULT_ENTRY_STATE,
774                 LdapConstants.SEARCH_RESULT_ENTRY_TAG,
775                 new InitSearchResultEntry() );
776 
777         // --------------------------------------------------------------------------------------------
778         // Transition from SearchResultEntry Message to ObjectName
779         // --------------------------------------------------------------------------------------------
780         // SearchResultEntry ::= [APPLICATION 4] SEQUENCE { ...
781         // objectName LDAPDN,
782         // ...
783         //
784         // Store the object name.
785         super.transitions[LdapStatesEnum.SEARCH_RESULT_ENTRY_STATE.ordinal()][OCTET_STRING.getValue()] =
786             new GrammarTransition(
787                 LdapStatesEnum.SEARCH_RESULT_ENTRY_STATE,
788                 LdapStatesEnum.OBJECT_NAME_STATE,
789                 OCTET_STRING,
790                 new StoreSearchResultEntryObjectName() );
791 
792         // --------------------------------------------------------------------------------------------
793         // Transition from ObjectName to AttributesSR
794         // --------------------------------------------------------------------------------------------
795         // SearchResultEntry ::= [APPLICATION 4] SEQUENCE { ...
796         // ...
797         // attributes PartialAttributeList }
798         //
799         // PartialAttributeList ::= *SEQUENCE* OF SEQUENCE {
800         // ...
801         //
802         // We may have no attributes. Just allows the grammar to end
803         super.transitions[LdapStatesEnum.OBJECT_NAME_STATE.ordinal()][SEQUENCE.getValue()] =
804             new GrammarTransition(
805                 LdapStatesEnum.OBJECT_NAME_STATE,
806                 LdapStatesEnum.ATTRIBUTES_SR_STATE,
807                 SEQUENCE,
808                 new AllowGrammarEnd() );
809 
810         // --------------------------------------------------------------------------------------------
811         // Transition from AttributesSR to PartialAttributesList
812         // --------------------------------------------------------------------------------------------
813         // SearchResultEntry ::= [APPLICATION 4] SEQUENCE { ...
814         // ...
815         // attributes PartialAttributeList }
816         //
817         // PartialAttributeList ::= SEQUENCE OF *SEQUENCE* {
818         // ...
819         //
820         // nothing to do
821         super.transitions[LdapStatesEnum.ATTRIBUTES_SR_STATE.ordinal()][SEQUENCE.getValue()] =
822             new GrammarTransition(
823                 LdapStatesEnum.ATTRIBUTES_SR_STATE,
824                 LdapStatesEnum.PARTIAL_ATTRIBUTES_LIST_STATE,
825                 SEQUENCE,
826                 null );
827 
828         // --------------------------------------------------------------------------------------------
829         // Transition from AttributesSR to Controls
830         // --------------------------------------------------------------------------------------------
831         //     searchResultEntry SearchResultEntry,
832         //     ... },
833         // controls   [0] Controls OPTIONAL }
834         //
835         // Initialize the controls
836         super.transitions[LdapStatesEnum.ATTRIBUTES_SR_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
837             new GrammarTransition(
838                 LdapStatesEnum.ATTRIBUTES_SR_STATE,
839                 LdapStatesEnum.CONTROLS_STATE,
840                 LdapConstants.CONTROLS_TAG,
841                 new InitControls() );
842 
843         // --------------------------------------------------------------------------------------------
844         // Transition from PartialAttributesList to typeSR
845         // --------------------------------------------------------------------------------------------
846         // SearchResultEntry ::= [APPLICATION 4] SEQUENCE { ...
847         // ...
848         // attributes PartialAttributeList }
849         //
850         // PartialAttributeList ::= SEQUENCE OF SEQUENCE {
851         //     type  AttributeDescription,
852         //     ...
853         //
854         // Store the attribute's name.
855         super.transitions[LdapStatesEnum.PARTIAL_ATTRIBUTES_LIST_STATE.ordinal()][OCTET_STRING.getValue()] =
856             new GrammarTransition(
857                 LdapStatesEnum.PARTIAL_ATTRIBUTES_LIST_STATE,
858                 LdapStatesEnum.TYPE_SR_STATE,
859                 OCTET_STRING,
860                 new AddAttributeType() );
861 
862         // --------------------------------------------------------------------------------------------
863         // Transition from typeSR to ValsSR
864         // --------------------------------------------------------------------------------------------
865         // SearchResultEntry ::= [APPLICATION 4] SEQUENCE { ...
866         // ...
867         // attributes PartialAttributeList }
868         //
869         // PartialAttributeList ::= SEQUENCE OF SEQUENCE {
870         //     ...
871         //     vals SET OF AttributeValue }
872         //
873         // We may have no value. Just allows the grammar to end
874         super.transitions[LdapStatesEnum.TYPE_SR_STATE.ordinal()][SET.getValue()] =
875             new GrammarTransition(
876                 LdapStatesEnum.TYPE_SR_STATE,
877                 LdapStatesEnum.VALS_SR_STATE,
878                 SET,
879                 new AllowGrammarEnd() );
880 
881         // --------------------------------------------------------------------------------------------
882         // Transition from ValsSR to AttributeValueSR
883         // --------------------------------------------------------------------------------------------
884         // PartialAttributeList ::= SEQUENCE OF SEQUENCE {
885         //     ...
886         //     vals SET OF AttributeValue }
887         //
888         // AttributeValue ::= OCTET STRING
889         //
890         // Store the attribute value
891         super.transitions[LdapStatesEnum.VALS_SR_STATE.ordinal()][OCTET_STRING.getValue()] =
892             new GrammarTransition(
893                 LdapStatesEnum.VALS_SR_STATE,
894                 LdapStatesEnum.ATTRIBUTE_VALUE_SR_STATE,
895                 OCTET_STRING,
896                 new StoreSearchResultAttributeValue() );
897 
898         // --------------------------------------------------------------------------------------------
899         // Transition from ValsSR to PartialAttributesList
900         // --------------------------------------------------------------------------------------------
901         // PartialAttributeList ::= SEQUENCE OF SEQUENCE {
902         //     ...
903         //     vals SET OF AttributeValue }
904         //
905         // Loop when we don't have any attribute value. Nothing to do
906         super.transitions[LdapStatesEnum.VALS_SR_STATE.ordinal()][SEQUENCE.getValue()] =
907             new GrammarTransition(
908                 LdapStatesEnum.VALS_SR_STATE,
909                 LdapStatesEnum.PARTIAL_ATTRIBUTES_LIST_STATE,
910                 SEQUENCE );
911 
912         // --------------------------------------------------------------------------------------------
913         // Transition from ValsSR to Controls
914         // --------------------------------------------------------------------------------------------
915         //     searchResultEntry SearchResultEntry,
916         //     ... },
917         // controls   [0] Controls OPTIONAL }
918         //
919         // Initialize the controls
920         super.transitions[LdapStatesEnum.VALS_SR_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
921             new GrammarTransition(
922                 LdapStatesEnum.VALS_SR_STATE,
923                 LdapStatesEnum.CONTROLS_STATE,
924                 LdapConstants.CONTROLS_TAG,
925                 new InitControls() );
926 
927         // --------------------------------------------------------------------------------------------
928         // Transition from AttributeValueSR to AttributeValueSR
929         // --------------------------------------------------------------------------------------------
930         // PartialAttributeList ::= SEQUENCE OF SEQUENCE {
931         //     ...
932         //     vals SET OF AttributeValue }
933         //
934         // AttributeValue ::= OCTET STRING
935         //
936         // Store the attribute value
937         super.transitions[LdapStatesEnum.ATTRIBUTE_VALUE_SR_STATE.ordinal()][OCTET_STRING.getValue()] =
938             new GrammarTransition(
939                 LdapStatesEnum.ATTRIBUTE_VALUE_SR_STATE,
940                 LdapStatesEnum.ATTRIBUTE_VALUE_SR_STATE,
941                 OCTET_STRING,
942                 new StoreSearchResultAttributeValue() );
943 
944         // --------------------------------------------------------------------------------------------
945         // Transition from AttributeValueSR to PartialAttributesList
946         // --------------------------------------------------------------------------------------------
947         // PartialAttributeList ::= SEQUENCE OF SEQUENCE {
948         //     ...
949         //     vals SET OF AttributeValue }
950         //
951         // Loop when we don't have any attribute value. Nothing to do
952         super.transitions[LdapStatesEnum.ATTRIBUTE_VALUE_SR_STATE.ordinal()][SEQUENCE.getValue()] =
953             new GrammarTransition(
954                 LdapStatesEnum.ATTRIBUTE_VALUE_SR_STATE,
955                 LdapStatesEnum.PARTIAL_ATTRIBUTES_LIST_STATE,
956                 SEQUENCE );
957 
958         // --------------------------------------------------------------------------------------------
959         // Transition from AttributeValueSR to Controls
960         // --------------------------------------------------------------------------------------------
961         //     searchResultEntry SearchResultEntry,
962         //     ... },
963         // controls   [0] Controls OPTIONAL }
964         //
965         // Initialize the controls
966         super.transitions[LdapStatesEnum.ATTRIBUTE_VALUE_SR_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
967             new GrammarTransition(
968                 LdapStatesEnum.ATTRIBUTE_VALUE_SR_STATE,
969                 LdapStatesEnum.CONTROLS_STATE,
970                 LdapConstants.CONTROLS_TAG,
971                 new InitControls() );
972 
973         // --------------------------------------------------------------------------------------------
974         // SearchResultDone Message.
975         // --------------------------------------------------------------------------------------------
976         // LdapMessage ::= ... SearchResultDone ...
977         // SearchResultDone ::= [APPLICATION 5] SEQUENCE { ...
978         //
979         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.SEARCH_RESULT_DONE_TAG] =
980             new GrammarTransition(
981                 LdapStatesEnum.MESSAGE_ID_STATE,
982                 LdapStatesEnum.SEARCH_RESULT_DONE_STATE,
983                 LdapConstants.SEARCH_RESULT_DONE_TAG,
984                 new InitSearchResultDone() );
985 
986         // --------------------------------------------------------------------------------------------
987         // SearchResultDone Message.
988         // --------------------------------------------------------------------------------------------
989         // LdapMessage ::= ... SearchResultDone ...
990         // SearchResultDone ::= [APPLICATION 5] LDAPResult
991         //
992         // LDAPResult ::= SEQUENCE {
993         //     resultCode    ENUMERATED {
994         //         ...
995         //
996         // Stores the result code
997         super.transitions[LdapStatesEnum.SEARCH_RESULT_DONE_STATE.ordinal()][ENUMERATED.getValue()] =
998             new GrammarTransition(
999                 LdapStatesEnum.SEARCH_RESULT_DONE_STATE,
1000                 LdapStatesEnum.RESULT_CODE_STATE,
1001                 ENUMERATED,
1002                 new StoreResultCode() );
1003 
1004         // --------------------------------------------------------------------------------------------
1005         // Transition from Message ID to ModifyRequest Message
1006         // --------------------------------------------------------------------------------------------
1007         // LdapMessage ::= ... ModifyRequest ...
1008         // ModifyRequest ::= [APPLICATION 6] SEQUENCE { ...
1009         //
1010         // Creates the Modify Request object
1011         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.MODIFY_REQUEST_TAG] =
1012             new GrammarTransition(
1013                 LdapStatesEnum.MESSAGE_ID_STATE,
1014                 LdapStatesEnum.MODIFY_REQUEST_STATE,
1015                 LdapConstants.MODIFY_REQUEST_TAG,
1016                 new InitModifyRequest() );
1017 
1018         // --------------------------------------------------------------------------------------------
1019         // Transition from ModifyRequest Message to Object
1020         // --------------------------------------------------------------------------------------------
1021         // ModifyRequest ::= [APPLICATION 6] SEQUENCE {
1022         //     object    LDAPDN,
1023         //     ...
1024         //
1025         // Stores the object Dn
1026         super.transitions[LdapStatesEnum.MODIFY_REQUEST_STATE.ordinal()][OCTET_STRING.getValue()] =
1027             new GrammarTransition(
1028                 LdapStatesEnum.MODIFY_REQUEST_STATE,
1029                 LdapStatesEnum.OBJECT_STATE,
1030                 OCTET_STRING,
1031                 new StoreModifyRequestObjectName() );
1032 
1033         // --------------------------------------------------------------------------------------------
1034         // Transition from Object to modifications
1035         // --------------------------------------------------------------------------------------------
1036         // ModifyRequest ::= [APPLICATION 6] SEQUENCE {
1037         //     ...
1038         //     modification *SEQUENCE OF* SEQUENCE {
1039         //     ...
1040         //
1041         // Initialize the modifications list
1042         super.transitions[LdapStatesEnum.OBJECT_STATE.ordinal()][SEQUENCE.getValue()] =
1043             new GrammarTransition(
1044                 LdapStatesEnum.OBJECT_STATE,
1045                 LdapStatesEnum.MODIFICATIONS_STATE,
1046                 SEQUENCE );
1047 
1048         // --------------------------------------------------------------------------------------------
1049         // Transition from modifications to modification sequence
1050         // --------------------------------------------------------------------------------------------
1051         // ModifyRequest ::= [APPLICATION 6] SEQUENCE {
1052         //     ...
1053         //     modification SEQUENCE OF *SEQUENCE* {
1054         //     ...
1055         //
1056         // Nothing to do
1057         super.transitions[LdapStatesEnum.MODIFICATIONS_STATE.ordinal()][SEQUENCE.getValue()] =
1058             new GrammarTransition(
1059                 LdapStatesEnum.MODIFICATIONS_STATE,
1060                 LdapStatesEnum.MODIFICATIONS_SEQ_STATE,
1061                 SEQUENCE );
1062 
1063         // --------------------------------------------------------------------------------------------
1064         // Transition from modification sequence to operation
1065         // --------------------------------------------------------------------------------------------
1066         // ModifyRequest ::= [APPLICATION 6] SEQUENCE {
1067         //     ...
1068         //     modification SEQUENCE OF SEQUENCE {
1069         //         operation  ENUMERATED {
1070         //             ...
1071         //
1072         // Store operation type
1073         super.transitions[LdapStatesEnum.MODIFICATIONS_SEQ_STATE.ordinal()][ENUMERATED.getValue()] =
1074             new GrammarTransition(
1075                 LdapStatesEnum.MODIFICATIONS_SEQ_STATE,
1076                 LdapStatesEnum.OPERATION_STATE,
1077                 ENUMERATED,
1078                 new StoreOperationType() );
1079 
1080         // --------------------------------------------------------------------------------------------
1081         // Transition from operation to modification
1082         // --------------------------------------------------------------------------------------------
1083         // ModifyRequest ::= [APPLICATION 6] SEQUENCE {
1084         //     ...
1085         //     modification SEQUENCE OF SEQUENCE {
1086         //             ...
1087         //         modification   AttributeTypeAndValues }
1088         //
1089         // AttributeTypeAndValues ::= SEQUENCE {
1090         //     ...
1091         //
1092         // Nothing to do
1093         super.transitions[LdapStatesEnum.OPERATION_STATE.ordinal()][SEQUENCE.getValue()] =
1094             new GrammarTransition(
1095                 LdapStatesEnum.OPERATION_STATE,
1096                 LdapStatesEnum.MODIFICATION_STATE,
1097                 SEQUENCE );
1098 
1099         // --------------------------------------------------------------------------------------------
1100         // Transition from modification to TypeMod
1101         // --------------------------------------------------------------------------------------------
1102         // ModifyRequest ::= [APPLICATION 6] SEQUENCE {
1103         //     ...
1104         //     modification SEQUENCE OF SEQUENCE {
1105         //             ...
1106         //         modification   AttributeTypeAndValues }
1107         //
1108         // AttributeTypeAndValues ::= SEQUENCE {
1109         //     type AttributeDescription,
1110         //     ...
1111         //
1112         // Stores the type
1113         super.transitions[LdapStatesEnum.MODIFICATION_STATE.ordinal()][OCTET_STRING.getValue()] =
1114             new GrammarTransition(
1115                 LdapStatesEnum.MODIFICATION_STATE,
1116                 LdapStatesEnum.TYPE_MOD_STATE,
1117                 OCTET_STRING,
1118                 new AddModifyRequestAttribute() );
1119 
1120         // --------------------------------------------------------------------------------------------
1121         // Transition from TypeMod to vals
1122         // --------------------------------------------------------------------------------------------
1123         // ModifyRequest ::= [APPLICATION 6] SEQUENCE {
1124         //     ...
1125         //     modification SEQUENCE OF SEQUENCE {
1126         //             ...
1127         //         modification   AttributeTypeAndValues }
1128         //
1129         // AttributeTypeAndValues ::= SEQUENCE {
1130         //     ...
1131         //     vals SET OF AttributeValue }
1132         //
1133         // Initialize the list of values
1134         super.transitions[LdapStatesEnum.TYPE_MOD_STATE.ordinal()][SET.getValue()] =
1135             new GrammarTransition(
1136                 LdapStatesEnum.TYPE_MOD_STATE,
1137                 LdapStatesEnum.VALS_STATE,
1138                 SET,
1139                 new InitAttributeVals() );
1140 
1141         // --------------------------------------------------------------------------------------------
1142         // Transition from vals to Attribute Value
1143         // --------------------------------------------------------------------------------------------
1144         // ModifyRequest ::= [APPLICATION 6] SEQUENCE {
1145         //     ...
1146         //     modification SEQUENCE OF SEQUENCE {
1147         //             ...
1148         //         modification   AttributeTypeAndValues }
1149         //
1150         // AttributeTypeAndValues ::= SEQUENCE {
1151         //     ...
1152         //     vals SET OF AttributeValue }
1153         //
1154         // AttributeValue ::= OCTET STRING
1155         //
1156         // Stores a value
1157         super.transitions[LdapStatesEnum.VALS_STATE.ordinal()][OCTET_STRING.getValue()] =
1158             new GrammarTransition(
1159                 LdapStatesEnum.VALS_STATE,
1160                 LdapStatesEnum.ATTRIBUTE_VALUE_STATE,
1161                 OCTET_STRING,
1162                 new StoreModifyRequestAttributeValue() );
1163 
1164         // --------------------------------------------------------------------------------------------
1165         // Transition from vals to ModificationsSeq
1166         // --------------------------------------------------------------------------------------------
1167         // ModifyRequest ::= [APPLICATION 6] SEQUENCE {
1168         //     ...
1169         //     modification SEQUENCE OF *SEQUENCE* {
1170         //             ...
1171         //         modification   AttributeTypeAndValues }
1172         //
1173         // AttributeTypeAndValues ::= SEQUENCE {
1174         //     ...
1175         //     vals SET OF AttributeValue }
1176         //
1177         // AttributeValue ::= OCTET STRING
1178         //
1179         // Nothing to do
1180         super.transitions[LdapStatesEnum.VALS_STATE.ordinal()][SEQUENCE.getValue()] =
1181             new GrammarTransition(
1182                 LdapStatesEnum.VALS_STATE,
1183                 LdapStatesEnum.MODIFICATIONS_SEQ_STATE,
1184                 SEQUENCE );
1185 
1186         // --------------------------------------------------------------------------------------------
1187         // Transition from vals to Controls
1188         // --------------------------------------------------------------------------------------------
1189         //     modifyRequest ModifyRequest,
1190         //     ... },
1191         // controls   [0] Controls OPTIONAL }
1192         //
1193         // Nothing to do
1194         super.transitions[LdapStatesEnum.VALS_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
1195             new GrammarTransition(
1196                 LdapStatesEnum.VALS_STATE,
1197                 LdapStatesEnum.CONTROLS_STATE,
1198                 LdapConstants.CONTROLS_TAG,
1199                 new InitControls() );
1200 
1201         // --------------------------------------------------------------------------------------------
1202         // Transition from Attribute Value to Attribute Value
1203         // --------------------------------------------------------------------------------------------
1204         // ModifyRequest ::= [APPLICATION 6] SEQUENCE {
1205         //     ...
1206         //     modification SEQUENCE OF SEQUENCE {
1207         //             ...
1208         //         modification   AttributeTypeAndValues }
1209         //
1210         // AttributeTypeAndValues ::= SEQUENCE {
1211         //     ...
1212         //     vals SET OF AttributeValue }
1213         //
1214         // AttributeValue ::= OCTET STRING
1215         //
1216         // Stores a value
1217         super.transitions[LdapStatesEnum.ATTRIBUTE_VALUE_STATE.ordinal()][OCTET_STRING.getValue()] =
1218             new GrammarTransition(
1219                 LdapStatesEnum.ATTRIBUTE_VALUE_STATE,
1220                 LdapStatesEnum.ATTRIBUTE_VALUE_STATE,
1221                 OCTET_STRING,
1222                 new StoreModifyRequestAttributeValue() );
1223 
1224         // --------------------------------------------------------------------------------------------
1225         // Transition from Attribute Value to ModificationsSeq
1226         // --------------------------------------------------------------------------------------------
1227         // ModifyRequest ::= [APPLICATION 6] SEQUENCE {
1228         //     ...
1229         //     modification SEQUENCE OF *SEQUENCE* {
1230         //             ...
1231         //         modification   AttributeTypeAndValues }
1232         //
1233         // AttributeTypeAndValues ::= SEQUENCE {
1234         //     ...
1235         //     vals SET OF AttributeValue }
1236         //
1237         // AttributeValue ::= OCTET STRING
1238         //
1239         // Nothing to do
1240         super.transitions[LdapStatesEnum.ATTRIBUTE_VALUE_STATE.ordinal()][SEQUENCE.getValue()] =
1241             new GrammarTransition(
1242                 LdapStatesEnum.ATTRIBUTE_VALUE_STATE,
1243                 LdapStatesEnum.MODIFICATIONS_SEQ_STATE,
1244                 SEQUENCE );
1245 
1246         // --------------------------------------------------------------------------------------------
1247         // Transition from Attribute Value to Controls
1248         // --------------------------------------------------------------------------------------------
1249         //     modifyRequest ModifyRequest,
1250         //     ... },
1251         // controls   [0] Controls OPTIONAL }
1252         //
1253         // Nothing to do
1254         super.transitions[LdapStatesEnum.ATTRIBUTE_VALUE_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
1255             new GrammarTransition(
1256                 LdapStatesEnum.ATTRIBUTE_VALUE_STATE,
1257                 LdapStatesEnum.CONTROLS_STATE,
1258                 LdapConstants.CONTROLS_TAG,
1259                 new InitControls() );
1260 
1261         // --------------------------------------------------------------------------------------------
1262         // ModifyResponse Message.
1263         // --------------------------------------------------------------------------------------------
1264         // LdapMessage ::= ... ModifyResponse ...
1265         // ModifyResponse ::= [APPLICATION 7] SEQUENCE { ...
1266         // We have to switch to the ModifyResponse grammar
1267         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.MODIFY_RESPONSE_TAG] =
1268             new GrammarTransition(
1269                 LdapStatesEnum.MESSAGE_ID_STATE,
1270                 LdapStatesEnum.MODIFY_RESPONSE_STATE,
1271                 LdapConstants.MODIFY_RESPONSE_TAG,
1272                 new InitModifyResponse() );
1273 
1274         // --------------------------------------------------------------------------------------------
1275         // ModifyResponse Message.
1276         // --------------------------------------------------------------------------------------------
1277         // LdapMessage ::= ... ModifyResponse ...
1278         // ModifyResponse ::= [APPLICATION 7] LDAPResult
1279         //
1280         // LDAPResult ::= SEQUENCE {
1281         //     resultCode    ENUMERATED {
1282         //         ...
1283         //
1284         // Stores the result code
1285         super.transitions[LdapStatesEnum.MODIFY_RESPONSE_STATE.ordinal()][ENUMERATED.getValue()] =
1286             new GrammarTransition(
1287                 LdapStatesEnum.MODIFY_RESPONSE_STATE,
1288                 LdapStatesEnum.RESULT_CODE_STATE,
1289                 ENUMERATED,
1290                 new StoreResultCode() );
1291 
1292         // --------------------------------------------------------------------------------------------
1293         // AddRequest Message.
1294         // --------------------------------------------------------------------------------------------
1295         // LdapMessage ::= ... AddRequest ...
1296         // AddRequest ::= [APPLICATION 8] SEQUENCE { ...
1297         //
1298         // Initialize the AddRequest object
1299         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.ADD_REQUEST_TAG] =
1300             new GrammarTransition(
1301                 LdapStatesEnum.MESSAGE_ID_STATE,
1302                 LdapStatesEnum.ADD_REQUEST_STATE,
1303                 LdapConstants.ADD_REQUEST_TAG,
1304                 new InitAddRequest() );
1305 
1306         // --------------------------------------------------------------------------------------------
1307         // Transition from Add Request to Entry
1308         // --------------------------------------------------------------------------------------------
1309         // AddRequest ::= [APPLICATION 8] SEQUENCE {
1310         //     entry           LDAPDN,
1311         //     ...
1312         //
1313         // Stores the Dn
1314         super.transitions[LdapStatesEnum.ADD_REQUEST_STATE.ordinal()][OCTET_STRING.getValue()] =
1315             new GrammarTransition(
1316                 LdapStatesEnum.ADD_REQUEST_STATE,
1317                 LdapStatesEnum.ENTRY_STATE,
1318                 OCTET_STRING,
1319                 new StoreAddRequestEntryName() );
1320 
1321         // --------------------------------------------------------------------------------------------
1322         // Transition from Entry to Attributes
1323         // --------------------------------------------------------------------------------------------
1324         // AddRequest ::= [APPLICATION 8] SEQUENCE {
1325         //     ...
1326         //    attributes AttributeList }
1327         //
1328         // AttributeList ::= SEQUENCE OF ...
1329         //
1330         // Initialize the attribute list
1331         super.transitions[LdapStatesEnum.ENTRY_STATE.ordinal()][SEQUENCE.getValue()] =
1332             new GrammarTransition(
1333                 LdapStatesEnum.ENTRY_STATE,
1334                 LdapStatesEnum.ATTRIBUTES_STATE,
1335                 SEQUENCE );
1336 
1337         // --------------------------------------------------------------------------------------------
1338         // Transition from Attributes to Attribute
1339         // --------------------------------------------------------------------------------------------
1340         // AttributeList ::= SEQUENCE OF SEQUENCE {
1341         //
1342         // We don't do anything in this transition. The attribute will be created when we met the type
1343         super.transitions[LdapStatesEnum.ATTRIBUTES_STATE.ordinal()][SEQUENCE.getValue()] =
1344             new GrammarTransition(
1345                 LdapStatesEnum.ATTRIBUTES_STATE,
1346                 LdapStatesEnum.ATTRIBUTE_STATE,
1347                 SEQUENCE );
1348 
1349         // --------------------------------------------------------------------------------------------
1350         // Transition from Attribute to type
1351         // --------------------------------------------------------------------------------------------
1352         // AttributeList ::= SEQUENCE OF SEQUENCE {
1353         //     type    AttributeDescription,
1354         //     ...
1355         //
1356         // AttributeDescription LDAPString
1357         //
1358         // We store the type in the current attribute
1359         super.transitions[LdapStatesEnum.ATTRIBUTE_STATE.ordinal()][OCTET_STRING.getValue()] =
1360             new GrammarTransition(
1361                 LdapStatesEnum.ATTRIBUTE_STATE,
1362                 LdapStatesEnum.TYPE_STATE,
1363                 OCTET_STRING,
1364                 new AddAddRequestAttributeType() );
1365 
1366         // --------------------------------------------------------------------------------------------
1367         // Transition from type to vals
1368         // --------------------------------------------------------------------------------------------
1369         // AttributeList ::= SEQUENCE OF SEQUENCE {
1370         //     ...
1371         //     vals SET OF AttributeValue }
1372         //
1373         // Nothing to do here.
1374         super.transitions[LdapStatesEnum.TYPE_STATE.ordinal()][SET.getValue()] =
1375             new GrammarTransition(
1376                 LdapStatesEnum.TYPE_STATE,
1377                 LdapStatesEnum.VALUES_STATE,
1378                 SET );
1379 
1380         // --------------------------------------------------------------------------------------------
1381         // Transition from vals to Value
1382         // --------------------------------------------------------------------------------------------
1383         // AttributeList ::= SEQUENCE OF SEQUENCE {
1384         //     ...
1385         //     vals SET OF AttributeValue }
1386         //
1387         // AttributeValue OCTET STRING
1388         //
1389         // Store the value into the current attribute
1390         super.transitions[LdapStatesEnum.VALUES_STATE.ordinal()][OCTET_STRING.getValue()] =
1391             new GrammarTransition(
1392                 LdapStatesEnum.VALUES_STATE,
1393                 LdapStatesEnum.VALUE_STATE,
1394                 OCTET_STRING,
1395                 new AddAttributeValue() );
1396 
1397         // --------------------------------------------------------------------------------------------
1398         // Transition from Value to Value
1399         // --------------------------------------------------------------------------------------------
1400         // AttributeList ::= SEQUENCE OF SEQUENCE {
1401         //     ...
1402         //     vals SET OF AttributeValue }
1403         //
1404         // AttributeValue OCTET STRING
1405         //
1406         // Store the value into the current attribute
1407         super.transitions[LdapStatesEnum.VALUE_STATE.ordinal()][OCTET_STRING.getValue()] =
1408             new GrammarTransition(
1409                 LdapStatesEnum.VALUE_STATE,
1410                 LdapStatesEnum.VALUE_STATE,
1411                 OCTET_STRING,
1412                 new AddAttributeValue() );
1413 
1414         // --------------------------------------------------------------------------------------------
1415         // Transition from Value to Attribute
1416         // --------------------------------------------------------------------------------------------
1417         // AttributeList ::= SEQUENCE OF SEQUENCE {
1418         //
1419         // Nothing to do here.
1420         super.transitions[LdapStatesEnum.VALUE_STATE.ordinal()][SEQUENCE.getValue()] =
1421             new GrammarTransition(
1422                 LdapStatesEnum.VALUE_STATE,
1423                 LdapStatesEnum.ATTRIBUTE_STATE,
1424                 SEQUENCE );
1425 
1426         // --------------------------------------------------------------------------------------------
1427         // Transition from Value to Controls
1428         // --------------------------------------------------------------------------------------------
1429         // AttributeList ::= SEQUENCE OF SEQUENCE {
1430         //
1431         // Initialize the controls
1432         super.transitions[LdapStatesEnum.VALUE_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
1433             new GrammarTransition(
1434                 LdapStatesEnum.VALUE_STATE,
1435                 LdapStatesEnum.CONTROLS_STATE,
1436                 LdapConstants.CONTROLS_TAG,
1437                 new InitControls() );
1438 
1439         // --------------------------------------------------------------------------------------------
1440         // AddResponse Message.
1441         // --------------------------------------------------------------------------------------------
1442         // LdapMessage ::= ... AddResponse ...
1443         // AddResponse ::= [APPLICATION 9] LDAPResult
1444         //
1445         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.ADD_RESPONSE_TAG] =
1446             new GrammarTransition(
1447                 LdapStatesEnum.MESSAGE_ID_STATE,
1448                 LdapStatesEnum.ADD_RESPONSE_STATE,
1449                 LdapConstants.ADD_RESPONSE_TAG,
1450                 new InitAddResponse() );
1451 
1452         // --------------------------------------------------------------------------------------------
1453         // AddResponse Message.
1454         // --------------------------------------------------------------------------------------------
1455         // LdapMessage ::= ... AddResponse ...
1456         // AddResponse ::= [APPLICATION 9] LDAPResult
1457         //
1458         // LDAPResult ::= SEQUENCE {
1459         //     resultCode    ENUMERATED {
1460         //         ...
1461         //
1462         // Stores the result code
1463         super.transitions[LdapStatesEnum.ADD_RESPONSE_STATE.ordinal()][ENUMERATED.getValue()] =
1464             new GrammarTransition(
1465                 LdapStatesEnum.ADD_RESPONSE_STATE,
1466                 LdapStatesEnum.RESULT_CODE_STATE,
1467                 ENUMERATED,
1468                 new StoreResultCode() );
1469 
1470         // --------------------------------------------------------------------------------------------
1471         // DelResponse Message.
1472         // --------------------------------------------------------------------------------------------
1473         // LdapMessage ::= ... DelResponse ...
1474         // DelResponse ::= [APPLICATION 11] LDAPResult
1475         // We have to switch to the DelResponse grammar
1476         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.DEL_RESPONSE_TAG] =
1477             new GrammarTransition(
1478                 LdapStatesEnum.MESSAGE_ID_STATE,
1479                 LdapStatesEnum.DEL_RESPONSE_STATE,
1480                 LdapConstants.DEL_RESPONSE_TAG,
1481                 new InitDelResponse() );
1482 
1483         // --------------------------------------------------------------------------------------------
1484         // DelResponse Message.
1485         // --------------------------------------------------------------------------------------------
1486         // LdapMessage ::= ... DelResponse ...
1487         // DelResponse ::= [APPLICATION 11] LDAPResult
1488         //
1489         // LDAPResult ::= SEQUENCE {
1490         //     resultCode    ENUMERATED {
1491         //         ...
1492         //
1493         // Stores the result code
1494         super.transitions[LdapStatesEnum.DEL_RESPONSE_STATE.ordinal()][ENUMERATED.getValue()] =
1495             new GrammarTransition(
1496                 LdapStatesEnum.DEL_RESPONSE_STATE,
1497                 LdapStatesEnum.RESULT_CODE_STATE,
1498                 ENUMERATED,
1499                 new StoreResultCode() );
1500 
1501         // --------------------------------------------------------------------------------------------
1502         // Transition from MessageID to ModifydDNRequest Message.
1503         // --------------------------------------------------------------------------------------------
1504         // LdapMessage ::= ... ModifyDNRequest ...
1505         // ModifyDNRequest ::= [APPLICATION 12] SEQUENCE { ...
1506         //
1507         // Create the ModifyDNRequest Object
1508         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.MODIFY_DN_REQUEST_TAG] =
1509             new GrammarTransition(
1510                 LdapStatesEnum.MESSAGE_ID_STATE,
1511                 LdapStatesEnum.MODIFY_DN_REQUEST_STATE,
1512                 LdapConstants.MODIFY_DN_REQUEST_TAG,
1513                 new InitModifyDnRequest() );
1514 
1515         // --------------------------------------------------------------------------------------------
1516         // Transition from ModifydDNRequest Message to EntryModDN
1517         // --------------------------------------------------------------------------------------------
1518         // ModifyDNRequest ::= [APPLICATION 12] SEQUENCE { ...
1519         //     entry LDAPDN,
1520         //     ...
1521         //
1522         // Stores the entry Dn
1523         super.transitions[LdapStatesEnum.MODIFY_DN_REQUEST_STATE.ordinal()][OCTET_STRING.getValue()] =
1524             new GrammarTransition(
1525                 LdapStatesEnum.MODIFY_DN_REQUEST_STATE,
1526                 LdapStatesEnum.ENTRY_MOD_DN_STATE,
1527                 OCTET_STRING,
1528                 new StoreModifyDnRequestEntryName() );
1529 
1530         // --------------------------------------------------------------------------------------------
1531         // Transition from EntryModDN to NewRDN
1532         // --------------------------------------------------------------------------------------------
1533         // ModifyDNRequest ::= [APPLICATION 12] SEQUENCE { ...
1534         //     ...
1535         //     newrdn  RelativeRDN,
1536         //     ...
1537         //
1538         // RelativeRDN :: LDAPString
1539         //
1540         // Stores the new Rdn
1541         super.transitions[LdapStatesEnum.ENTRY_MOD_DN_STATE.ordinal()][OCTET_STRING.getValue()] =
1542             new GrammarTransition(
1543                 LdapStatesEnum.ENTRY_MOD_DN_STATE,
1544                 LdapStatesEnum.NEW_RDN_STATE,
1545                 OCTET_STRING,
1546                 new StoreModifyDnRequestNewRdn() );
1547 
1548         // --------------------------------------------------------------------------------------------
1549         // Transition from NewRDN to DeleteOldRDN
1550         // --------------------------------------------------------------------------------------------
1551         // ModifyDNRequest ::= [APPLICATION 12] SEQUENCE { ...
1552         //     ...
1553         //     deleteoldrdn BOOLEAN,
1554         //     ...
1555         //
1556         // Stores the deleteOldRDN flag
1557         super.transitions[LdapStatesEnum.NEW_RDN_STATE.ordinal()][BOOLEAN.getValue()] =
1558             new GrammarTransition(
1559                 LdapStatesEnum.NEW_RDN_STATE,
1560                 LdapStatesEnum.DELETE_OLD_RDN_STATE,
1561                 BOOLEAN,
1562                 new StoreModifyDnRequestDeleteOldRdn() );
1563 
1564         // --------------------------------------------------------------------------------------------
1565         // Transition from DeleteOldRDN to NewSuperior
1566         // --------------------------------------------------------------------------------------------
1567         // ModifyDNRequest ::= [APPLICATION 12] SEQUENCE { ...
1568         //     ...
1569         //     newSuperior [0] LDAPDN OPTIONAL }
1570         //
1571         // Stores the new superior
1572         super.transitions[LdapStatesEnum.DELETE_OLD_RDN_STATE.ordinal()][LdapConstants.MODIFY_DN_REQUEST_NEW_SUPERIOR_TAG] =
1573             new GrammarTransition(
1574                 LdapStatesEnum.DELETE_OLD_RDN_STATE,
1575                 LdapStatesEnum.NEW_SUPERIOR_STATE,
1576                 LdapConstants.MODIFY_DN_REQUEST_NEW_SUPERIOR_TAG,
1577                 new StoreModifyDnRequestNewSuperior() );
1578 
1579         // --------------------------------------------------------------------------------------------
1580         // Transition from DeleteOldRDN to Controls
1581         // --------------------------------------------------------------------------------------------
1582         //     modifyDNRequest ModifyDNRequest,
1583         //     ... },
1584         // controls   [0] Controls OPTIONAL }
1585         //
1586         // Stores the new superior
1587         super.transitions[LdapStatesEnum.DELETE_OLD_RDN_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
1588             new GrammarTransition(
1589                 LdapStatesEnum.DELETE_OLD_RDN_STATE,
1590                 LdapStatesEnum.CONTROLS_STATE,
1591                 LdapConstants.CONTROLS_TAG,
1592                 new InitControls() );
1593 
1594         // --------------------------------------------------------------------------------------------
1595         // Transition from DeleteOldRDN to Controls
1596         // --------------------------------------------------------------------------------------------
1597         //     modifyDNRequest ModifyDNRequest,
1598         //     ... },
1599         // controls   [0] Controls OPTIONAL }
1600         //
1601         // Stores the new superior
1602         super.transitions[LdapStatesEnum.NEW_SUPERIOR_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
1603             new GrammarTransition(
1604                 LdapStatesEnum.NEW_SUPERIOR_STATE,
1605                 LdapStatesEnum.CONTROLS_STATE,
1606                 LdapConstants.CONTROLS_TAG,
1607                 new InitControls() );
1608 
1609         // --------------------------------------------------------------------------------------------
1610         // Transition from MessageID to ModifyDNResponse Message.
1611         // --------------------------------------------------------------------------------------------
1612         // ModifyDNResponse ::= [APPLICATION 13] SEQUENCE {
1613         //     ...
1614         //
1615         // Creates the ModifyDNResponse
1616         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.MODIFY_DN_RESPONSE_TAG] =
1617             new GrammarTransition(
1618                 LdapStatesEnum.MESSAGE_ID_STATE,
1619                 LdapStatesEnum.MODIFY_DN_RESPONSE_STATE,
1620                 LdapConstants.MODIFY_DN_RESPONSE_TAG,
1621                 new InitModifyDnResponse() );
1622 
1623         // --------------------------------------------------------------------------------------------
1624         // Transition from ModifyDNResponse Message to Result Code
1625         // --------------------------------------------------------------------------------------------
1626         // LdapMessage ::= ... ModifyDNResponse ...
1627         // ModifyDNResponse ::= [APPLICATION 13] LDAPResult
1628         //
1629         // LDAPResult ::= SEQUENCE {
1630         //     resultCode    ENUMERATED {
1631         //         ...
1632         //
1633         // Stores the result co        //     modifyDNRequest ModifyDNRequest,
1634         //     ... },
1635         // controls   [0] Controls OPTIONAL }
1636         super.transitions[LdapStatesEnum.MODIFY_DN_RESPONSE_STATE.ordinal()][ENUMERATED.getValue()] =
1637             new GrammarTransition(
1638                 LdapStatesEnum.MODIFY_DN_RESPONSE_STATE,
1639                 LdapStatesEnum.RESULT_CODE_STATE,
1640                 ENUMERATED,
1641                 new StoreResultCode() );
1642 
1643         // --------------------------------------------------------------------------------------------
1644         // Transition from Message ID to CompareResquest
1645         // --------------------------------------------------------------------------------------------
1646         // LdapMessage ::= ... CompareRequest ...
1647         //
1648         // CompareRequest ::= [APPLICATION 14] SEQUENCE {
1649         // ...
1650         //
1651         // Initialize the Compare Request object
1652         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.COMPARE_REQUEST_TAG] =
1653             new GrammarTransition(
1654                 LdapStatesEnum.MESSAGE_ID_STATE,
1655                 LdapStatesEnum.COMPARE_REQUEST_STATE,
1656                 LdapConstants.COMPARE_REQUEST_TAG,
1657                 new InitCompareRequest() );
1658 
1659         // --------------------------------------------------------------------------------------------
1660         // Transition from CompareResquest to entryComp
1661         // --------------------------------------------------------------------------------------------
1662         // CompareRequest ::= [APPLICATION 14] SEQUENCE {
1663         //     entry    LDAPDN,
1664         //     ...
1665         //
1666         // Stores the compared Dn
1667         super.transitions[LdapStatesEnum.COMPARE_REQUEST_STATE.ordinal()][OCTET_STRING.getValue()] =
1668             new GrammarTransition(
1669                 LdapStatesEnum.COMPARE_REQUEST_STATE,
1670                 LdapStatesEnum.ENTRY_COMP_STATE,
1671                 OCTET_STRING,
1672                 new StoreCompareRequestEntryName() );
1673 
1674         // --------------------------------------------------------------------------------------------
1675         // Transition from entryComp to ava
1676         // --------------------------------------------------------------------------------------------
1677         // CompareRequest ::= [APPLICATION 14] SEQUENCE {
1678         //     ...
1679         //     ava AttributeValueAssertion }
1680         //
1681         // AttributeValueAssertion ::= SEQUENCE {
1682         //
1683         // Nothing to do
1684         super.transitions[LdapStatesEnum.ENTRY_COMP_STATE.ordinal()][SEQUENCE.getValue()] =
1685             new GrammarTransition(
1686                 LdapStatesEnum.ENTRY_COMP_STATE,
1687                 LdapStatesEnum.AVA_STATE,
1688                 SEQUENCE );
1689 
1690         // --------------------------------------------------------------------------------------------
1691         // Transition from ava to AttributeDesc
1692         // --------------------------------------------------------------------------------------------
1693         // AttributeValueAssertion ::= SEQUENCE {
1694         //     attributeDesc AttributeDescription,
1695         //     ...
1696         //
1697         // AttributeDescription LDAPString
1698         //
1699         // Stores the attribute description
1700         super.transitions[LdapStatesEnum.AVA_STATE.ordinal()][OCTET_STRING.getValue()] =
1701             new GrammarTransition(
1702                 LdapStatesEnum.AVA_STATE,
1703                 LdapStatesEnum.ATTRIBUTE_DESC_STATE,
1704                 OCTET_STRING,
1705                 new StoreCompareRequestAttributeDesc() );
1706 
1707         // --------------------------------------------------------------------------------------------
1708         // Transition from AttributeDesc to Assertion Value
1709         // --------------------------------------------------------------------------------------------
1710         // AttributeValueAssertion ::= SEQUENCE {
1711         //     ...
1712         //     assertionValue AssertionValue }
1713         //
1714         // AssertionValue OCTET STRING
1715         //
1716         // Stores the attribute value
1717         super.transitions[LdapStatesEnum.ATTRIBUTE_DESC_STATE.ordinal()][OCTET_STRING.getValue()] =
1718             new GrammarTransition(
1719                 LdapStatesEnum.ATTRIBUTE_DESC_STATE,
1720                 LdapStatesEnum.ASSERTION_VALUE_STATE,
1721                 OCTET_STRING,
1722                 new StoreCompareRequestAssertionValue() );
1723 
1724         // --------------------------------------------------------------------------------------------
1725         // Transition from Assertion Value to Controls
1726         // --------------------------------------------------------------------------------------------
1727         // AttributeValueAssertion ::= SEQUENCE {
1728         //     ...
1729         //     assertionValue AssertionValue }
1730         //
1731         // AssertionValue OCTET STRING
1732         //
1733         // Stores the attribute value
1734         super.transitions[LdapStatesEnum.ASSERTION_VALUE_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
1735             new GrammarTransition(
1736                 LdapStatesEnum.ASSERTION_VALUE_STATE,
1737                 LdapStatesEnum.CONTROLS_STATE,
1738                 LdapConstants.CONTROLS_TAG,
1739                 new InitControls() );
1740 
1741         // --------------------------------------------------------------------------------------------
1742         // CompareResponse Message.
1743         // --------------------------------------------------------------------------------------------
1744         // LdapMessage ::= ... CompareResponse ...
1745         // CompareResponse ::= [APPLICATION 15] LDAPResult
1746         // We have to switch to the CompareResponse grammar
1747         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.COMPARE_RESPONSE_TAG] =
1748             new GrammarTransition(
1749                 LdapStatesEnum.MESSAGE_ID_STATE,
1750                 LdapStatesEnum.COMPARE_RESPONSE_STATE,
1751                 LdapConstants.COMPARE_RESPONSE_TAG,
1752                 new InitCompareResponse() );
1753 
1754         // --------------------------------------------------------------------------------------------
1755         // CompareResponse Message.
1756         // --------------------------------------------------------------------------------------------
1757         // LdapMessage ::= ... CompareResponse ...
1758         // CompareResponse ::= [APPLICATION 15] LDAPResult
1759         //
1760         // LDAPResult ::= SEQUENCE {
1761         //     resultCode    ENUMERATED {
1762         //         ...
1763         //
1764         // Stores the result code
1765         super.transitions[LdapStatesEnum.COMPARE_RESPONSE_STATE.ordinal()][ENUMERATED.getValue()] =
1766             new GrammarTransition(
1767                 LdapStatesEnum.COMPARE_RESPONSE_STATE,
1768                 LdapStatesEnum.RESULT_CODE_STATE,
1769                 ENUMERATED,
1770                 new StoreResultCode() );
1771 
1772         // --------------------------------------------------------------------------------------------
1773         // Transition from MessageID to SearchResultReference Message.
1774         // --------------------------------------------------------------------------------------------
1775         // LdapMessage ::= ... SearchResultReference ...
1776         // SearchResultReference ::= [APPLICATION 19] SEQUENCE OF LDAPURL
1777         //
1778         // Initialization of SearchResultReference object
1779         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.SEARCH_RESULT_REFERENCE_TAG] =
1780             new GrammarTransition(
1781                 LdapStatesEnum.MESSAGE_ID_STATE,
1782                 LdapStatesEnum.SEARCH_RESULT_REFERENCE_STATE,
1783                 LdapConstants.SEARCH_RESULT_REFERENCE_TAG,
1784                 new InitSearchResultReference() );
1785 
1786         // --------------------------------------------------------------------------------------------
1787         // Transition from SearchResultReference Message to Reference
1788         // --------------------------------------------------------------------------------------------
1789         // LdapMessage ::= ... SearchResultReference ...
1790         // SearchResultReference ::= [APPLICATION 19] SEQUENCE OF LDAPURL
1791         //
1792         // Initialization of SearchResultReference object
1793         super.transitions[LdapStatesEnum.SEARCH_RESULT_REFERENCE_STATE.ordinal()][OCTET_STRING.getValue()] =
1794             new GrammarTransition(
1795                 LdapStatesEnum.SEARCH_RESULT_REFERENCE_STATE,
1796                 LdapStatesEnum.REFERENCE_STATE,
1797                 OCTET_STRING,
1798                 new StoreReference() );
1799 
1800         // --------------------------------------------------------------------------------------------
1801         // Transition from Reference to Reference
1802         // --------------------------------------------------------------------------------------------
1803         // LdapMessage ::= ... SearchResultReference ...
1804         // SearchResultReference ::= [APPLICATION 19] SEQUENCE OF LDAPURL
1805         //
1806         // Initialization of SearchResultReference object
1807         super.transitions[LdapStatesEnum.REFERENCE_STATE.ordinal()][OCTET_STRING.getValue()] =
1808             new GrammarTransition(
1809                 LdapStatesEnum.REFERENCE_STATE,
1810                 LdapStatesEnum.REFERENCE_STATE,
1811                 OCTET_STRING,
1812                 new StoreReference() );
1813 
1814         // --------------------------------------------------------------------------------------------
1815         // Transition from Reference to Controls
1816         // --------------------------------------------------------------------------------------------
1817         //     searchResultReference SearchResultReference,
1818         //     ... },
1819         // controls   [0] Controls OPTIONAL }
1820         //
1821         // Initialization the controls
1822         super.transitions[LdapStatesEnum.REFERENCE_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
1823             new GrammarTransition(
1824                 LdapStatesEnum.REFERENCE_STATE,
1825                 LdapStatesEnum.CONTROLS_STATE,
1826                 LdapConstants.CONTROLS_TAG,
1827                 new InitControls() );
1828 
1829         // --------------------------------------------------------------------------------------------
1830         // Transition from Message Id to ExtendedRequest Message
1831         // --------------------------------------------------------------------------------------------
1832         // LdapMessage ::= ... ExtendedRequest ...
1833         // ExtendedRequest ::= [APPLICATION 23] SEQUENCE {
1834         //
1835         // Creates the ExtendedRequest object
1836         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.EXTENDED_REQUEST_TAG] =
1837             new GrammarTransition(
1838                 LdapStatesEnum.MESSAGE_ID_STATE,
1839                 LdapStatesEnum.EXTENDED_REQUEST_STATE,
1840                 LdapConstants.EXTENDED_REQUEST_TAG,
1841                 new InitExtendedRequest() );
1842 
1843         // --------------------------------------------------------------------------------------------
1844         // Transition from ExtendedRequest Message to RequestName
1845         // --------------------------------------------------------------------------------------------
1846         // ExtendedRequest ::= [APPLICATION 23] SEQUENCE {
1847         //     requestName [0] LDAPOID,
1848         //     ...
1849         //
1850         // Stores the name
1851         super.transitions[LdapStatesEnum.EXTENDED_REQUEST_STATE.ordinal()][LdapConstants.EXTENDED_REQUEST_NAME_TAG] =
1852             new GrammarTransition(
1853                 LdapStatesEnum.EXTENDED_REQUEST_STATE,
1854                 LdapStatesEnum.REQUEST_NAME_STATE,
1855                 LdapConstants.EXTENDED_REQUEST_NAME_TAG,
1856                 new StoreExtendedRequestName() );
1857 
1858         // --------------------------------------------------------------------------------------------
1859         // Transition from RequestName to RequestValue
1860         // --------------------------------------------------------------------------------------------
1861         // ExtendedRequest ::= [APPLICATION 23] SEQUENCE {
1862         //     ...
1863         //     requestValue  [1] OCTET STRING OPTIONAL }
1864         //
1865         // Stores the value
1866         super.transitions[LdapStatesEnum.REQUEST_NAME_STATE.ordinal()][LdapConstants.EXTENDED_REQUEST_VALUE_TAG] =
1867             new GrammarTransition(
1868                 LdapStatesEnum.REQUEST_NAME_STATE,
1869                 LdapStatesEnum.REQUEST_VALUE_STATE,
1870                 LdapConstants.EXTENDED_REQUEST_VALUE_TAG,
1871                 new StoreExtendedRequestValue() );
1872 
1873         // --------------------------------------------------------------------------------------------
1874         // Transition from RequestName to Controls
1875         // --------------------------------------------------------------------------------------------
1876         //         extendedRequest   EtendedRequest,
1877         //         ... },
1878         //     controls       [0] Controls OPTIONAL }
1879         //
1880         // Stores the value
1881         super.transitions[LdapStatesEnum.REQUEST_NAME_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
1882             new GrammarTransition(
1883                 LdapStatesEnum.REQUEST_NAME_STATE,
1884                 LdapStatesEnum.CONTROLS_STATE,
1885                 LdapConstants.CONTROLS_TAG,
1886                 new InitControls() );
1887 
1888         // --------------------------------------------------------------------------------------------
1889         // Transition from RequestValue to Controls
1890         // --------------------------------------------------------------------------------------------
1891         //         extendedRequest   EtendedRequest,
1892         //         ... },
1893         //     controls       [0] Controls OPTIONAL }
1894         //
1895         // Stores the value
1896         super.transitions[LdapStatesEnum.REQUEST_VALUE_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
1897             new GrammarTransition(
1898                 LdapStatesEnum.REQUEST_VALUE_STATE,
1899                 LdapStatesEnum.CONTROLS_STATE,
1900                 LdapConstants.CONTROLS_TAG,
1901                 new InitControls() );
1902 
1903         // --------------------------------------------------------------------------------------------
1904         // Transition from MessageId to ExtendedResponse Message.
1905         // --------------------------------------------------------------------------------------------
1906         // LdapMessage ::= ... ExtendedResponse ...
1907         // ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
1908         //
1909         // Creates the ExtendeResponse object
1910         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.EXTENDED_RESPONSE_TAG] =
1911             new GrammarTransition(
1912                 LdapStatesEnum.MESSAGE_ID_STATE,
1913                 LdapStatesEnum.EXTENDED_RESPONSE_STATE,
1914                 LdapConstants.EXTENDED_RESPONSE_TAG,
1915                 new InitExtendedResponse() );
1916 
1917         // --------------------------------------------------------------------------------------------
1918         // Transition from ExtendedResponse Message to Result Code ER
1919         // --------------------------------------------------------------------------------------------
1920         // LdapMessage ::= ... ExtendedResponse ...
1921         // ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
1922         //     COMPONENTS OF LDAPResult,
1923         //     ...
1924         //
1925         // Stores the result code
1926         super.transitions[LdapStatesEnum.EXTENDED_RESPONSE_STATE.ordinal()][ENUMERATED.getValue()] =
1927             new GrammarTransition(
1928                 LdapStatesEnum.EXTENDED_RESPONSE_STATE,
1929                 LdapStatesEnum.RESULT_CODE_ER_STATE,
1930                 ENUMERATED,
1931                 new StoreResultCode() );
1932 
1933         // --------------------------------------------------------------------------------------------
1934         // Transition from Result Code ER to Matched Dn ER
1935         // --------------------------------------------------------------------------------------------
1936         // LdapMessage ::= ... ExtendedResponse ...
1937         // ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
1938         //     COMPONENTS OF LDAPResult,
1939         //     ...
1940         //
1941         //
1942         super.transitions[LdapStatesEnum.RESULT_CODE_ER_STATE.ordinal()][OCTET_STRING.getValue()] =
1943             new GrammarTransition(
1944                 LdapStatesEnum.RESULT_CODE_ER_STATE,
1945                 LdapStatesEnum.MATCHED_DN_ER_STATE,
1946                 OCTET_STRING,
1947                 new StoreMatchedDN() );
1948 
1949         // --------------------------------------------------------------------------------------------
1950         // Transition from Matched Dn ER to Error Message ER
1951         // --------------------------------------------------------------------------------------------
1952         // LdapMessage ::= ... ExtendedResponse ...
1953         // ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
1954         //     COMPONENTS OF LDAPResult,
1955         //     ...
1956         //
1957         //
1958         super.transitions[LdapStatesEnum.MATCHED_DN_ER_STATE.ordinal()][OCTET_STRING.getValue()] =
1959             new GrammarTransition(
1960                 LdapStatesEnum.MATCHED_DN_ER_STATE,
1961                 LdapStatesEnum.ERROR_MESSAGE_ER_STATE,
1962                 OCTET_STRING,
1963                 new StoreErrorMessage() );
1964 
1965         // --------------------------------------------------------------------------------------------
1966         // Transition from Error Message ER to Referrals ER
1967         // --------------------------------------------------------------------------------------------
1968         // LdapMessage ::= ... ExtendedResponse ...
1969         // ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
1970         //     COMPONENTS OF LDAPResult,
1971         //     ...
1972         //
1973         //
1974         super.transitions[LdapStatesEnum.ERROR_MESSAGE_ER_STATE.ordinal()][LdapConstants.LDAP_RESULT_REFERRAL_SEQUENCE_TAG] =
1975             new GrammarTransition(
1976                 LdapStatesEnum.ERROR_MESSAGE_ER_STATE,
1977                 LdapStatesEnum.REFERRALS_ER_STATE,
1978                 LdapConstants.LDAP_RESULT_REFERRAL_SEQUENCE_TAG,
1979                 new InitReferrals() );
1980 
1981         // --------------------------------------------------------------------------------------------
1982         // Transition from Referrals ER to Referral ER
1983         // --------------------------------------------------------------------------------------------
1984         // Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI (RFC 4511)
1985         // URI ::= LDAPString
1986         //
1987         // Add a first Referral
1988         super.transitions[LdapStatesEnum.REFERRALS_ER_STATE.ordinal()][OCTET_STRING.getValue()] =
1989             new GrammarTransition(
1990                 LdapStatesEnum.REFERRALS_ER_STATE,
1991                 LdapStatesEnum.REFERRAL_ER_STATE,
1992                 OCTET_STRING,
1993                 new AddReferral() );
1994 
1995         // --------------------------------------------------------------------------------------------
1996         // Transition from Referral ER to Referral ER
1997         // --------------------------------------------------------------------------------------------
1998         // Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI (RFC 4511)
1999         // URI ::= LDAPString
2000         //
2001         // Adda new Referral
2002         super.transitions[LdapStatesEnum.REFERRAL_ER_STATE.ordinal()][OCTET_STRING.getValue()] =
2003             new GrammarTransition(
2004                 LdapStatesEnum.REFERRAL_ER_STATE,
2005                 LdapStatesEnum.REFERRAL_ER_STATE,
2006                 OCTET_STRING,
2007                 new AddReferral() );
2008 
2009         // --------------------------------------------------------------------------------------------
2010         // Transition from Referral ER to ResponseName
2011         // --------------------------------------------------------------------------------------------
2012         // Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI (RFC 4511)
2013         // URI ::= LDAPString
2014         //
2015         // Adda new Referral
2016         super.transitions[LdapStatesEnum.REFERRAL_ER_STATE.ordinal()][LdapConstants.EXTENDED_RESPONSE_RESPONSE_NAME_TAG] =
2017             new GrammarTransition(
2018                 LdapStatesEnum.REFERRAL_ER_STATE,
2019                 LdapStatesEnum.RESPONSE_NAME_STATE,
2020                 LdapConstants.EXTENDED_RESPONSE_RESPONSE_NAME_TAG,
2021                 new StoreExtendedResponseName() );
2022 
2023         // --------------------------------------------------------------------------------------------
2024         // Transition from Referral ER to Response
2025         // --------------------------------------------------------------------------------------------
2026         // Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI (RFC 4511)
2027         // URI ::= LDAPString
2028         //
2029         // Add a new Referral
2030         super.transitions[LdapStatesEnum.REFERRAL_ER_STATE.ordinal()][LdapConstants.EXTENDED_RESPONSE_RESPONSE_TAG] =
2031             new GrammarTransition(
2032                 LdapStatesEnum.REFERRAL_ER_STATE,
2033                 LdapStatesEnum.RESPONSE_STATE,
2034                 LdapConstants.EXTENDED_RESPONSE_RESPONSE_TAG,
2035                 new StoreExtendedResponseValue() );
2036 
2037         // --------------------------------------------------------------------------------------------
2038         // Transition from Referral ER to Controls
2039         // --------------------------------------------------------------------------------------------
2040         //         extendedResponse   ExtendedResponse,
2041         //         ... },
2042         //     controls       [0] Controls OPTIONAL }
2043         //
2044         // Adda new Referral
2045         super.transitions[LdapStatesEnum.REFERRAL_ER_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
2046             new GrammarTransition(
2047                 LdapStatesEnum.REFERRAL_ER_STATE,
2048                 LdapStatesEnum.CONTROLS_STATE,
2049                 LdapConstants.CONTROLS_TAG,
2050                 new InitControls() );
2051 
2052         // --------------------------------------------------------------------------------------------
2053         // Transition from Error Message ER to Controls
2054         // --------------------------------------------------------------------------------------------
2055         // LdapMessage ::= ... ExtendedResponse ...
2056         // ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
2057         //     COMPONENTS OF LDAPResult,
2058         //     ...
2059         //
2060         //
2061         super.transitions[LdapStatesEnum.ERROR_MESSAGE_ER_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
2062             new GrammarTransition(
2063                 LdapStatesEnum.ERROR_MESSAGE_ER_STATE,
2064                 LdapStatesEnum.CONTROLS_STATE,
2065                 LdapConstants.CONTROLS_TAG,
2066                 new InitControls() );
2067 
2068         // --------------------------------------------------------------------------------------------
2069         // Transition from Error Message ER to ResponseName
2070         // --------------------------------------------------------------------------------------------
2071         // LdapMessage ::= ... ExtendedResponse ...
2072         // ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
2073         //     COMPONENTS OF LDAPResult,
2074         //     responseName   [10] LDAPOID OPTIONAL,
2075         //     ...
2076         //
2077         // Stores the response name
2078         super.transitions[LdapStatesEnum.ERROR_MESSAGE_ER_STATE.ordinal()][LdapConstants.EXTENDED_RESPONSE_RESPONSE_NAME_TAG] =
2079             new GrammarTransition(
2080                 LdapStatesEnum.ERROR_MESSAGE_ER_STATE,
2081                 LdapStatesEnum.RESPONSE_NAME_STATE,
2082                 LdapConstants.EXTENDED_RESPONSE_RESPONSE_NAME_TAG,
2083                 new StoreExtendedResponseName() );
2084 
2085         // --------------------------------------------------------------------------------------------
2086         // Transition from Response Name to Response
2087         // --------------------------------------------------------------------------------------------
2088         // LdapMessage ::= ... ExtendedResponse ...
2089         // ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
2090         //     ...
2091         //     responseName   [10] LDAPOID OPTIONAL,
2092         //     response       [11] OCTET STRING OPTIONAL}
2093         //
2094         // Stores the response
2095         super.transitions[LdapStatesEnum.RESPONSE_NAME_STATE.ordinal()][LdapConstants.EXTENDED_RESPONSE_RESPONSE_TAG] =
2096             new GrammarTransition(
2097                 LdapStatesEnum.RESPONSE_NAME_STATE,
2098                 LdapStatesEnum.RESPONSE_STATE,
2099                 LdapConstants.EXTENDED_RESPONSE_RESPONSE_TAG,
2100                 new StoreExtendedResponseValue() );
2101 
2102         // --------------------------------------------------------------------------------------------
2103         // Transition from ResponseName to Controls
2104         // --------------------------------------------------------------------------------------------
2105         //         extendedRequest   EtendedRequest,
2106         //         ... },
2107         //     controls       [0] Controls OPTIONAL }
2108         //
2109         // Init the controls
2110         super.transitions[LdapStatesEnum.RESPONSE_NAME_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
2111             new GrammarTransition(
2112                 LdapStatesEnum.RESPONSE_NAME_STATE,
2113                 LdapStatesEnum.CONTROLS_STATE,
2114                 LdapConstants.CONTROLS_TAG,
2115                 new InitControls() );
2116 
2117         // --------------------------------------------------------------------------------------------
2118         // Transition from Error Message ER to Response
2119         // --------------------------------------------------------------------------------------------
2120         // LdapMessage ::= ... ExtendedResponse ...
2121         // ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
2122         //     COMPONENTS OF LDAPResult,
2123         //     ...
2124         //     response       [11] OCTET STRING OPTIONAL}
2125         //
2126         // Stores the response
2127         super.transitions[LdapStatesEnum.ERROR_MESSAGE_ER_STATE.ordinal()][LdapConstants.EXTENDED_RESPONSE_RESPONSE_TAG] =
2128             new GrammarTransition(
2129                 LdapStatesEnum.ERROR_MESSAGE_ER_STATE,
2130                 LdapStatesEnum.RESPONSE_STATE,
2131                 LdapConstants.EXTENDED_RESPONSE_RESPONSE_TAG,
2132                 new StoreExtendedResponseValue() );
2133 
2134         // --------------------------------------------------------------------------------------------
2135         // Transition from Response to Controls
2136         // --------------------------------------------------------------------------------------------
2137         //         extendedRequest   EtendedRequest,
2138         //         ... },
2139         //     controls       [0] Controls OPTIONAL }
2140         //
2141         // Init the controls
2142         super.transitions[LdapStatesEnum.RESPONSE_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
2143             new GrammarTransition(
2144                 LdapStatesEnum.RESPONSE_STATE,
2145                 LdapStatesEnum.CONTROLS_STATE,
2146                 LdapConstants.CONTROLS_TAG,
2147                 new InitControls() );
2148 
2149         // --------------------------------------------------------------------------------------------
2150         // Transition from Message Id to IntermediateResponse Message
2151         // --------------------------------------------------------------------------------------------
2152         // LdapMessage ::= ... IntermediateResponse ...
2153         // IntermediateResponse ::= [APPLICATION 25] SEQUENCE {
2154         //
2155         // Creates the IntermediateResponse object
2156         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.INTERMEDIATE_RESPONSE_TAG] =
2157             new GrammarTransition(
2158                 LdapStatesEnum.MESSAGE_ID_STATE,
2159                 LdapStatesEnum.INTERMEDIATE_RESPONSE_STATE,
2160                 LdapConstants.INTERMEDIATE_RESPONSE_TAG,
2161                 new InitIntermediateResponse() );
2162 
2163         // --------------------------------------------------------------------------------------------
2164         // Transition from IntermediateResponse Message to ResponseName
2165         // --------------------------------------------------------------------------------------------
2166         // IntermediateResponse ::= [APPLICATION 25] SEQUENCE {
2167         //     responseName [0] LDAPOID OPTIONAL,
2168         //     ...
2169         //
2170         // Stores the name
2171         super.transitions[LdapStatesEnum.INTERMEDIATE_RESPONSE_STATE.ordinal()][LdapConstants.INTERMEDIATE_RESPONSE_NAME_TAG] =
2172             new GrammarTransition(
2173                 LdapStatesEnum.INTERMEDIATE_RESPONSE_STATE,
2174                 LdapStatesEnum.INTERMEDIATE_RESPONSE_NAME_STATE,
2175                 LdapConstants.INTERMEDIATE_RESPONSE_NAME_TAG,
2176                 new StoreIntermediateResponseName() );
2177 
2178         // --------------------------------------------------------------------------------------------
2179         // Transition from IntermediateResponse Message to ResponseValue (ResponseName is null)
2180         // --------------------------------------------------------------------------------------------
2181         // IntermediateResponse ::= [APPLICATION 25] SEQUENCE {
2182         //     ...
2183         //     responseValue [1] OCTET STRING OPTIONAL
2184         //     }
2185         //
2186         // Stores the value
2187         super.transitions[LdapStatesEnum.INTERMEDIATE_RESPONSE_STATE.ordinal()][LdapConstants.INTERMEDIATE_RESPONSE_VALUE_TAG] =
2188             new GrammarTransition(
2189                 LdapStatesEnum.INTERMEDIATE_RESPONSE_STATE,
2190                 LdapStatesEnum.INTERMEDIATE_RESPONSE_VALUE_STATE,
2191                 LdapConstants.INTERMEDIATE_RESPONSE_VALUE_TAG,
2192                 new StoreIntermediateResponseValue() );
2193 
2194         // --------------------------------------------------------------------------------------------
2195         // Transition from ResponseName to ResponseValue
2196         // --------------------------------------------------------------------------------------------
2197         // IntermediateResponse ::= [APPLICATION 25] SEQUENCE {
2198         //     ...
2199         //     responseValue  [1] OCTET STRING OPTIONAL }
2200         //
2201         // Stores the value
2202         super.transitions[LdapStatesEnum.INTERMEDIATE_RESPONSE_NAME_STATE.ordinal()][LdapConstants.INTERMEDIATE_RESPONSE_VALUE_TAG] =
2203             new GrammarTransition(
2204                 LdapStatesEnum.INTERMEDIATE_RESPONSE_NAME_STATE,
2205                 LdapStatesEnum.INTERMEDIATE_RESPONSE_VALUE_STATE,
2206                 LdapConstants.INTERMEDIATE_RESPONSE_VALUE_TAG,
2207                 new StoreIntermediateResponseValue() );
2208 
2209         // --------------------------------------------------------------------------------------------
2210         // Transition from ResponseName to Controls
2211         // --------------------------------------------------------------------------------------------
2212         //         intermediateResponse   IntermediateResponse,
2213         //         ... },
2214         //     controls       [0] Controls OPTIONAL }
2215         //
2216         // Stores the value
2217         super.transitions[LdapStatesEnum.INTERMEDIATE_RESPONSE_NAME_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
2218             new GrammarTransition(
2219                 LdapStatesEnum.INTERMEDIATE_RESPONSE_NAME_STATE,
2220                 LdapStatesEnum.CONTROLS_STATE,
2221                 LdapConstants.CONTROLS_TAG,
2222                 new InitControls() );
2223 
2224         // --------------------------------------------------------------------------------------------
2225         // Transition from ResponseValue to Controls
2226         // --------------------------------------------------------------------------------------------
2227         //         intermediateResponse   IntermediateResponse,
2228         //         ... },
2229         //     controls       [0] Controls OPTIONAL }
2230         //
2231         // Stores the value
2232         super.transitions[LdapStatesEnum.INTERMEDIATE_RESPONSE_VALUE_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
2233             new GrammarTransition(
2234                 LdapStatesEnum.INTERMEDIATE_RESPONSE_VALUE_STATE,
2235                 LdapStatesEnum.CONTROLS_STATE,
2236                 LdapConstants.CONTROLS_TAG,
2237                 new InitControls() );
2238 
2239         // ============================================================================================
2240         // Transition from Controls to Control
2241         // ============================================================================================
2242         // ...
2243         // Controls ::= SEQUENCE OF Control
2244         //  ...
2245         //
2246         // Initialize the controls
2247         super.transitions[LdapStatesEnum.CONTROLS_STATE.ordinal()][SEQUENCE.getValue()] =
2248             new GrammarTransition(
2249                 LdapStatesEnum.CONTROLS_STATE,
2250                 LdapStatesEnum.CONTROL_STATE,
2251                 SEQUENCE,
2252                 new CheckLengthNotNull() );
2253 
2254         // ============================================================================================
2255         // Transition from Control to ControlType
2256         // ============================================================================================
2257         // Control ::= SEQUENCE {
2258         //     ...
2259         //
2260         // Create a new Control object, and store it in the message Container
2261         super.transitions[LdapStatesEnum.CONTROL_STATE.ordinal()][OCTET_STRING.getValue()] =
2262             new GrammarTransition(
2263                 LdapStatesEnum.CONTROL_STATE,
2264                 LdapStatesEnum.CONTROL_TYPE_STATE,
2265                 OCTET_STRING,
2266                 new AddControl() );
2267 
2268         // ============================================================================================
2269         // Transition from ControlType to Control Criticality
2270         // ============================================================================================
2271         // Control ::= SEQUENCE {
2272         //     ...
2273         //     criticality BOOLEAN DEFAULT FALSE,
2274         //     ...
2275         //
2276         // Store the value in the control object created before
2277         super.transitions[LdapStatesEnum.CONTROL_TYPE_STATE.ordinal()][BOOLEAN.getValue()] =
2278             new GrammarTransition(
2279                 LdapStatesEnum.CONTROL_TYPE_STATE,
2280                 LdapStatesEnum.CRITICALITY_STATE,
2281                 OCTET_STRING,
2282                 new StoreControlCriticality() );
2283 
2284         // ============================================================================================
2285         // Transition from Control Criticality to Control Value
2286         // ============================================================================================
2287         // Control ::= SEQUENCE {
2288         //     ...
2289         //     controlValue OCTET STRING OPTIONAL }
2290         //
2291         // Store the value in the control object created before
2292         super.transitions[LdapStatesEnum.CRITICALITY_STATE.ordinal()][OCTET_STRING.getValue()] =
2293             new GrammarTransition(
2294                 LdapStatesEnum.CRITICALITY_STATE,
2295                 LdapStatesEnum.CONTROL_VALUE_STATE,
2296                 OCTET_STRING,
2297                 new StoreControlValue() );
2298 
2299         // ============================================================================================
2300         // Transition from Control Type to Control Value
2301         // ============================================================================================
2302         // Control ::= SEQUENCE {
2303         //     ...
2304         //     controlValue OCTET STRING OPTIONAL }
2305         //
2306         // Store the value in the control object created before
2307         super.transitions[LdapStatesEnum.CONTROL_TYPE_STATE.ordinal()][OCTET_STRING.getValue()] =
2308             new GrammarTransition(
2309                 LdapStatesEnum.CONTROL_TYPE_STATE,
2310                 LdapStatesEnum.CONTROL_VALUE_STATE,
2311                 OCTET_STRING,
2312                 new StoreControlValue() );
2313 
2314         // ============================================================================================
2315         // Transition from Control Type to Control
2316         // ============================================================================================
2317         // Control ::= SEQUENCE {
2318         //     ...
2319         //     controlValue OCTET STRING OPTIONAL }
2320         //
2321         // Store the value in the control object created before
2322         super.transitions[LdapStatesEnum.CONTROL_TYPE_STATE.ordinal()][SEQUENCE.getValue()] =
2323             new GrammarTransition(
2324                 LdapStatesEnum.CONTROL_TYPE_STATE,
2325                 LdapStatesEnum.CONTROL_STATE,
2326                 SEQUENCE,
2327                 new CheckLengthNotNull() );
2328 
2329         // ============================================================================================
2330         // Transition from Control Criticality to Control
2331         // ============================================================================================
2332         // Control ::= SEQUENCE {
2333         //     ...
2334         //     controlValue OCTET STRING OPTIONAL }
2335         //
2336         // Store the value in the control object created before
2337         super.transitions[LdapStatesEnum.CRITICALITY_STATE.ordinal()][SEQUENCE.getValue()] =
2338             new GrammarTransition(
2339                 LdapStatesEnum.CRITICALITY_STATE,
2340                 LdapStatesEnum.CONTROL_STATE,
2341                 SEQUENCE,
2342                 new CheckLengthNotNull() );
2343 
2344         // ============================================================================================
2345         // Transition from Control Value to Control
2346         // ============================================================================================
2347         // Control ::= SEQUENCE {
2348         //     ...
2349         //     controlValue OCTET STRING OPTIONAL }
2350         //
2351         // Store the value in the control object created before
2352         super.transitions[LdapStatesEnum.CONTROL_VALUE_STATE.ordinal()][SEQUENCE.getValue()] =
2353             new GrammarTransition(
2354                 LdapStatesEnum.CONTROL_VALUE_STATE,
2355                 LdapStatesEnum.CONTROL_STATE,
2356                 SEQUENCE,
2357                 new CheckLengthNotNull() );
2358 
2359         // --------------------------------------------------------------------------------------------
2360         // Transition from message ID to SearchRequest Message
2361         // --------------------------------------------------------------------------------------------
2362         // LdapMessage ::= ... SearchRequest ...
2363         // SearchRequest ::= [APPLICATION 3] SEQUENCE { ...
2364         //
2365         // Initialize the searchRequest object
2366         super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.SEARCH_REQUEST_TAG] =
2367             new GrammarTransition(
2368                 LdapStatesEnum.MESSAGE_ID_STATE,
2369                 LdapStatesEnum.SEARCH_REQUEST_STATE,
2370                 LdapConstants.SEARCH_REQUEST_TAG,
2371                 new InitSearchRequest() );
2372 
2373         // --------------------------------------------------------------------------------------------
2374         // Transition from SearchRequest Message to BaseObject
2375         // --------------------------------------------------------------------------------------------
2376         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2377         //     baseObject LDAPDN,
2378         //     ...
2379         //
2380         // We have a value for the base object, we will store it in the message
2381         super.transitions[LdapStatesEnum.SEARCH_REQUEST_STATE.ordinal()][OCTET_STRING.getValue()] =
2382             new GrammarTransition(
2383                 LdapStatesEnum.SEARCH_REQUEST_STATE,
2384                 LdapStatesEnum.BASE_OBJECT_STATE,
2385                 OCTET_STRING,
2386                 new StoreSearchRequestBaseObject() );
2387 
2388         // --------------------------------------------------------------------------------------------
2389         // Transition from BaseObject to Scope
2390         // --------------------------------------------------------------------------------------------
2391         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2392         //     ...
2393         //     scope ENUMERATED {
2394         //         baseObject   (0),
2395         //         singleLevel  (1),
2396         //         wholeSubtree (2) },
2397         //     ...
2398         //
2399         // We have a value for the scope, we will store it in the message
2400         super.transitions[LdapStatesEnum.BASE_OBJECT_STATE.ordinal()][ENUMERATED.getValue()] =
2401             new GrammarTransition(
2402                 LdapStatesEnum.BASE_OBJECT_STATE,
2403                 LdapStatesEnum.SCOPE_STATE,
2404                 ENUMERATED,
2405                 new StoreSearchRequestScope() );
2406 
2407         // --------------------------------------------------------------------------------------------
2408         // Transition from Scope to DerefAlias
2409         // --------------------------------------------------------------------------------------------
2410         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2411         //     ...
2412         //     derefAliases ENUMERATED {
2413         //         neverDerefAliases   (0),
2414         //         derefInSearching    (1),
2415         //         derefFindingBaseObj (2),
2416         //         derefAlways         (3) },
2417         //     ...
2418         //
2419         // We have a value for the derefAliases, we will store it in the message
2420         super.transitions[LdapStatesEnum.SCOPE_STATE.ordinal()][ENUMERATED.getValue()] =
2421             new GrammarTransition(
2422                 LdapStatesEnum.SCOPE_STATE,
2423                 LdapStatesEnum.DEREF_ALIAS_STATE,
2424                 ENUMERATED,
2425                 new StoreSearchRequestDerefAlias() );
2426 
2427         // --------------------------------------------------------------------------------------------
2428         // Transition from DerefAlias to SizeLimit
2429         // --------------------------------------------------------------------------------------------
2430         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2431         //     ...
2432         //     sizeLimit INTEGER (0 .. maxInt),
2433         //     ...
2434         //
2435         // We have a value for the sizeLimit, we will store it in the message
2436         super.transitions[LdapStatesEnum.DEREF_ALIAS_STATE.ordinal()][INTEGER.getValue()] = new
2437             GrammarTransition(
2438                 LdapStatesEnum.DEREF_ALIAS_STATE,
2439                 LdapStatesEnum.SIZE_LIMIT_STATE,
2440                 INTEGER,
2441                 new StoreSearchRequestSizeLimit() );
2442 
2443         // --------------------------------------------------------------------------------------------
2444         // Transition from SizeLimit to TimeLimit
2445         // --------------------------------------------------------------------------------------------
2446         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2447         //     ...
2448         //     timeLimit INTEGER (0 .. maxInt),
2449         //     ...
2450         //
2451         // We have a value for the timeLimit, we will store it in the message
2452         super.transitions[LdapStatesEnum.SIZE_LIMIT_STATE.ordinal()][INTEGER.getValue()] =
2453             new GrammarTransition(
2454                 LdapStatesEnum.SIZE_LIMIT_STATE,
2455                 LdapStatesEnum.TIME_LIMIT_STATE,
2456                 INTEGER,
2457                 new StoreSearchRequestTimeLimit() );
2458 
2459         // --------------------------------------------------------------------------------------------
2460         // Transition from TimeLimit to TypesOnly
2461         // --------------------------------------------------------------------------------------------
2462         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2463         //     ...
2464         //     typesOnly BOOLEAN,
2465         //     ...
2466         //
2467         // We have a value for the typesOnly, we will store it in the message.
2468         super.transitions[LdapStatesEnum.TIME_LIMIT_STATE.ordinal()][BOOLEAN.getValue()] =
2469             new GrammarTransition(
2470                 LdapStatesEnum.TIME_LIMIT_STATE,
2471                 LdapStatesEnum.TYPES_ONLY_STATE,
2472                 BOOLEAN,
2473                 new StoreSearchRequestTypesOnly() );
2474 
2475         //============================================================================================
2476         // Search Request And Filter
2477         // This is quite complicated, because we have a tree structure to build,
2478         // and we may have many elements on each node. For instance, considering the
2479         // search filter :
2480         // (& (| (a = b) (c = d)) (! (e = f)) (attr =* h))
2481         // We will have to create an And filter with three children :
2482         //  - an Or child,
2483         //  - a Not child
2484         //  - and a Present child.
2485         // The Or child will also have two children.
2486         //
2487         // We know when we have a children while decoding the PDU, because the length
2488         // of its parent has not yet reached its expected length.
2489         //
2490         // This search filter :
2491         // (&(|(objectclass=top)(ou=contacts))(!(objectclass=ttt))(objectclass=*top))
2492         // is encoded like this :
2493         //                              +----------------+---------------+
2494         //                              | ExpectedLength | CurrentLength |
2495         //+-----------------------------+----------------+---------------+
2496         //|A0 52                        | 82             | 0             | new level 1
2497         //|   A1 24                     | 82 36          | 0 0           | new level 2
2498         //|      A3 12                  | 82 36 18       | 0 0 0         | new level 3
2499         //|         04 0B 'objectclass' | 82 36 18       | 0 0 13        |
2500         //|         04 03 'top'         | 82 36 18       | 0 20 18       |
2501         //|                             |       ^               ^        |
2502         //|                             |       |               |        |
2503         //|                             |       +---------------+        |
2504         //+-----------------------------* end level 3 -------------------*
2505         //|      A3 0E                  | 82 36 14       | 0 0 0         | new level 3
2506         //|         04 02 'ou'          | 82 36 14       | 0 0 4         |
2507         //|         04 08 'contacts'    | 82 36 14       | 38 36 14      |
2508         //|                             |    ^  ^             ^  ^       |
2509         //|                             |    |  |             |  |       |
2510         //|                             |    |  +-------------|--+       |
2511         //|                             |    +----------------+          |
2512         //+-----------------------------* end level 3, end level 2 ------*
2513         //|   A2 14                     | 82 20          | 38 0          | new level 2
2514         //|      A3 12                  | 82 20 18       | 38 0 0        | new level 3
2515         //|         04 0B 'objectclass' | 82 20 18       | 38 0 13       |
2516         //|         04 03 'ttt'         | 82 20 18       | 60 20 18      |
2517         //|                             |    ^  ^             ^  ^       |
2518         //|                             |    |  |             |  |       |
2519         //|                             |    |  +-------------|--+       |
2520         //|                             |    +----------------+          |
2521         //+-----------------------------* end level 3, end level 2 ------*
2522         //|   A4 14                     | 82 20          | 60 0          | new level 2
2523         //|      04 0B 'objectclass'    | 82 20          | 60 13         |
2524         //|      30 05                  | 82 20          | 60 13         |
2525         //|         82 03 'top'         | 82 20          | 82 20         |
2526         //|                             | ^  ^             ^  ^          |
2527         //|                             | |  |             |  |          |
2528         //|                             | |  +-------------|--+          |
2529         //|                             | +----------------+             |
2530         //+-----------------------------* end level 2, end level 1 ------*
2531         //+-----------------------------+----------------+---------------+
2532         //
2533         // When the current length equals the expected length of the parent PDU,
2534         // then we are able to 'close' the parent : it has all its children. This
2535         // is propagated through all the tree, until either there are no more
2536         // parents, or the expected length of the parent is different from the
2537         // current length.
2538 
2539         // --------------------------------------------------------------------------------------------
2540         // Transition from TypesOnly to AND filter
2541         // --------------------------------------------------------------------------------------------
2542         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2543         //     ...
2544         //     filter Filter,
2545         //     ...
2546         //
2547         // Filter ::= CHOICE {
2548         //     and             [0] SET OF Filter,
2549         //     ...
2550         //
2551         // Init AND filter
2552         super.transitions[LdapStatesEnum.TYPES_ONLY_STATE.ordinal()][LdapConstants.AND_FILTER_TAG] =
2553             new GrammarTransition(
2554                 LdapStatesEnum.TYPES_ONLY_STATE,
2555                 LdapStatesEnum.AND_STATE,
2556                 LdapConstants.AND_FILTER_TAG,
2557                 new InitAndFilter() );
2558 
2559         // --------------------------------------------------------------------------------------------
2560         // Transition from TypesOnly to OR filter
2561         // --------------------------------------------------------------------------------------------
2562         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2563         //     ...
2564         //     filter Filter,
2565         //     ...
2566         //
2567         // Filter ::= CHOICE {
2568         //     ...
2569         //     or              [1] SET OF Filter,
2570         //     ...
2571         //
2572         // Init OR filter
2573         super.transitions[LdapStatesEnum.TYPES_ONLY_STATE.ordinal()][LdapConstants.OR_FILTER_TAG] =
2574             new GrammarTransition(
2575                 LdapStatesEnum.TYPES_ONLY_STATE,
2576                 LdapStatesEnum.OR_STATE,
2577                 LdapConstants.OR_FILTER_TAG,
2578                 new InitOrFilter() );
2579 
2580         // --------------------------------------------------------------------------------------------
2581         // Transition from TypesOnly to NOT filter
2582         // --------------------------------------------------------------------------------------------
2583         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2584         //     ...
2585         //     filter Filter,
2586         //     ...
2587         //
2588         // Filter ::= CHOICE {
2589         //     ...
2590         //     not             [2] SET OF Filter,
2591         //     ...
2592         //
2593         // Init NOT filter
2594         super.transitions[LdapStatesEnum.TYPES_ONLY_STATE.ordinal()][LdapConstants.NOT_FILTER_TAG] =
2595             new GrammarTransition(
2596                 LdapStatesEnum.TYPES_ONLY_STATE,
2597                 LdapStatesEnum.NOT_STATE,
2598                 LdapConstants.NOT_FILTER_TAG,
2599                 new InitNotFilter() );
2600 
2601         // --------------------------------------------------------------------------------------------
2602         // Transition from TypesOnly to Equality Match filter
2603         // --------------------------------------------------------------------------------------------
2604         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2605         //     ...
2606         //     filter Filter,
2607         //     ...
2608         //
2609         // Filter ::= CHOICE {
2610         //     ...
2611         //     equalityMatch   [3] AttributeValueAssertion,
2612         //     ...
2613         //
2614         // Init Equality filter
2615         super.transitions[LdapStatesEnum.TYPES_ONLY_STATE.ordinal()][LdapConstants.EQUALITY_MATCH_FILTER_TAG] =
2616             new GrammarTransition(
2617                 LdapStatesEnum.TYPES_ONLY_STATE,
2618                 LdapStatesEnum.EQUALITY_MATCH_STATE,
2619                 LdapConstants.EQUALITY_MATCH_FILTER_TAG,
2620                 new InitEqualityMatchFilter() );
2621 
2622         // --------------------------------------------------------------------------------------------
2623         // Transition from TypesOnly to Substrings filter
2624         // --------------------------------------------------------------------------------------------
2625         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2626         //     ...
2627         //     filter Filter,
2628         //     ...
2629         //
2630         // Filter ::= CHOICE {
2631         //     ...
2632         //     substrings     [4] SubstringFilter,
2633         //     ...
2634         //
2635         // Init Substrings filter
2636         super.transitions[LdapStatesEnum.TYPES_ONLY_STATE.ordinal()][LdapConstants.SUBSTRINGS_FILTER_TAG] =
2637             new GrammarTransition(
2638                 LdapStatesEnum.TYPES_ONLY_STATE,
2639                 LdapStatesEnum.SUBSTRING_FILTER_STATE,
2640                 LdapConstants.SUBSTRINGS_FILTER_TAG,
2641                 new InitSubstringsFilter() );
2642 
2643         // --------------------------------------------------------------------------------------------
2644         // Transition from TypesOnly to GreaterOrEqual filter
2645         // --------------------------------------------------------------------------------------------
2646         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2647         //     ...
2648         //     filter Filter,
2649         //     ...
2650         //
2651         // Filter ::= CHOICE {
2652         //     ...
2653         //     greaterOrEqual  [5] AttributeValueAssertion,
2654         //     ...
2655         //
2656         // Init Greater Or Equal filter
2657         super.transitions[LdapStatesEnum.TYPES_ONLY_STATE.ordinal()][LdapConstants.GREATER_OR_EQUAL_FILTER_TAG] =
2658             new GrammarTransition(
2659                 LdapStatesEnum.TYPES_ONLY_STATE,
2660                 LdapStatesEnum.GREATER_OR_EQUAL_STATE,
2661                 LdapConstants.GREATER_OR_EQUAL_FILTER_TAG,
2662                 new InitGreaterOrEqualFilter() );
2663 
2664         // --------------------------------------------------------------------------------------------
2665         // Transition from TypesOnly to LessOrEqual filter
2666         // --------------------------------------------------------------------------------------------
2667         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2668         //     ...
2669         //     filter Filter,
2670         //     ...
2671         //
2672         // Filter ::= CHOICE {
2673         //     ...
2674         //     LessOrEqual    [6] AttributeValueAssertion,
2675         //     ...
2676         //
2677         // Init Less Or Equal filter
2678         super.transitions[LdapStatesEnum.TYPES_ONLY_STATE.ordinal()][LdapConstants.LESS_OR_EQUAL_FILTER_TAG] =
2679             new GrammarTransition(
2680                 LdapStatesEnum.TYPES_ONLY_STATE,
2681                 LdapStatesEnum.LESS_OR_EQUAL_STATE,
2682                 LdapConstants.LESS_OR_EQUAL_FILTER_TAG,
2683                 new InitLessOrEqualFilter() );
2684 
2685         // --------------------------------------------------------------------------------------------
2686         // Transition from TypesOnly to Present filter
2687         // --------------------------------------------------------------------------------------------
2688         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2689         //     ...
2690         //     filter Filter,
2691         //     ...
2692         //
2693         // Filter ::= CHOICE {
2694         //     ...
2695         //     present        [7] AttributeDescription,
2696         //     ...
2697         //
2698         // Init Present Match filter
2699         super.transitions[LdapStatesEnum.TYPES_ONLY_STATE.ordinal()][LdapConstants.PRESENT_FILTER_TAG] =
2700             new GrammarTransition(
2701                 LdapStatesEnum.TYPES_ONLY_STATE,
2702                 LdapStatesEnum.PRESENT_STATE,
2703                 LdapConstants.PRESENT_FILTER_TAG,
2704                 new InitPresentFilter() );
2705 
2706         // --------------------------------------------------------------------------------------------
2707         // Transition from TypesOnly to Approx Match filter
2708         // --------------------------------------------------------------------------------------------
2709         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2710         //     ...
2711         //     filter Filter,
2712         //     ...
2713         //
2714         // Filter ::= CHOICE {
2715         //     ...
2716         //     approxMatch     [8] AttributeValueAssertion,
2717         //     ...
2718         //
2719         // Init Approx Match filter
2720         super.transitions[LdapStatesEnum.TYPES_ONLY_STATE.ordinal()][LdapConstants.APPROX_MATCH_FILTER_TAG] =
2721             new GrammarTransition(
2722                 LdapStatesEnum.TYPES_ONLY_STATE,
2723                 LdapStatesEnum.APPROX_MATCH_STATE,
2724                 LdapConstants.APPROX_MATCH_FILTER_TAG,
2725                 new InitApproxMatchFilter() );
2726 
2727         // --------------------------------------------------------------------------------------------
2728         // Transition from TypesOnly to Extensible Match filter
2729         // --------------------------------------------------------------------------------------------
2730         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2731         //     ...
2732         //     filter Filter,
2733         //     ...
2734         //
2735         // Filter ::= CHOICE {
2736         //     ...
2737         //     extensibleMatch  [9] MatchingRuleAssertion,
2738         //     ...
2739         //
2740         // Init Extensible Match filter
2741         super.transitions[LdapStatesEnum.TYPES_ONLY_STATE.ordinal()][LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG] =
2742             new GrammarTransition(
2743                 LdapStatesEnum.TYPES_ONLY_STATE,
2744                 LdapStatesEnum.EXTENSIBLE_MATCH_STATE,
2745                 LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG,
2746                 new InitExtensibleMatchFilter() );
2747 
2748         // --------------------------------------------------------------------------------------------
2749         // Transition from AND to AND filter
2750         // --------------------------------------------------------------------------------------------
2751         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2752         //     ...
2753         //     filter Filter,
2754         //     ...
2755         //
2756         // Filter ::= CHOICE {
2757         //     and             [0] SET OF Filter,
2758         //     ...
2759         //
2760         // Init AND filter
2761         super.transitions[LdapStatesEnum.AND_STATE.ordinal()][LdapConstants.AND_FILTER_TAG] =
2762             new GrammarTransition(
2763                 LdapStatesEnum.AND_STATE,
2764                 LdapStatesEnum.AND_STATE,
2765                 LdapConstants.AND_FILTER_TAG,
2766                 new InitAndFilter() );
2767 
2768         // --------------------------------------------------------------------------------------------
2769         // Transition from AND to OR filter
2770         // --------------------------------------------------------------------------------------------
2771         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2772         //     ...
2773         //     filter Filter,
2774         //     ...
2775         //
2776         // Filter ::= CHOICE {
2777         //     ...
2778         //     or              [1] SET OF Filter,
2779         //     ...
2780         //
2781         // Init OR filter
2782         super.transitions[LdapStatesEnum.AND_STATE.ordinal()][LdapConstants.OR_FILTER_TAG] =
2783             new GrammarTransition(
2784                 LdapStatesEnum.AND_STATE,
2785                 LdapStatesEnum.OR_STATE,
2786                 LdapConstants.OR_FILTER_TAG,
2787                 new InitOrFilter() );
2788 
2789         // --------------------------------------------------------------------------------------------
2790         // Transition from AND to NOT filter
2791         // --------------------------------------------------------------------------------------------
2792         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2793         //     ...
2794         //     filter Filter,
2795         //     ...
2796         //
2797         // Filter ::= CHOICE {
2798         //     ...
2799         //     not             [2] SET OF Filter,
2800         //     ...
2801         //
2802         // Init NOT filter
2803         super.transitions[LdapStatesEnum.AND_STATE.ordinal()][LdapConstants.NOT_FILTER_TAG] =
2804             new GrammarTransition(
2805                 LdapStatesEnum.AND_STATE,
2806                 LdapStatesEnum.NOT_STATE,
2807                 LdapConstants.NOT_FILTER_TAG,
2808                 new InitNotFilter() );
2809 
2810         // --------------------------------------------------------------------------------------------
2811         // Transition from AND to Equality Match filter
2812         // --------------------------------------------------------------------------------------------
2813         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2814         //     ...
2815         //     filter Filter,
2816         //     ...
2817         //
2818         // Filter ::= CHOICE {
2819         //     ...
2820         //     equalityMatch   [3] AttributeValueAssertion,
2821         //     ...
2822         //
2823         // Init NOT filter
2824         super.transitions[LdapStatesEnum.AND_STATE.ordinal()][LdapConstants.EQUALITY_MATCH_FILTER_TAG] =
2825             new GrammarTransition(
2826                 LdapStatesEnum.AND_STATE,
2827                 LdapStatesEnum.EQUALITY_MATCH_STATE,
2828                 LdapConstants.EQUALITY_MATCH_FILTER_TAG,
2829                 new InitEqualityMatchFilter() );
2830 
2831         // --------------------------------------------------------------------------------------------
2832         // Transition from AND to Substrings filter
2833         // --------------------------------------------------------------------------------------------
2834         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2835         //     ...
2836         //     filter Filter,
2837         //     ...
2838         //
2839         // Filter ::= CHOICE {
2840         //     ...
2841         //     substrings     [4] SubstringFilter,
2842         //     ...
2843         //
2844         // Init Substrings filter
2845         super.transitions[LdapStatesEnum.AND_STATE.ordinal()][LdapConstants.SUBSTRINGS_FILTER_TAG] =
2846             new GrammarTransition(
2847                 LdapStatesEnum.AND_STATE,
2848                 LdapStatesEnum.SUBSTRING_FILTER_STATE,
2849                 LdapConstants.SUBSTRINGS_FILTER_TAG,
2850                 new InitSubstringsFilter() );
2851 
2852         // --------------------------------------------------------------------------------------------
2853         // Transition from AND to GreaterOrEqual filter
2854         // --------------------------------------------------------------------------------------------
2855         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2856         //     ...
2857         //     filter Filter,
2858         //     ...
2859         //
2860         // Filter ::= CHOICE {
2861         //     ...
2862         //     greaterOrEqual  [5] AttributeValueAssertion,
2863         //     ...
2864         //
2865         // Init Greater Or Equal filter
2866         super.transitions[LdapStatesEnum.AND_STATE.ordinal()][LdapConstants.GREATER_OR_EQUAL_FILTER_TAG] =
2867             new GrammarTransition(
2868                 LdapStatesEnum.AND_STATE,
2869                 LdapStatesEnum.GREATER_OR_EQUAL_STATE,
2870                 LdapConstants.GREATER_OR_EQUAL_FILTER_TAG,
2871                 new InitGreaterOrEqualFilter() );
2872 
2873         // --------------------------------------------------------------------------------------------
2874         // Transition from AND to LessOrEqual filter
2875         // --------------------------------------------------------------------------------------------
2876         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2877         //     ...
2878         //     filter Filter,
2879         //     ...
2880         //
2881         // Filter ::= CHOICE {
2882         //     ...
2883         //     LessOrEqual    [6] AttributeValueAssertion,
2884         //     ...
2885         //
2886         // Init Less Or Equal filter
2887         super.transitions[LdapStatesEnum.AND_STATE.ordinal()][LdapConstants.LESS_OR_EQUAL_FILTER_TAG] =
2888             new GrammarTransition(
2889                 LdapStatesEnum.AND_STATE,
2890                 LdapStatesEnum.LESS_OR_EQUAL_STATE,
2891                 LdapConstants.LESS_OR_EQUAL_FILTER_TAG,
2892                 new InitLessOrEqualFilter() );
2893 
2894         // --------------------------------------------------------------------------------------------
2895         // Transition from AND to Present filter
2896         // --------------------------------------------------------------------------------------------
2897         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2898         //     ...
2899         //     filter Filter,
2900         //     ...
2901         //
2902         // Filter ::= CHOICE {
2903         //     ...
2904         //     present        [7] AttributeDescription,
2905         //     ...
2906         //
2907         // Init Approx Match filter
2908         super.transitions[LdapStatesEnum.AND_STATE.ordinal()][LdapConstants.PRESENT_FILTER_TAG] =
2909             new GrammarTransition(
2910                 LdapStatesEnum.AND_STATE,
2911                 LdapStatesEnum.PRESENT_STATE,
2912                 LdapConstants.PRESENT_FILTER_TAG,
2913                 new InitPresentFilter() );
2914 
2915         // --------------------------------------------------------------------------------------------
2916         // Transition from AND to Approx Match filter
2917         // --------------------------------------------------------------------------------------------
2918         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2919         //     ...
2920         //     filter Filter,
2921         //     ...
2922         //
2923         // Filter ::= CHOICE {
2924         //     ...
2925         //     approxMatch     [8] AttributeValueAssertion,
2926         //     ...
2927         //
2928         // Init Approx Match filter
2929         super.transitions[LdapStatesEnum.AND_STATE.ordinal()][LdapConstants.APPROX_MATCH_FILTER_TAG] =
2930             new GrammarTransition(
2931                 LdapStatesEnum.AND_STATE,
2932                 LdapStatesEnum.APPROX_MATCH_STATE,
2933                 LdapConstants.APPROX_MATCH_FILTER_TAG,
2934                 new InitApproxMatchFilter() );
2935 
2936         // --------------------------------------------------------------------------------------------
2937         // Transition from AND to Extensible Match filter
2938         // --------------------------------------------------------------------------------------------
2939         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2940         //     ...
2941         //     filter Filter,
2942         //     ...
2943         //
2944         // Filter ::= CHOICE {
2945         //     ...
2946         //     extensibleMatch  [9] MatchingRuleAssertion,
2947         //     ...
2948         //
2949         // Init Approx Match filter
2950         super.transitions[LdapStatesEnum.AND_STATE.ordinal()][LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG] =
2951             new GrammarTransition(
2952                 LdapStatesEnum.AND_STATE,
2953                 LdapStatesEnum.EXTENSIBLE_MATCH_STATE,
2954                 LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG,
2955                 new InitExtensibleMatchFilter() );
2956 
2957         // --------------------------------------------------------------------------------------------
2958         // Transition from OR to AND filter
2959         // --------------------------------------------------------------------------------------------
2960         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2961         //     ...
2962         //     filter Filter,
2963         //     ...
2964         //
2965         // Filter ::= CHOICE {
2966         //     and             [0] SET OF Filter,
2967         //     ...
2968         //
2969         // Init AND filter
2970         super.transitions[LdapStatesEnum.OR_STATE.ordinal()][LdapConstants.AND_FILTER_TAG] =
2971             new GrammarTransition(
2972                 LdapStatesEnum.OR_STATE,
2973                 LdapStatesEnum.AND_STATE,
2974                 LdapConstants.AND_FILTER_TAG,
2975                 new InitAndFilter() );
2976 
2977         // --------------------------------------------------------------------------------------------
2978         // Transition from OR to OR filter
2979         // --------------------------------------------------------------------------------------------
2980         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
2981         //     ...
2982         //     filter Filter,
2983         //     ...
2984         //
2985         // Filter ::= CHOICE {
2986         //     ...
2987         //     or              [1] SET OF Filter,
2988         //     ...
2989         //
2990         // Init OR filter
2991         super.transitions[LdapStatesEnum.OR_STATE.ordinal()][LdapConstants.OR_FILTER_TAG] =
2992             new GrammarTransition(
2993                 LdapStatesEnum.OR_STATE,
2994                 LdapStatesEnum.OR_STATE,
2995                 LdapConstants.OR_FILTER_TAG,
2996                 new InitOrFilter() );
2997 
2998         // --------------------------------------------------------------------------------------------
2999         // Transition from OR to NOT filter
3000         // --------------------------------------------------------------------------------------------
3001         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3002         //     ...
3003         //     filter Filter,
3004         //     ...
3005         //
3006         // Filter ::= CHOICE {
3007         //     ...
3008         //     not             [2] SET OF Filter,
3009         //     ...
3010         //
3011         // Init NOT filter
3012         super.transitions[LdapStatesEnum.OR_STATE.ordinal()][LdapConstants.NOT_FILTER_TAG] =
3013             new GrammarTransition(
3014                 LdapStatesEnum.OR_STATE,
3015                 LdapStatesEnum.NOT_STATE,
3016                 LdapConstants.NOT_FILTER_TAG,
3017                 new InitNotFilter() );
3018 
3019         // --------------------------------------------------------------------------------------------
3020         // Transition from OR to Equality Match filter
3021         // --------------------------------------------------------------------------------------------
3022         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3023         //     ...
3024         //     filter Filter,
3025         //     ...
3026         //
3027         // Filter ::= CHOICE {
3028         //     ...
3029         //     equalityMatch   [3] AttributeValueAssertion,
3030         //     ...
3031         //
3032         // Init NOT filter
3033         super.transitions[LdapStatesEnum.OR_STATE.ordinal()][LdapConstants.EQUALITY_MATCH_FILTER_TAG] =
3034             new GrammarTransition(
3035                 LdapStatesEnum.OR_STATE,
3036                 LdapStatesEnum.EQUALITY_MATCH_STATE,
3037                 LdapConstants.EQUALITY_MATCH_FILTER_TAG,
3038                 new InitEqualityMatchFilter() );
3039 
3040         // --------------------------------------------------------------------------------------------
3041         // Transition from OR to Substrings filter
3042         // --------------------------------------------------------------------------------------------
3043         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3044         //     ...
3045         //     filter Filter,
3046         //     ...
3047         //
3048         // Filter ::= CHOICE {
3049         //     ...
3050         //     substrings     [4] SubstringFilter,
3051         //     ...
3052         //
3053         // Init Substrings filter
3054         super.transitions[LdapStatesEnum.OR_STATE.ordinal()][LdapConstants.SUBSTRINGS_FILTER_TAG] =
3055             new GrammarTransition(
3056                 LdapStatesEnum.OR_STATE,
3057                 LdapStatesEnum.SUBSTRING_FILTER_STATE,
3058                 LdapConstants.SUBSTRINGS_FILTER_TAG,
3059                 new InitSubstringsFilter() );
3060 
3061         // --------------------------------------------------------------------------------------------
3062         // Transition from OR to GreaterOrEqual filter
3063         // --------------------------------------------------------------------------------------------
3064         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3065         //     ...
3066         //     filter Filter,
3067         //     ...
3068         //
3069         // Filter ::= CHOICE {
3070         //     ...
3071         //     greaterOrEqual  [5] AttributeValueAssertion,
3072         //     ...
3073         //
3074         // Init Greater Or Equal filter
3075         super.transitions[LdapStatesEnum.OR_STATE.ordinal()][LdapConstants.GREATER_OR_EQUAL_FILTER_TAG] =
3076             new GrammarTransition(
3077                 LdapStatesEnum.OR_STATE,
3078                 LdapStatesEnum.GREATER_OR_EQUAL_STATE,
3079                 LdapConstants.GREATER_OR_EQUAL_FILTER_TAG,
3080                 new InitGreaterOrEqualFilter() );
3081 
3082         // --------------------------------------------------------------------------------------------
3083         // Transition from OR to LessOrEqual filter
3084         // --------------------------------------------------------------------------------------------
3085         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3086         //     ...
3087         //     filter Filter,
3088         //     ...
3089         //
3090         // Filter ::= CHOICE {
3091         //     ...
3092         //     LessOrEqual    [6] AttributeValueAssertion,
3093         //     ...
3094         //
3095         // Init Less Or Equal filter
3096         super.transitions[LdapStatesEnum.OR_STATE.ordinal()][LdapConstants.LESS_OR_EQUAL_FILTER_TAG] =
3097             new GrammarTransition(
3098                 LdapStatesEnum.OR_STATE,
3099                 LdapStatesEnum.LESS_OR_EQUAL_STATE,
3100                 LdapConstants.LESS_OR_EQUAL_FILTER_TAG,
3101                 new InitLessOrEqualFilter() );
3102 
3103         // --------------------------------------------------------------------------------------------
3104         // Transition from OR to Present filter
3105         // --------------------------------------------------------------------------------------------
3106         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3107         //     ...
3108         //     filter Filter,
3109         //     ...
3110         //
3111         // Filter ::= CHOICE {
3112         //     ...
3113         //     present        [7] AttributeDescription,
3114         //     ...
3115         //
3116         // Init Approx Match filter
3117         super.transitions[LdapStatesEnum.OR_STATE.ordinal()][LdapConstants.PRESENT_FILTER_TAG] =
3118             new GrammarTransition(
3119                 LdapStatesEnum.OR_STATE,
3120                 LdapStatesEnum.PRESENT_STATE,
3121                 LdapConstants.PRESENT_FILTER_TAG,
3122                 new InitPresentFilter() );
3123 
3124         // --------------------------------------------------------------------------------------------
3125         // Transition from OR to Approx Match filter
3126         // --------------------------------------------------------------------------------------------
3127         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3128         //     ...
3129         //     filter Filter,
3130         //     ...
3131         //
3132         // Filter ::= CHOICE {
3133         //     ...
3134         //     approxMatch     [8] AttributeValueAssertion,
3135         //     ...
3136         //
3137         // Init Approx Match filter
3138         super.transitions[LdapStatesEnum.OR_STATE.ordinal()][LdapConstants.APPROX_MATCH_FILTER_TAG] =
3139             new GrammarTransition(
3140                 LdapStatesEnum.OR_STATE,
3141                 LdapStatesEnum.APPROX_MATCH_STATE,
3142                 LdapConstants.APPROX_MATCH_FILTER_TAG,
3143                 new InitApproxMatchFilter() );
3144 
3145         // --------------------------------------------------------------------------------------------
3146         // Transition from OR to Extensible Match filter
3147         // --------------------------------------------------------------------------------------------
3148         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3149         //     ...
3150         //     filter Filter,
3151         //     ...
3152         //
3153         // Filter ::= CHOICE {
3154         //     ...
3155         //     extensibleMatch  [9] MatchingRuleAssertion,
3156         //     ...
3157         //
3158         // Init Approx Match filter
3159         super.transitions[LdapStatesEnum.OR_STATE.ordinal()][LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG] =
3160             new GrammarTransition(
3161                 LdapStatesEnum.OR_STATE,
3162                 LdapStatesEnum.EXTENSIBLE_MATCH_STATE,
3163                 LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG,
3164                 new InitExtensibleMatchFilter() );
3165 
3166         // --------------------------------------------------------------------------------------------
3167         // Transition from NOT to AND filter
3168         // --------------------------------------------------------------------------------------------
3169         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3170         //     ...
3171         //     filter Filter,
3172         //     ...
3173         //
3174         // Filter ::= CHOICE {
3175         //     and             [0] SET OF Filter,
3176         //     ...
3177         //
3178         // Init AND filter
3179         super.transitions[LdapStatesEnum.NOT_STATE.ordinal()][LdapConstants.AND_FILTER_TAG] =
3180             new GrammarTransition(
3181                 LdapStatesEnum.NOT_STATE,
3182                 LdapStatesEnum.AND_STATE,
3183                 LdapConstants.AND_FILTER_TAG,
3184                 new InitAndFilter() );
3185 
3186         // --------------------------------------------------------------------------------------------
3187         // Transition from NOT to OR filter
3188         // --------------------------------------------------------------------------------------------
3189         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3190         //     ...
3191         //     filter Filter,
3192         //     ...
3193         //
3194         // Filter ::= CHOICE {
3195         //     ...
3196         //     or              [1] SET OF Filter,
3197         //     ...
3198         //
3199         // Init OR filter
3200         super.transitions[LdapStatesEnum.NOT_STATE.ordinal()][LdapConstants.OR_FILTER_TAG] =
3201             new GrammarTransition(
3202                 LdapStatesEnum.NOT_STATE,
3203                 LdapStatesEnum.OR_STATE,
3204                 LdapConstants.OR_FILTER_TAG,
3205                 new InitOrFilter() );
3206 
3207         // --------------------------------------------------------------------------------------------
3208         // Transition from NOT to NOT filter
3209         // --------------------------------------------------------------------------------------------
3210         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3211         //     ...
3212         //     filter Filter,
3213         //     ...
3214         //
3215         // Filter ::= CHOICE {
3216         //     ...
3217         //     not             [2] SET OF Filter,
3218         //     ...
3219         //
3220         // Init NOT filter
3221         super.transitions[LdapStatesEnum.NOT_STATE.ordinal()][LdapConstants.NOT_FILTER_TAG] =
3222             new GrammarTransition(
3223                 LdapStatesEnum.NOT_STATE,
3224                 LdapStatesEnum.NOT_STATE,
3225                 LdapConstants.NOT_FILTER_TAG,
3226                 new InitNotFilter() );
3227 
3228         // --------------------------------------------------------------------------------------------
3229         // Transition from NOT to Equality Match filter
3230         // --------------------------------------------------------------------------------------------
3231         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3232         //     ...
3233         //     filter Filter,
3234         //     ...
3235         //
3236         // Filter ::= CHOICE {
3237         //     ...
3238         //     equalityMatch   [3] AttributeValueAssertion,
3239         //     ...
3240         //
3241         // Init NOT filter
3242         super.transitions[LdapStatesEnum.NOT_STATE.ordinal()][LdapConstants.EQUALITY_MATCH_FILTER_TAG] =
3243             new GrammarTransition(
3244                 LdapStatesEnum.NOT_STATE,
3245                 LdapStatesEnum.EQUALITY_MATCH_STATE,
3246                 LdapConstants.EQUALITY_MATCH_FILTER_TAG,
3247                 new InitEqualityMatchFilter() );
3248 
3249         // --------------------------------------------------------------------------------------------
3250         // Transition from NOT to Substrings filter
3251         // --------------------------------------------------------------------------------------------
3252         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3253         //     ...
3254         //     filter Filter,
3255         //     ...
3256         //
3257         // Filter ::= CHOICE {
3258         //     ...
3259         //     substrings     [4] SubstringFilter,
3260         //     ...
3261         //
3262         // Init Substrings filter
3263         super.transitions[LdapStatesEnum.NOT_STATE.ordinal()][LdapConstants.SUBSTRINGS_FILTER_TAG] =
3264             new GrammarTransition(
3265                 LdapStatesEnum.NOT_STATE,
3266                 LdapStatesEnum.SUBSTRING_FILTER_STATE,
3267                 LdapConstants.SUBSTRINGS_FILTER_TAG,
3268                 new InitSubstringsFilter() );
3269 
3270         // --------------------------------------------------------------------------------------------
3271         // Transition from NOT to GreaterOrEqual filter
3272         // --------------------------------------------------------------------------------------------
3273         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3274         //     ...
3275         //     filter Filter,
3276         //     ...
3277         //
3278         // Filter ::= CHOICE {
3279         //     ...
3280         //     greaterOrEqual  [5] AttributeValueAssertion,
3281         //     ...
3282         //
3283         // Init Greater Or Equal filter
3284         super.transitions[LdapStatesEnum.NOT_STATE.ordinal()][LdapConstants.GREATER_OR_EQUAL_FILTER_TAG] =
3285             new GrammarTransition(
3286                 LdapStatesEnum.NOT_STATE,
3287                 LdapStatesEnum.GREATER_OR_EQUAL_STATE,
3288                 LdapConstants.GREATER_OR_EQUAL_FILTER_TAG,
3289                 new InitGreaterOrEqualFilter() );
3290 
3291         // --------------------------------------------------------------------------------------------
3292         // Transition from NOT to LessOrEqual filter
3293         // --------------------------------------------------------------------------------------------
3294         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3295         //     ...
3296         //     filter Filter,
3297         //     ...
3298         //
3299         // Filter ::= CHOICE {
3300         //     ...
3301         //     LessOrEqual    [6] AttributeValueAssertion,
3302         //     ...
3303         //
3304         // Init Less Or Equal filter
3305         super.transitions[LdapStatesEnum.NOT_STATE.ordinal()][LdapConstants.LESS_OR_EQUAL_FILTER_TAG] =
3306             new GrammarTransition(
3307                 LdapStatesEnum.NOT_STATE,
3308                 LdapStatesEnum.LESS_OR_EQUAL_STATE,
3309                 LdapConstants.LESS_OR_EQUAL_FILTER_TAG,
3310                 new InitLessOrEqualFilter() );
3311 
3312         // --------------------------------------------------------------------------------------------
3313         // Transition from NOT to Present filter
3314         // --------------------------------------------------------------------------------------------
3315         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3316         //     ...
3317         //     filter Filter,
3318         //     ...
3319         //
3320         // Filter ::= CHOICE {
3321         //     ...
3322         //     present        [7] AttributeDescription,
3323         //     ...
3324         //
3325         // Init present filter
3326         super.transitions[LdapStatesEnum.NOT_STATE.ordinal()][LdapConstants.PRESENT_FILTER_TAG] =
3327             new GrammarTransition(
3328                 LdapStatesEnum.NOT_STATE,
3329                 LdapStatesEnum.PRESENT_STATE,
3330                 LdapConstants.PRESENT_FILTER_TAG,
3331                 new InitPresentFilter() );
3332 
3333         // --------------------------------------------------------------------------------------------
3334         // Transition from NOT to Approx Match filter
3335         // --------------------------------------------------------------------------------------------
3336         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3337         //     ...
3338         //     filter Filter,
3339         //     ...
3340         //
3341         // Filter ::= CHOICE {
3342         //     ...
3343         //     approxMatch     [8] AttributeValueAssertion,
3344         //     ...
3345         //
3346         // Init Approx Match filter
3347         super.transitions[LdapStatesEnum.NOT_STATE.ordinal()][LdapConstants.APPROX_MATCH_FILTER_TAG] =
3348             new GrammarTransition(
3349                 LdapStatesEnum.NOT_STATE,
3350                 LdapStatesEnum.APPROX_MATCH_STATE,
3351                 LdapConstants.APPROX_MATCH_FILTER_TAG,
3352                 new InitApproxMatchFilter() );
3353 
3354         // --------------------------------------------------------------------------------------------
3355         // Transition from NOT to Extensible Match filter
3356         // --------------------------------------------------------------------------------------------
3357         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3358         //     ...
3359         //     filter Filter,
3360         //     ...
3361         //
3362         // Filter ::= CHOICE {
3363         //     ...
3364         //     extensibleMatch  [9] MatchingRuleAssertion,
3365         //     ...
3366         //
3367         // Init extensible match filter
3368         super.transitions[LdapStatesEnum.NOT_STATE.ordinal()][LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG] =
3369             new GrammarTransition(
3370                 LdapStatesEnum.NOT_STATE,
3371                 LdapStatesEnum.EXTENSIBLE_MATCH_STATE,
3372                 LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG,
3373                 new InitExtensibleMatchFilter() );
3374 
3375         // --------------------------------------------------------------------------------------------
3376         // Transition from Equality match to Attribute Desc Filter
3377         // --------------------------------------------------------------------------------------------
3378         // Filter ::= CHOICE {
3379         //     ...
3380         //     equalityMatch  [3] AttributeValueAssertion,
3381         //     ...
3382         //
3383         // AttributeValueAssertion ::= SEQUENCE {
3384         //     attributeDesc   AttributeDescription,
3385         //     ...
3386         //
3387         // Init Attribute Desc filter
3388         super.transitions[LdapStatesEnum.EQUALITY_MATCH_STATE.ordinal()][OCTET_STRING.getValue()] =
3389             new GrammarTransition(
3390                 LdapStatesEnum.EQUALITY_MATCH_STATE,
3391                 LdapStatesEnum.ATTRIBUTE_DESC_FILTER_STATE,
3392                 OCTET_STRING,
3393                 new InitAttributeDescFilter() );
3394 
3395         // --------------------------------------------------------------------------------------------
3396         // Transition from Attribute Desc Filter to Assertion Value Filter
3397         // --------------------------------------------------------------------------------------------
3398         // Filter ::= CHOICE {
3399         //     ...
3400         //     equalityMatch  [3] AttributeValueAssertion,
3401         //     ...
3402         //
3403         // AttributeValueAssertion ::= SEQUENCE {
3404         //     ...
3405         //     assertionValue   AssertionValue }
3406         //
3407         // Init Assertion Value filter
3408         super.transitions[LdapStatesEnum.ATTRIBUTE_DESC_FILTER_STATE.ordinal()][OCTET_STRING.getValue()] =
3409             new GrammarTransition(
3410                 LdapStatesEnum.ATTRIBUTE_DESC_FILTER_STATE,
3411                 LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE,
3412                 OCTET_STRING,
3413                 new InitAssertionValueFilter() );
3414 
3415         // --------------------------------------------------------------------------------------------
3416         // Transition from Assertion Value Filter to AND filter
3417         // --------------------------------------------------------------------------------------------
3418         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3419         //     ...
3420         //     filter Filter,
3421         //     ...
3422         //
3423         // Filter ::= CHOICE {
3424         //     and             [0] SET OF Filter,
3425         //     ...
3426         //
3427         // Init AND filter
3428         super.transitions[LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE.ordinal()][LdapConstants.AND_FILTER_TAG] =
3429             new GrammarTransition(
3430                 LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE,
3431                 LdapStatesEnum.AND_STATE,
3432                 LdapConstants.AND_FILTER_TAG,
3433                 new InitAndFilter() );
3434 
3435         // --------------------------------------------------------------------------------------------
3436         // Transition from Assertion Value Filter to OR filter
3437         // --------------------------------------------------------------------------------------------
3438         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3439         //     ...
3440         //     filter Filter,
3441         //     ...
3442         //
3443         // Filter ::= CHOICE {
3444         //     ...
3445         //     or              [1] SET OF Filter,
3446         //     ...
3447         //
3448         // Init OR filter
3449         super.transitions[LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE.ordinal()][LdapConstants.OR_FILTER_TAG] =
3450             new GrammarTransition(
3451                 LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE,
3452                 LdapStatesEnum.OR_STATE,
3453                 LdapConstants.OR_FILTER_TAG,
3454                 new InitOrFilter() );
3455 
3456         // --------------------------------------------------------------------------------------------
3457         // Transition from Assertion Value Filter to NOT filter
3458         // --------------------------------------------------------------------------------------------
3459         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3460         //     ...
3461         //     filter Filter,
3462         //     ...
3463         //
3464         // Filter ::= CHOICE {
3465         //     ...
3466         //     not             [2] SET OF Filter,
3467         //     ...
3468         //
3469         // Init NOT filter
3470         super.transitions[LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE.ordinal()][LdapConstants.NOT_FILTER_TAG] =
3471             new GrammarTransition(
3472                 LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE,
3473                 LdapStatesEnum.NOT_STATE,
3474                 LdapConstants.NOT_FILTER_TAG,
3475                 new InitNotFilter() );
3476 
3477         // --------------------------------------------------------------------------------------------
3478         // Transition from Assertion Value Filter to Equality Match filter
3479         // --------------------------------------------------------------------------------------------
3480         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3481         //     ...
3482         //     filter Filter,
3483         //     ...
3484         //
3485         // Filter ::= CHOICE {
3486         //     ...
3487         //     equalityMatch   [3] AttributeValueAssertion,
3488         //     ...
3489         //
3490         // Init NOT filter
3491         super.transitions[LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE.ordinal()][LdapConstants.EQUALITY_MATCH_FILTER_TAG] =
3492             new GrammarTransition(
3493                 LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE,
3494                 LdapStatesEnum.EQUALITY_MATCH_STATE,
3495                 LdapConstants.EQUALITY_MATCH_FILTER_TAG,
3496                 new InitEqualityMatchFilter() );
3497 
3498         // --------------------------------------------------------------------------------------------
3499         // Transition from Assertion Value Filter to Substrings filter
3500         // --------------------------------------------------------------------------------------------
3501         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3502         //     ...
3503         //     filter Filter,
3504         //     ...
3505         //
3506         // Filter ::= CHOICE {
3507         //     ...
3508         //     substrings     [4] SubstringFilter,
3509         //     ...
3510         //
3511         // Init Substrings filter
3512         super.transitions[LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE.ordinal()][LdapConstants.SUBSTRINGS_FILTER_TAG] =
3513             new GrammarTransition(
3514                 LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE,
3515                 LdapStatesEnum.SUBSTRING_FILTER_STATE,
3516                 LdapConstants.SUBSTRINGS_FILTER_TAG,
3517                 new InitSubstringsFilter() );
3518 
3519         // --------------------------------------------------------------------------------------------
3520         // Transition from Assertion Value Filter to GreaterOrEqual filter
3521         // --------------------------------------------------------------------------------------------
3522         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3523         //     ...
3524         //     filter Filter,
3525         //     ...
3526         //
3527         // Filter ::= CHOICE {
3528         //     ...
3529         //     greaterOrEqual  [5] AttributeValueAssertion,
3530         //     ...
3531         //
3532         // Init Greater Or Equal filter
3533         super.transitions[LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE.ordinal()][LdapConstants.GREATER_OR_EQUAL_FILTER_TAG] =
3534             new GrammarTransition(
3535                 LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE,
3536                 LdapStatesEnum.GREATER_OR_EQUAL_STATE,
3537                 LdapConstants.GREATER_OR_EQUAL_FILTER_TAG,
3538                 new InitGreaterOrEqualFilter() );
3539 
3540         // --------------------------------------------------------------------------------------------
3541         // Transition from Assertion Value Filter to LessOrEqual filter
3542         // --------------------------------------------------------------------------------------------
3543         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3544         //     ...
3545         //     filter Filter,
3546         //     ...
3547         //
3548         // Filter ::= CHOICE {
3549         //     ...
3550         //     LessOrEqual    [6] AttributeValueAssertion,
3551         //     ...
3552         //
3553         // Init Less Or Equal filter
3554         super.transitions[LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE.ordinal()][LdapConstants.LESS_OR_EQUAL_FILTER_TAG] =
3555             new GrammarTransition(
3556                 LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE,
3557                 LdapStatesEnum.LESS_OR_EQUAL_STATE,
3558                 LdapConstants.LESS_OR_EQUAL_FILTER_TAG,
3559                 new InitLessOrEqualFilter() );
3560 
3561         // --------------------------------------------------------------------------------------------
3562         // Transition from Assertion Value Filter to Present filter
3563         // --------------------------------------------------------------------------------------------
3564         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3565         //     ...
3566         //     filter Filter,
3567         //     ...
3568         //
3569         // Filter ::= CHOICE {
3570         //     ...
3571         //     present        [7] AttributeDescription,
3572         //     ...
3573         //
3574         // Init present filter
3575         super.transitions[LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE.ordinal()][LdapConstants.PRESENT_FILTER_TAG] =
3576             new GrammarTransition(
3577                 LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE,
3578                 LdapStatesEnum.PRESENT_STATE,
3579                 LdapConstants.PRESENT_FILTER_TAG,
3580                 new InitPresentFilter() );
3581 
3582         // --------------------------------------------------------------------------------------------
3583         // Transition from Assertion Value Filter to Approx Match filter
3584         // --------------------------------------------------------------------------------------------
3585         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3586         //     ...
3587         //     filter Filter,
3588         //     ...
3589         //
3590         // Filter ::= CHOICE {
3591         //     ...
3592         //     approxMatch     [8] AttributeValueAssertion,
3593         //     ...
3594         //
3595         // Init Approx Match filter
3596         super.transitions[LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE.ordinal()][LdapConstants.APPROX_MATCH_FILTER_TAG] =
3597             new GrammarTransition(
3598                 LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE,
3599                 LdapStatesEnum.APPROX_MATCH_STATE,
3600                 LdapConstants.APPROX_MATCH_FILTER_TAG,
3601                 new InitApproxMatchFilter() );
3602 
3603         // --------------------------------------------------------------------------------------------
3604         // Transition from Assertion Value Filter to Extensible Match filter
3605         // --------------------------------------------------------------------------------------------
3606         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3607         //     ...
3608         //     filter Filter,
3609         //     ...
3610         //
3611         // Filter ::= CHOICE {
3612         //     ...
3613         //     extensibleMatch  [9] MatchingRuleAssertion,
3614         //     ...
3615         //
3616         // Init Assertion Value Filter filter
3617         super.transitions[LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE.ordinal()][LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG] =
3618             new GrammarTransition(
3619                 LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE,
3620                 LdapStatesEnum.EXTENSIBLE_MATCH_STATE,
3621                 LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG,
3622                 new InitExtensibleMatchFilter() );
3623 
3624         // --------------------------------------------------------------------------------------------
3625         // Transition from Assertion Value Filter to Attribute Description List
3626         // --------------------------------------------------------------------------------------------
3627         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3628         //     ...
3629         //     filter      Filter,
3630         //     attributes  AttributeDescriptionList }
3631         //
3632         // AttributeDescriptionList ::= SEQUENCE OF
3633         //     AttributeDescription
3634         //
3635         // Init attribute description list
3636         super.transitions[LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE.ordinal()][SEQUENCE.getValue()] =
3637             new GrammarTransition(
3638                 LdapStatesEnum.ASSERTION_VALUE_FILTER_STATE,
3639                 LdapStatesEnum.ATTRIBUTE_DESCRIPTION_LIST_STATE,
3640                 SEQUENCE,
3641                 new InitSearchRequestAttributeDescList() );
3642 
3643         // --------------------------------------------------------------------------------------------
3644         // Transition from Attribute Description List to AttributeDescription
3645         // --------------------------------------------------------------------------------------------
3646         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3647         //     ...
3648         //     filter      Filter,
3649         //     attributes  AttributeDescriptionList }
3650         //
3651         // AttributeDescriptionList ::= SEQUENCE OF
3652         //     AttributeDescription
3653         //
3654         // Store attribute description
3655         super.transitions[LdapStatesEnum.ATTRIBUTE_DESCRIPTION_LIST_STATE.ordinal()][OCTET_STRING.getValue()] =
3656             new GrammarTransition(
3657                 LdapStatesEnum.ATTRIBUTE_DESCRIPTION_LIST_STATE,
3658                 LdapStatesEnum.ATTRIBUTE_DESCRIPTION_STATE,
3659                 OCTET_STRING,
3660                 new StoreSearchRequestAttributeDesc() );
3661 
3662         // --------------------------------------------------------------------------------------------
3663         // Transition from Attribute Description List to Controls
3664         // --------------------------------------------------------------------------------------------
3665         //         searchRequest   SearchRequest,
3666         //         ... },
3667         //     controls       [0] Controls OPTIONAL }
3668         //
3669         // Empty attribute description list, with controls
3670         super.transitions[LdapStatesEnum.ATTRIBUTE_DESCRIPTION_LIST_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
3671             new GrammarTransition(
3672                 LdapStatesEnum.ATTRIBUTE_DESCRIPTION_LIST_STATE,
3673                 LdapStatesEnum.CONTROLS_STATE,
3674                 LdapConstants.CONTROLS_TAG,
3675                 new InitControls() );
3676 
3677         // --------------------------------------------------------------------------------------------
3678         // Transition from Attribute Description to AttributeDescription
3679         // --------------------------------------------------------------------------------------------
3680         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3681         //     ...
3682         //     filter      Filter,
3683         //     attributes  AttributeDescriptionList }
3684         //
3685         // AttributeDescriptionList ::= SEQUENCE OF
3686         //     AttributeDescription
3687         //
3688         // Store attribute description
3689         super.transitions[LdapStatesEnum.ATTRIBUTE_DESCRIPTION_STATE.ordinal()][OCTET_STRING.getValue()] =
3690             new GrammarTransition(
3691                 LdapStatesEnum.ATTRIBUTE_DESCRIPTION_STATE,
3692                 LdapStatesEnum.ATTRIBUTE_DESCRIPTION_STATE,
3693                 OCTET_STRING,
3694                 new StoreSearchRequestAttributeDesc() );
3695 
3696         // --------------------------------------------------------------------------------------------
3697         // transition from Attribute Description to Controls.
3698         // --------------------------------------------------------------------------------------------
3699         //         searchRequest   SearchRequest,
3700         //         ... },
3701         //     controls       [0] Controls OPTIONAL }
3702         //
3703         super.transitions[LdapStatesEnum.ATTRIBUTE_DESCRIPTION_STATE.ordinal()][LdapConstants.CONTROLS_TAG] =
3704             new GrammarTransition(
3705                 LdapStatesEnum.ATTRIBUTE_DESCRIPTION_STATE,
3706                 LdapStatesEnum.CONTROLS_STATE,
3707                 LdapConstants.CONTROLS_TAG,
3708                 new InitControls() );
3709 
3710         // --------------------------------------------------------------------------------------------
3711         // Transition from Greater Or Equal to Attribute Desc Filter
3712         // --------------------------------------------------------------------------------------------
3713         // Filter ::= CHOICE {
3714         //     ...
3715         //     greaterOrEqual  [5] AttributeValueAssertion,
3716         //     ...
3717         //
3718         // AttributeValueAssertion ::= SEQUENCE {
3719         //     attributeDesc   AttributeDescription,
3720         //     ...
3721         //
3722         // Init Attribute Desc filter
3723         super.transitions[LdapStatesEnum.GREATER_OR_EQUAL_STATE.ordinal()][OCTET_STRING.getValue()] =
3724             new GrammarTransition(
3725                 LdapStatesEnum.GREATER_OR_EQUAL_STATE,
3726                 LdapStatesEnum.ATTRIBUTE_DESC_FILTER_STATE,
3727                 OCTET_STRING,
3728                 new InitAttributeDescFilter() );
3729 
3730         // --------------------------------------------------------------------------------------------
3731         // Transition from Less Or Equal to Attribute Desc Filter
3732         // --------------------------------------------------------------------------------------------
3733         // Filter ::= CHOICE {
3734         //     ...
3735         //     lessOrEqual  [6] AttributeValueAssertion,
3736         //     ...
3737         //
3738         // AttributeValueAssertion ::= SEQUENCE {
3739         //     attributeDesc   AttributeDescription,
3740         //     ...
3741         //
3742         // Init Attribute Desc filter
3743         super.transitions[LdapStatesEnum.LESS_OR_EQUAL_STATE.ordinal()][OCTET_STRING.getValue()] =
3744             new GrammarTransition(
3745                 LdapStatesEnum.LESS_OR_EQUAL_STATE,
3746                 LdapStatesEnum.ATTRIBUTE_DESC_FILTER_STATE,
3747                 OCTET_STRING,
3748                 new InitAttributeDescFilter() );
3749 
3750         // --------------------------------------------------------------------------------------------
3751         // Transition from Substrings to typeSubstring
3752         // --------------------------------------------------------------------------------------------
3753         // Filter ::= CHOICE {
3754         //     ...
3755         //     substrings  [4] SubstringFilter,
3756         //     ...
3757         //
3758         // SubstringFilter ::= SEQUENCE {
3759         //     type   AttributeDescription,
3760         //     ...
3761         //
3762         // Init substring type
3763         super.transitions[LdapStatesEnum.SUBSTRING_FILTER_STATE.ordinal()][OCTET_STRING.getValue()] =
3764             new GrammarTransition(
3765                 LdapStatesEnum.SUBSTRING_FILTER_STATE,
3766                 LdapStatesEnum.TYPE_SUBSTRING_STATE,
3767                 OCTET_STRING,
3768                 new StoreSubstringFilterType() );
3769 
3770         // --------------------------------------------------------------------------------------------
3771         // Transition from typeSubstring to substrings
3772         // --------------------------------------------------------------------------------------------
3773         // Filter ::= CHOICE {
3774         //     ...
3775         //     substrings  [4] SubstringFilter,
3776         //     ...
3777         //
3778         // SubstringFilter ::= SEQUENCE {
3779         //     ...
3780         //     substrings SEQUENCE OF CHOICE {
3781         //     ...
3782         //
3783         // Init substring type
3784         super.transitions[LdapStatesEnum.TYPE_SUBSTRING_STATE.ordinal()][SEQUENCE.getValue()] =
3785             new GrammarTransition(
3786                 LdapStatesEnum.TYPE_SUBSTRING_STATE,
3787                 LdapStatesEnum.SUBSTRINGS_STATE,
3788                 SEQUENCE,
3789                 new CheckNotNullLength<LdapMessageContainer<SearchRequestDecorator>>() );
3790 
3791         // --------------------------------------------------------------------------------------------
3792         // Transition from substrings to Initial
3793         // --------------------------------------------------------------------------------------------
3794         // SubstringFilter ::= SEQUENCE {
3795         //     ...
3796         //     substrings SEQUENCE OF CHOICE {
3797         //         initial  [0] LDAPSTRING,
3798         //         ...
3799         //
3800         // Store initial value
3801         super.transitions[LdapStatesEnum.SUBSTRINGS_STATE.ordinal()][LdapConstants.SUBSTRINGS_FILTER_INITIAL_TAG] =
3802             new GrammarTransition(
3803                 LdapStatesEnum.SUBSTRINGS_STATE,
3804                 LdapStatesEnum.INITIAL_STATE,
3805                 LdapConstants.SUBSTRINGS_FILTER_INITIAL_TAG,
3806                 new StoreInitial() );
3807 
3808         // --------------------------------------------------------------------------------------------
3809         // Transition from substrings to any
3810         // --------------------------------------------------------------------------------------------
3811         // SubstringFilter ::= SEQUENCE {
3812         //     ...
3813         //     substrings SEQUENCE OF CHOICE {
3814         //         ...
3815         //         any  [1] LDAPSTRING,
3816         //         ...
3817         //
3818         // Store substring any type
3819         super.transitions[LdapStatesEnum.SUBSTRINGS_STATE.ordinal()][LdapConstants.SUBSTRINGS_FILTER_ANY_TAG] =
3820             new GrammarTransition(
3821                 LdapStatesEnum.SUBSTRINGS_STATE,
3822                 LdapStatesEnum.ANY_STATE,
3823                 LdapConstants.SUBSTRINGS_FILTER_ANY_TAG,
3824                 new StoreAny() );
3825 
3826         // --------------------------------------------------------------------------------------------
3827         // Transition from substrings to final
3828         // --------------------------------------------------------------------------------------------
3829         // SubstringFilter ::= SEQUENCE {
3830         //     ...
3831         //     substrings SEQUENCE OF CHOICE {
3832         //         ...
3833         //         final  [2] LDAPSTRING }
3834         //
3835         // Store substring final type
3836         super.transitions[LdapStatesEnum.SUBSTRINGS_STATE.ordinal()][LdapConstants.SUBSTRINGS_FILTER_FINAL_TAG] =
3837             new GrammarTransition(
3838                 LdapStatesEnum.SUBSTRINGS_STATE,
3839                 LdapStatesEnum.FINAL_STATE,
3840                 LdapConstants.SUBSTRINGS_FILTER_FINAL_TAG,
3841                 new StoreFinal() );
3842 
3843         // --------------------------------------------------------------------------------------------
3844         // Transition from initial to any
3845         // --------------------------------------------------------------------------------------------
3846         // SubstringFilter ::= SEQUENCE {
3847         //     ...
3848         //     substrings SEQUENCE OF CHOICE {
3849         //         ...
3850         //         any  [1] LDAPSTRING,
3851         //         ...
3852         //
3853         // Store substring any type
3854         super.transitions[LdapStatesEnum.INITIAL_STATE.ordinal()][LdapConstants.SUBSTRINGS_FILTER_ANY_TAG] =
3855             new GrammarTransition(
3856                 LdapStatesEnum.INITIAL_STATE,
3857                 LdapStatesEnum.ANY_STATE,
3858                 LdapConstants.SUBSTRINGS_FILTER_ANY_TAG,
3859                 new StoreAny() );
3860 
3861         // --------------------------------------------------------------------------------------------
3862         // Transition from initial to final
3863         // --------------------------------------------------------------------------------------------
3864         // SubstringFilter ::= SEQUENCE {
3865         //     ...
3866         //     substrings SEQUENCE OF CHOICE {
3867         //         ...
3868         //         final  [2] LDAPSTRING }
3869         //
3870         // Store substring final type
3871         super.transitions[LdapStatesEnum.INITIAL_STATE.ordinal()][LdapConstants.SUBSTRINGS_FILTER_FINAL_TAG] =
3872             new GrammarTransition(
3873                 LdapStatesEnum.INITIAL_STATE,
3874                 LdapStatesEnum.FINAL_STATE,
3875                 LdapConstants.SUBSTRINGS_FILTER_FINAL_TAG,
3876                 new StoreFinal() );
3877 
3878         // --------------------------------------------------------------------------------------------
3879         // Transition from initial to Attribute Description List
3880         // --------------------------------------------------------------------------------------------
3881         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3882         //     ...
3883         //     filter      Filter,
3884         //     attributes  AttributeDescriptionList }
3885         //
3886         // AttributeDescriptionList ::= SEQUENCE OF
3887         //     AttributeDescription
3888         //
3889         // Init attribute description list
3890         super.transitions[LdapStatesEnum.INITIAL_STATE.ordinal()][SEQUENCE.getValue()] =
3891             new GrammarTransition(
3892                 LdapStatesEnum.INITIAL_STATE,
3893                 LdapStatesEnum.ATTRIBUTE_DESCRIPTION_LIST_STATE,
3894                 SEQUENCE,
3895                 new InitSearchRequestAttributeDescList() );
3896 
3897         // --------------------------------------------------------------------------------------------
3898         // Transition from initial to AND filter
3899         // --------------------------------------------------------------------------------------------
3900         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3901         //     ...
3902         //     filter Filter,
3903         //     ...
3904         //
3905         // Filter ::= CHOICE {
3906         //     and             [0] SET OF Filter,
3907         //     ...
3908         //
3909         // Init AND filter
3910         super.transitions[LdapStatesEnum.INITIAL_STATE.ordinal()][LdapConstants.AND_FILTER_TAG] =
3911             new GrammarTransition(
3912                 LdapStatesEnum.INITIAL_STATE,
3913                 LdapStatesEnum.AND_STATE,
3914                 LdapConstants.AND_FILTER_TAG,
3915                 new InitAndFilter() );
3916 
3917         // --------------------------------------------------------------------------------------------
3918         // Transition from initial to OR filter
3919         // --------------------------------------------------------------------------------------------
3920         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3921         //     ...
3922         //     filter Filter,
3923         //     ...
3924         //
3925         // Filter ::= CHOICE {
3926         //     ...
3927         //     or              [1] SET OF Filter,
3928         //     ...
3929         //
3930         // Init OR filter
3931         super.transitions[LdapStatesEnum.INITIAL_STATE.ordinal()][LdapConstants.OR_FILTER_TAG] =
3932             new GrammarTransition(
3933                 LdapStatesEnum.INITIAL_STATE,
3934                 LdapStatesEnum.OR_STATE,
3935                 LdapConstants.OR_FILTER_TAG,
3936                 new InitOrFilter() );
3937 
3938         // --------------------------------------------------------------------------------------------
3939         // Transition from initial to NOT filter
3940         // --------------------------------------------------------------------------------------------
3941         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3942         //     ...
3943         //     filter Filter,
3944         //     ...
3945         //
3946         // Filter ::= CHOICE {
3947         //     ...
3948         //     not             [2] SET OF Filter,
3949         //     ...
3950         //
3951         // Init NOT filter
3952         super.transitions[LdapStatesEnum.INITIAL_STATE.ordinal()][LdapConstants.NOT_FILTER_TAG] =
3953             new GrammarTransition(
3954                 LdapStatesEnum.INITIAL_STATE,
3955                 LdapStatesEnum.NOT_STATE,
3956                 LdapConstants.NOT_FILTER_TAG,
3957                 new InitNotFilter() );
3958 
3959         // --------------------------------------------------------------------------------------------
3960         // Transition from initial to Equality Match filter
3961         // --------------------------------------------------------------------------------------------
3962         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3963         //     ...
3964         //     filter Filter,
3965         //     ...
3966         //
3967         // Filter ::= CHOICE {
3968         //     ...
3969         //     equalityMatch   [3] AttributeValueAssertion,
3970         //     ...
3971         //
3972         // Init NOT filter
3973         super.transitions[LdapStatesEnum.INITIAL_STATE.ordinal()][LdapConstants.EQUALITY_MATCH_FILTER_TAG] =
3974             new GrammarTransition(
3975                 LdapStatesEnum.INITIAL_STATE,
3976                 LdapStatesEnum.EQUALITY_MATCH_STATE,
3977                 LdapConstants.EQUALITY_MATCH_FILTER_TAG,
3978                 new InitEqualityMatchFilter() );
3979 
3980         // --------------------------------------------------------------------------------------------
3981         // Transition from initial to Substrings filter
3982         // --------------------------------------------------------------------------------------------
3983         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
3984         //     ...
3985         //     filter Filter,
3986         //     ...
3987         //
3988         // Filter ::= CHOICE {
3989         //     ...
3990         //     substrings     [4] SubstringFilter,
3991         //     ...
3992         //
3993         // Init Substrings filter
3994         super.transitions[LdapStatesEnum.INITIAL_STATE.ordinal()][LdapConstants.SUBSTRINGS_FILTER_TAG] =
3995             new GrammarTransition(
3996                 LdapStatesEnum.INITIAL_STATE,
3997                 LdapStatesEnum.SUBSTRING_FILTER_STATE,
3998                 LdapConstants.SUBSTRINGS_FILTER_TAG,
3999                 new InitSubstringsFilter() );
4000 
4001         // --------------------------------------------------------------------------------------------
4002         // Transition from initial to GreaterOrEqual filter
4003         // --------------------------------------------------------------------------------------------
4004         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4005         //     ...
4006         //     filter Filter,
4007         //     ...
4008         //
4009         // Filter ::= CHOICE {
4010         //     ...
4011         //     greaterOrEqual  [5] AttributeValueAssertion,
4012         //     ...
4013         //
4014         // Init Greater Or Equal filter
4015         super.transitions[LdapStatesEnum.INITIAL_STATE.ordinal()][LdapConstants.GREATER_OR_EQUAL_FILTER_TAG] =
4016             new GrammarTransition(
4017                 LdapStatesEnum.INITIAL_STATE,
4018                 LdapStatesEnum.GREATER_OR_EQUAL_STATE,
4019                 LdapConstants.GREATER_OR_EQUAL_FILTER_TAG,
4020                 new InitGreaterOrEqualFilter() );
4021 
4022         // --------------------------------------------------------------------------------------------
4023         // Transition from initial to LessOrEqual filter
4024         // --------------------------------------------------------------------------------------------
4025         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4026         //     ...
4027         //     filter Filter,
4028         //     ...
4029         //
4030         // Filter ::= CHOICE {
4031         //     ...
4032         //     LessOrEqual    [6] AttributeValueAssertion,
4033         //     ...
4034         //
4035         // Init Less Or Equal filter
4036         super.transitions[LdapStatesEnum.INITIAL_STATE.ordinal()][LdapConstants.LESS_OR_EQUAL_FILTER_TAG] =
4037             new GrammarTransition(
4038                 LdapStatesEnum.INITIAL_STATE,
4039                 LdapStatesEnum.LESS_OR_EQUAL_STATE,
4040                 LdapConstants.LESS_OR_EQUAL_FILTER_TAG,
4041                 new InitLessOrEqualFilter() );
4042 
4043         // --------------------------------------------------------------------------------------------
4044         // Transition from initial to Present filter
4045         // --------------------------------------------------------------------------------------------
4046         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4047         //     ...
4048         //     filter Filter,
4049         //     ...
4050         //
4051         // Filter ::= CHOICE {
4052         //     ...
4053         //     present        [7] AttributeDescription,
4054         //     ...
4055         //
4056         // Init present filter
4057         super.transitions[LdapStatesEnum.INITIAL_STATE.ordinal()][LdapConstants.PRESENT_FILTER_TAG] =
4058             new GrammarTransition(
4059                 LdapStatesEnum.INITIAL_STATE,
4060                 LdapStatesEnum.PRESENT_STATE,
4061                 LdapConstants.PRESENT_FILTER_TAG,
4062                 new InitPresentFilter() );
4063 
4064         // --------------------------------------------------------------------------------------------
4065         // Transition from initial to Approx Match filter
4066         // --------------------------------------------------------------------------------------------
4067         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4068         //     ...
4069         //     filter Filter,
4070         //     ...
4071         //
4072         // Filter ::= CHOICE {
4073         //     ...
4074         //     approxMatch     [8] AttributeValueAssertion,
4075         //     ...
4076         //
4077         // Init Approx Match filter
4078         super.transitions[LdapStatesEnum.INITIAL_STATE.ordinal()][LdapConstants.APPROX_MATCH_FILTER_TAG] =
4079             new GrammarTransition(
4080                 LdapStatesEnum.INITIAL_STATE,
4081                 LdapStatesEnum.APPROX_MATCH_STATE,
4082                 LdapConstants.APPROX_MATCH_FILTER_TAG,
4083                 new InitApproxMatchFilter() );
4084 
4085         // --------------------------------------------------------------------------------------------
4086         // Transition from initial to Extensible Match filter
4087         // --------------------------------------------------------------------------------------------
4088         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4089         //     ...
4090         //     filter Filter,
4091         //     ...
4092         //
4093         // Filter ::= CHOICE {
4094         //     ...
4095         //     extensibleMatch  [9] MatchingRuleAssertion,
4096         //     ...
4097         //
4098         // Init Assertion Value Filter filter
4099         super.transitions[LdapStatesEnum.INITIAL_STATE.ordinal()][LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG] =
4100             new GrammarTransition(
4101                 LdapStatesEnum.INITIAL_STATE,
4102                 LdapStatesEnum.EXTENSIBLE_MATCH_STATE,
4103                 LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG,
4104                 new InitExtensibleMatchFilter() );
4105 
4106         // --------------------------------------------------------------------------------------------
4107         // Transition from any to final
4108         // --------------------------------------------------------------------------------------------
4109         // SubstringFilter ::= SEQUENCE {
4110         //     ...
4111         //     substrings SEQUENCE OF CHOICE {
4112         //         ...
4113         //         final  [2] LDAPSTRING }
4114         //
4115         // Store substring final type
4116         super.transitions[LdapStatesEnum.ANY_STATE.ordinal()][LdapConstants.SUBSTRINGS_FILTER_FINAL_TAG] =
4117             new GrammarTransition(
4118                 LdapStatesEnum.ANY_STATE,
4119                 LdapStatesEnum.FINAL_STATE,
4120                 LdapConstants.SUBSTRINGS_FILTER_FINAL_TAG,
4121                 new StoreFinal() );
4122 
4123         // --------------------------------------------------------------------------------------------
4124         // Transition from any to any
4125         // --------------------------------------------------------------------------------------------
4126         // SubstringFilter ::= SEQUENCE {
4127         //     ...
4128         //     substrings SEQUENCE OF CHOICE {
4129         //         ...
4130         //         any  [1] LDAPSTRING
4131         //         ...
4132         //
4133         // Store substring any type
4134         super.transitions[LdapStatesEnum.ANY_STATE.ordinal()][LdapConstants.SUBSTRINGS_FILTER_ANY_TAG] =
4135             new GrammarTransition(
4136                 LdapStatesEnum.ANY_STATE,
4137                 LdapStatesEnum.ANY_STATE,
4138                 LdapConstants.SUBSTRINGS_FILTER_ANY_TAG,
4139                 new StoreAny() );
4140 
4141         // --------------------------------------------------------------------------------------------
4142         // Transition from any to Attribute Description List
4143         // --------------------------------------------------------------------------------------------
4144         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4145         //     ...
4146         //     filter      Filter,
4147         //     attributes  AttributeDescriptionList }
4148         //
4149         // AttributeDescriptionList ::= SEQUENCE OF
4150         //     AttributeDescription
4151         //
4152         // Init attribute description list
4153         super.transitions[LdapStatesEnum.ANY_STATE.ordinal()][SEQUENCE.getValue()] =
4154             new GrammarTransition(
4155                 LdapStatesEnum.ANY_STATE,
4156                 LdapStatesEnum.ATTRIBUTE_DESCRIPTION_LIST_STATE,
4157                 SEQUENCE,
4158                 new InitSearchRequestAttributeDescList() );
4159 
4160         // --------------------------------------------------------------------------------------------
4161         // Transition from any to AND filter
4162         // --------------------------------------------------------------------------------------------
4163         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4164         //     ...
4165         //     filter Filter,
4166         //     ...
4167         //
4168         // Filter ::= CHOICE {
4169         //     and             [0] SET OF Filter,
4170         //     ...
4171         //
4172         // Init AND filter
4173         super.transitions[LdapStatesEnum.ANY_STATE.ordinal()][LdapConstants.AND_FILTER_TAG] =
4174             new GrammarTransition(
4175                 LdapStatesEnum.ANY_STATE,
4176                 LdapStatesEnum.AND_STATE,
4177                 LdapConstants.AND_FILTER_TAG,
4178                 new InitAndFilter() );
4179 
4180         // --------------------------------------------------------------------------------------------
4181         // Transition from any to OR filter
4182         // --------------------------------------------------------------------------------------------
4183         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4184         //     ...
4185         //     filter Filter,
4186         //     ...
4187         //
4188         // Filter ::= CHOICE {
4189         //     ...
4190         //     or              [1] SET OF Filter,
4191         //     ...
4192         //
4193         // Init OR filter
4194         super.transitions[LdapStatesEnum.ANY_STATE.ordinal()][LdapConstants.OR_FILTER_TAG] =
4195             new GrammarTransition(
4196                 LdapStatesEnum.ANY_STATE,
4197                 LdapStatesEnum.OR_STATE,
4198                 LdapConstants.OR_FILTER_TAG,
4199                 new InitOrFilter() );
4200 
4201         // --------------------------------------------------------------------------------------------
4202         // Transition from any to NOT filter
4203         // --------------------------------------------------------------------------------------------
4204         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4205         //     ...
4206         //     filter Filter,
4207         //     ...
4208         //
4209         // Filter ::= CHOICE {
4210         //     ...
4211         //     not             [2] SET OF Filter,
4212         //     ...
4213         //
4214         // Init NOT filter
4215         super.transitions[LdapStatesEnum.ANY_STATE.ordinal()][LdapConstants.NOT_FILTER_TAG] =
4216             new GrammarTransition(
4217                 LdapStatesEnum.ANY_STATE,
4218                 LdapStatesEnum.NOT_STATE,
4219                 LdapConstants.NOT_FILTER_TAG,
4220                 new InitNotFilter() );
4221 
4222         // --------------------------------------------------------------------------------------------
4223         // Transition from any to Equality Match filter
4224         // --------------------------------------------------------------------------------------------
4225         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4226         //     ...
4227         //     filter Filter,
4228         //     ...
4229         //
4230         // Filter ::= CHOICE {
4231         //     ...
4232         //     equalityMatch   [3] AttributeValueAssertion,
4233         //     ...
4234         //
4235         // Init NOT filter
4236         super.transitions[LdapStatesEnum.ANY_STATE.ordinal()][LdapConstants.EQUALITY_MATCH_FILTER_TAG] =
4237             new GrammarTransition(
4238                 LdapStatesEnum.ANY_STATE,
4239                 LdapStatesEnum.EQUALITY_MATCH_STATE,
4240                 LdapConstants.EQUALITY_MATCH_FILTER_TAG,
4241                 new InitEqualityMatchFilter() );
4242 
4243         // --------------------------------------------------------------------------------------------
4244         // Transition from any to Substrings filter
4245         // --------------------------------------------------------------------------------------------
4246         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4247         //     ...
4248         //     filter Filter,
4249         //     ...
4250         //
4251         // Filter ::= CHOICE {
4252         //     ...
4253         //     substrings     [4] SubstringFilter,
4254         //     ...
4255         //
4256         // Init Substrings filter
4257         super.transitions[LdapStatesEnum.ANY_STATE.ordinal()][LdapConstants.SUBSTRINGS_FILTER_TAG] =
4258             new GrammarTransition(
4259                 LdapStatesEnum.ANY_STATE,
4260                 LdapStatesEnum.SUBSTRING_FILTER_STATE,
4261                 LdapConstants.SUBSTRINGS_FILTER_TAG,
4262                 new InitSubstringsFilter() );
4263 
4264         // --------------------------------------------------------------------------------------------
4265         // Transition from any to GreaterOrEqual filter
4266         // --------------------------------------------------------------------------------------------
4267         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4268         //     ...
4269         //     filter Filter,
4270         //     ...
4271         //
4272         // Filter ::= CHOICE {
4273         //     ...
4274         //     greaterOrEqual  [5] AttributeValueAssertion,
4275         //     ...
4276         //
4277         // Init Greater Or Equal filter
4278         super.transitions[LdapStatesEnum.ANY_STATE.ordinal()][LdapConstants.GREATER_OR_EQUAL_FILTER_TAG] =
4279             new GrammarTransition(
4280                 LdapStatesEnum.ANY_STATE,
4281                 LdapStatesEnum.GREATER_OR_EQUAL_STATE,
4282                 LdapConstants.GREATER_OR_EQUAL_FILTER_TAG,
4283                 new InitGreaterOrEqualFilter() );
4284 
4285         // --------------------------------------------------------------------------------------------
4286         // Transition from any to LessOrEqual filter
4287         // --------------------------------------------------------------------------------------------
4288         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4289         //     ...
4290         //     filter Filter,
4291         //     ...
4292         //
4293         // Filter ::= CHOICE {
4294         //     ...
4295         //     LessOrEqual    [6] AttributeValueAssertion,
4296         //     ...
4297         //
4298         // Init Less Or Equal filter
4299         super.transitions[LdapStatesEnum.ANY_STATE.ordinal()][LdapConstants.LESS_OR_EQUAL_FILTER_TAG] =
4300             new GrammarTransition(
4301                 LdapStatesEnum.ANY_STATE,
4302                 LdapStatesEnum.LESS_OR_EQUAL_STATE,
4303                 LdapConstants.LESS_OR_EQUAL_FILTER_TAG,
4304                 new InitLessOrEqualFilter() );
4305 
4306         // --------------------------------------------------------------------------------------------
4307         // Transition from any to Present filter
4308         // --------------------------------------------------------------------------------------------
4309         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4310         //     ...
4311         //     filter Filter,
4312         //     ...
4313         //
4314         // Filter ::= CHOICE {
4315         //     ...
4316         //     present        [7] AttributeDescription,
4317         //     ...
4318         //
4319         // Init present filter
4320         super.transitions[LdapStatesEnum.ANY_STATE.ordinal()][LdapConstants.PRESENT_FILTER_TAG] =
4321             new GrammarTransition(
4322                 LdapStatesEnum.ANY_STATE,
4323                 LdapStatesEnum.PRESENT_STATE,
4324                 LdapConstants.PRESENT_FILTER_TAG,
4325                 new InitPresentFilter() );
4326 
4327         // --------------------------------------------------------------------------------------------
4328         // Transition from any to Approx Match filter
4329         // --------------------------------------------------------------------------------------------
4330         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4331         //     ...
4332         //     filter Filter,
4333         //     ...
4334         //
4335         // Filter ::= CHOICE {
4336         //     ...
4337         //     approxMatch     [8] AttributeValueAssertion,
4338         //     ...
4339         //
4340         // Init Approx Match filter
4341         super.transitions[LdapStatesEnum.ANY_STATE.ordinal()][LdapConstants.APPROX_MATCH_FILTER_TAG] =
4342             new GrammarTransition(
4343                 LdapStatesEnum.ANY_STATE,
4344                 LdapStatesEnum.APPROX_MATCH_STATE,
4345                 LdapConstants.APPROX_MATCH_FILTER_TAG,
4346                 new InitApproxMatchFilter() );
4347 
4348         // --------------------------------------------------------------------------------------------
4349         // Transition from any to Extensible Match filter
4350         // --------------------------------------------------------------------------------------------
4351         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4352         //     ...
4353         //     filter Filter,
4354         //     ...
4355         //
4356         // Filter ::= CHOICE {
4357         //     ...
4358         //     extensibleMatch  [9] MatchingRuleAssertion,
4359         //     ...
4360         //
4361         // Init Assertion Value Filter filter
4362         super.transitions[LdapStatesEnum.ANY_STATE.ordinal()][LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG] =
4363             new GrammarTransition(
4364                 LdapStatesEnum.ANY_STATE,
4365                 LdapStatesEnum.EXTENSIBLE_MATCH_STATE,
4366                 LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG,
4367                 new InitExtensibleMatchFilter() );
4368 
4369         // --------------------------------------------------------------------------------------------
4370         // Transition from final to Attribute Description List
4371         // --------------------------------------------------------------------------------------------
4372         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4373         //     ...
4374         //     filter      Filter,
4375         //     attributes  AttributeDescriptionList }
4376         //
4377         // AttributeDescriptionList ::= SEQUENCE OF
4378         //     AttributeDescription
4379         //
4380         // Init attribute description list
4381         super.transitions[LdapStatesEnum.FINAL_STATE.ordinal()][SEQUENCE.getValue()] =
4382             new GrammarTransition(
4383                 LdapStatesEnum.FINAL_STATE,
4384                 LdapStatesEnum.ATTRIBUTE_DESCRIPTION_LIST_STATE,
4385                 SEQUENCE,
4386                 new InitSearchRequestAttributeDescList() );
4387 
4388         // --------------------------------------------------------------------------------------------
4389         // Transition from final to AND filter
4390         // --------------------------------------------------------------------------------------------
4391         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4392         //     ...
4393         //     filter Filter,
4394         //     ...
4395         //
4396         // Filter ::= CHOICE {
4397         //     and             [0] SET OF Filter,
4398         //     ...
4399         //
4400         // Init AND filter
4401         super.transitions[LdapStatesEnum.FINAL_STATE.ordinal()][LdapConstants.AND_FILTER_TAG] =
4402             new GrammarTransition(
4403                 LdapStatesEnum.FINAL_STATE,
4404                 LdapStatesEnum.AND_STATE,
4405                 LdapConstants.AND_FILTER_TAG,
4406                 new InitAndFilter() );
4407 
4408         // --------------------------------------------------------------------------------------------
4409         // Transition from final to OR filter
4410         // --------------------------------------------------------------------------------------------
4411         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4412         //     ...
4413         //     filter Filter,
4414         //     ...
4415         //
4416         // Filter ::= CHOICE {
4417         //     ...
4418         //     or              [1] SET OF Filter,
4419         //     ...
4420         //
4421         // Init OR filter
4422         super.transitions[LdapStatesEnum.FINAL_STATE.ordinal()][LdapConstants.OR_FILTER_TAG] =
4423             new GrammarTransition(
4424                 LdapStatesEnum.FINAL_STATE,
4425                 LdapStatesEnum.OR_STATE,
4426                 LdapConstants.OR_FILTER_TAG,
4427                 new InitOrFilter() );
4428 
4429         // --------------------------------------------------------------------------------------------
4430         // Transition from final to NOT filter
4431         // --------------------------------------------------------------------------------------------
4432         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4433         //     ...
4434         //     filter Filter,
4435         //     ...
4436         //
4437         // Filter ::= CHOICE {
4438         //     ...
4439         //     not             [2] SET OF Filter,
4440         //     ...
4441         //
4442         // Init NOT filter
4443         super.transitions[LdapStatesEnum.FINAL_STATE.ordinal()][LdapConstants.NOT_FILTER_TAG] =
4444             new GrammarTransition(
4445                 LdapStatesEnum.FINAL_STATE,
4446                 LdapStatesEnum.NOT_STATE,
4447                 LdapConstants.NOT_FILTER_TAG,
4448                 new InitNotFilter() );
4449 
4450         // --------------------------------------------------------------------------------------------
4451         // Transition from final to Equality Match filter
4452         // --------------------------------------------------------------------------------------------
4453         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4454         //     ...
4455         //     filter Filter,
4456         //     ...
4457         //
4458         // Filter ::= CHOICE {
4459         //     ...
4460         //     equalityMatch   [3] AttributeValueAssertion,
4461         //     ...
4462         //
4463         // Init NOT filter
4464         super.transitions[LdapStatesEnum.FINAL_STATE.ordinal()][LdapConstants.EQUALITY_MATCH_FILTER_TAG] =
4465             new GrammarTransition(
4466                 LdapStatesEnum.FINAL_STATE,
4467                 LdapStatesEnum.EQUALITY_MATCH_STATE,
4468                 LdapConstants.EQUALITY_MATCH_FILTER_TAG,
4469                 new InitEqualityMatchFilter() );
4470 
4471         // --------------------------------------------------------------------------------------------
4472         // Transition from final to Substrings filter
4473         // --------------------------------------------------------------------------------------------
4474         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4475         //     ...
4476         //     filter Filter,
4477         //     ...
4478         //
4479         // Filter ::= CHOICE {
4480         //     ...
4481         //     substrings     [4] SubstringFilter,
4482         //     ...
4483         //
4484         // Init Substrings filter
4485         super.transitions[LdapStatesEnum.FINAL_STATE.ordinal()][LdapConstants.SUBSTRINGS_FILTER_TAG] =
4486             new GrammarTransition(
4487                 LdapStatesEnum.FINAL_STATE,
4488                 LdapStatesEnum.SUBSTRING_FILTER_STATE,
4489                 LdapConstants.SUBSTRINGS_FILTER_TAG,
4490                 new InitSubstringsFilter() );
4491 
4492         // --------------------------------------------------------------------------------------------
4493         // Transition from final to GreaterOrEqual filter
4494         // --------------------------------------------------------------------------------------------
4495         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4496         //     ...
4497         //     filter Filter,
4498         //     ...
4499         //
4500         // Filter ::= CHOICE {
4501         //     ...
4502         //     greaterOrEqual  [5] AttributeValueAssertion,
4503         //     ...
4504         //
4505         // Init Greater Or Equal filter
4506         super.transitions[LdapStatesEnum.FINAL_STATE.ordinal()][LdapConstants.GREATER_OR_EQUAL_FILTER_TAG] =
4507             new GrammarTransition(
4508                 LdapStatesEnum.FINAL_STATE,
4509                 LdapStatesEnum.GREATER_OR_EQUAL_STATE,
4510                 LdapConstants.GREATER_OR_EQUAL_FILTER_TAG,
4511                 new InitGreaterOrEqualFilter() );
4512 
4513         // --------------------------------------------------------------------------------------------
4514         // Transition from final to LessOrEqual filter
4515         // --------------------------------------------------------------------------------------------
4516         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4517         //     ...
4518         //     filter Filter,
4519         //     ...
4520         //
4521         // Filter ::= CHOICE {
4522         //     ...
4523         //     LessOrEqual    [6] AttributeValueAssertion,
4524         //     ...
4525         //
4526         // Init Less Or Equal filter
4527         super.transitions[LdapStatesEnum.FINAL_STATE.ordinal()][LdapConstants.LESS_OR_EQUAL_FILTER_TAG] =
4528             new GrammarTransition(
4529                 LdapStatesEnum.FINAL_STATE,
4530                 LdapStatesEnum.LESS_OR_EQUAL_STATE,
4531                 LdapConstants.LESS_OR_EQUAL_FILTER_TAG,
4532                 new InitLessOrEqualFilter() );
4533 
4534         // --------------------------------------------------------------------------------------------
4535         // Transition from final to Present filter
4536         // --------------------------------------------------------------------------------------------
4537         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4538         //     ...
4539         //     filter Filter,
4540         //     ...
4541         //
4542         // Filter ::= CHOICE {
4543         //     ...
4544         //     present        [7] AttributeDescription,
4545         //     ...
4546         //
4547         // Init present filter
4548         super.transitions[LdapStatesEnum.FINAL_STATE.ordinal()][LdapConstants.PRESENT_FILTER_TAG] =
4549             new GrammarTransition(
4550                 LdapStatesEnum.FINAL_STATE,
4551                 LdapStatesEnum.PRESENT_STATE,
4552                 LdapConstants.PRESENT_FILTER_TAG,
4553                 new InitPresentFilter() );
4554 
4555         // --------------------------------------------------------------------------------------------
4556         // Transition from final to Approx Match filter
4557         // --------------------------------------------------------------------------------------------
4558         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4559         //     ...
4560         //     filter Filter,
4561         //     ...
4562         //
4563         // Filter ::= CHOICE {
4564         //     ...
4565         //     approxMatch     [8] AttributeValueAssertion,
4566         //     ...
4567         //
4568         // Init Approx Match filter
4569         super.transitions[LdapStatesEnum.FINAL_STATE.ordinal()][LdapConstants.APPROX_MATCH_FILTER_TAG] =
4570             new GrammarTransition(
4571                 LdapStatesEnum.FINAL_STATE,
4572                 LdapStatesEnum.APPROX_MATCH_STATE,
4573                 LdapConstants.APPROX_MATCH_FILTER_TAG,
4574                 new InitApproxMatchFilter() );
4575 
4576         // --------------------------------------------------------------------------------------------
4577         // Transition from final to Extensible Match filter
4578         // --------------------------------------------------------------------------------------------
4579         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4580         //     ...
4581         //     filter Filter,
4582         //     ...
4583         //
4584         // Filter ::= CHOICE {
4585         //     ...
4586         //     extensibleMatch  [9] MatchingRuleAssertion,
4587         //     ...
4588         //
4589         // Init Assertion Value Filter filter
4590         super.transitions[LdapStatesEnum.FINAL_STATE.ordinal()][LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG] =
4591             new GrammarTransition(
4592                 LdapStatesEnum.FINAL_STATE,
4593                 LdapStatesEnum.EXTENSIBLE_MATCH_STATE,
4594                 LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG,
4595                 new InitExtensibleMatchFilter() );
4596 
4597         // --------------------------------------------------------------------------------------------
4598         // Transition from Present Filter to AND filter
4599         // --------------------------------------------------------------------------------------------
4600         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4601         //     ...
4602         //     filter Filter,
4603         //     ...
4604         //
4605         // Filter ::= CHOICE {
4606         //     and             [0] SET OF Filter,
4607         //     ...
4608         //
4609         // Init AND filter
4610         super.transitions[LdapStatesEnum.PRESENT_STATE.ordinal()][LdapConstants.AND_FILTER_TAG] =
4611             new GrammarTransition(
4612                 LdapStatesEnum.PRESENT_STATE,
4613                 LdapStatesEnum.AND_STATE,
4614                 LdapConstants.AND_FILTER_TAG,
4615                 new InitAndFilter() );
4616 
4617         // --------------------------------------------------------------------------------------------
4618         // Transition from Present Filter to OR filter
4619         // --------------------------------------------------------------------------------------------
4620         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4621         //     ...
4622         //     filter Filter,
4623         //     ...
4624         //
4625         // Filter ::= CHOICE {
4626         //     ...
4627         //     or              [1] SET OF Filter,
4628         //     ...
4629         //
4630         // Init OR filter
4631         super.transitions[LdapStatesEnum.PRESENT_STATE.ordinal()][LdapConstants.OR_FILTER_TAG] =
4632             new GrammarTransition(
4633                 LdapStatesEnum.PRESENT_STATE,
4634                 LdapStatesEnum.OR_STATE,
4635                 LdapConstants.OR_FILTER_TAG,
4636                 new InitOrFilter() );
4637 
4638         // --------------------------------------------------------------------------------------------
4639         // Transition from Present Filter to NOT filter
4640         // --------------------------------------------------------------------------------------------
4641         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4642         //     ...
4643         //     filter Filter,
4644         //     ...
4645         //
4646         // Filter ::= CHOICE {
4647         //     ...
4648         //     not             [2] SET OF Filter,
4649         //     ...
4650         //
4651         // Init NOT filter
4652         super.transitions[LdapStatesEnum.PRESENT_STATE.ordinal()][LdapConstants.NOT_FILTER_TAG] =
4653             new GrammarTransition(
4654                 LdapStatesEnum.PRESENT_STATE,
4655                 LdapStatesEnum.NOT_STATE,
4656                 LdapConstants.NOT_FILTER_TAG,
4657                 new InitNotFilter() );
4658 
4659         // --------------------------------------------------------------------------------------------
4660         // Transition from Present Filter to Equality Match filter
4661         // --------------------------------------------------------------------------------------------
4662         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4663         //     ...
4664         //     filter Filter,
4665         //     ...
4666         //
4667         // Filter ::= CHOICE {
4668         //     ...
4669         //     equalityMatch   [3] AttributeValueAssertion,
4670         //     ...
4671         //
4672         // Init NOT filter
4673         super.transitions[LdapStatesEnum.PRESENT_STATE.ordinal()][LdapConstants.EQUALITY_MATCH_FILTER_TAG] =
4674             new GrammarTransition(
4675                 LdapStatesEnum.PRESENT_STATE,
4676                 LdapStatesEnum.EQUALITY_MATCH_STATE,
4677                 LdapConstants.EQUALITY_MATCH_FILTER_TAG,
4678                 new InitEqualityMatchFilter() );
4679 
4680         // --------------------------------------------------------------------------------------------
4681         // Transition from Present Filter to Substrings filter
4682         // --------------------------------------------------------------------------------------------
4683         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4684         //     ...
4685         //     filter Filter,
4686         //     ...
4687         //
4688         // Filter ::= CHOICE {
4689         //     ...
4690         //     substrings     [4] SubstringFilter,
4691         //     ...
4692         //
4693         // Init Substrings filter
4694         super.transitions[LdapStatesEnum.PRESENT_STATE.ordinal()][LdapConstants.SUBSTRINGS_FILTER_TAG] =
4695             new GrammarTransition(
4696                 LdapStatesEnum.PRESENT_STATE,
4697                 LdapStatesEnum.SUBSTRING_FILTER_STATE,
4698                 LdapConstants.SUBSTRINGS_FILTER_TAG,
4699                 new InitSubstringsFilter() );
4700 
4701         // --------------------------------------------------------------------------------------------
4702         // Transition from Present Filter to GreaterOrEqual filter
4703         // --------------------------------------------------------------------------------------------
4704         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4705         //     ...
4706         //     filter Filter,
4707         //     ...
4708         //
4709         // Filter ::= CHOICE {
4710         //     ...
4711         //     greaterOrEqual  [5] AttributeValueAssertion,
4712         //     ...
4713         //
4714         // Init Greater Or Equal filter
4715         super.transitions[LdapStatesEnum.PRESENT_STATE.ordinal()][LdapConstants.GREATER_OR_EQUAL_FILTER_TAG] =
4716             new GrammarTransition(
4717                 LdapStatesEnum.PRESENT_STATE,
4718                 LdapStatesEnum.GREATER_OR_EQUAL_STATE,
4719                 LdapConstants.GREATER_OR_EQUAL_FILTER_TAG,
4720                 new InitGreaterOrEqualFilter() );
4721 
4722         // --------------------------------------------------------------------------------------------
4723         // Transition from Present Filter to LessOrEqual filter
4724         // --------------------------------------------------------------------------------------------
4725         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4726         //     ...
4727         //     filter Filter,
4728         //     ...
4729         //
4730         // Filter ::= CHOICE {
4731         //     ...
4732         //     LessOrEqual    [6] AttributeValueAssertion,
4733         //     ...
4734         //
4735         // Init Less Or Equal filter
4736         super.transitions[LdapStatesEnum.PRESENT_STATE.ordinal()][LdapConstants.LESS_OR_EQUAL_FILTER_TAG] =
4737             new GrammarTransition(
4738                 LdapStatesEnum.PRESENT_STATE,
4739                 LdapStatesEnum.LESS_OR_EQUAL_STATE,
4740                 LdapConstants.LESS_OR_EQUAL_FILTER_TAG,
4741                 new InitLessOrEqualFilter() );
4742 
4743         // --------------------------------------------------------------------------------------------
4744         // Transition from Present Filter to Present filter
4745         // --------------------------------------------------------------------------------------------
4746         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4747         //     ...
4748         //     filter Filter,
4749         //     ...
4750         //
4751         // Filter ::= CHOICE {
4752         //     ...
4753         //     present        [7] AttributeDescription,
4754         //     ...
4755         //
4756         // Init present filter
4757         super.transitions[LdapStatesEnum.PRESENT_STATE.ordinal()][LdapConstants.PRESENT_FILTER_TAG] =
4758             new GrammarTransition(
4759                 LdapStatesEnum.PRESENT_STATE,
4760                 LdapStatesEnum.PRESENT_STATE,
4761                 LdapConstants.PRESENT_FILTER_TAG,
4762                 new InitPresentFilter() );
4763 
4764         // --------------------------------------------------------------------------------------------
4765         // Transition from Present Filter to Approx Match filter
4766         // --------------------------------------------------------------------------------------------
4767         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4768         //     ...
4769         //     filter Filter,
4770         //     ...
4771         //
4772         // Filter ::= CHOICE {
4773         //     ...
4774         //     approxMatch     [8] AttributeValueAssertion,
4775         //     ...
4776         //
4777         // Init Approx Match filter
4778         super.transitions[LdapStatesEnum.PRESENT_STATE.ordinal()][LdapConstants.APPROX_MATCH_FILTER_TAG] =
4779             new GrammarTransition(
4780                 LdapStatesEnum.PRESENT_STATE,
4781                 LdapStatesEnum.APPROX_MATCH_STATE,
4782                 LdapConstants.APPROX_MATCH_FILTER_TAG,
4783                 new InitApproxMatchFilter() );
4784 
4785         // --------------------------------------------------------------------------------------------
4786         // Transition from Present Filter to Extensible Match filter
4787         // --------------------------------------------------------------------------------------------
4788         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4789         //     ...
4790         //     filter Filter,
4791         //     ...
4792         //
4793         // Filter ::= CHOICE {
4794         //     ...
4795         //     extensibleMatch  [9] MatchingRuleAssertion,
4796         //     ...
4797         //
4798         // Init Assertion Value Filter filter
4799         super.transitions[LdapStatesEnum.PRESENT_STATE.ordinal()][LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG] =
4800             new GrammarTransition(
4801                 LdapStatesEnum.PRESENT_STATE,
4802                 LdapStatesEnum.EXTENSIBLE_MATCH_STATE,
4803                 LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG,
4804                 new InitExtensibleMatchFilter() );
4805 
4806         // --------------------------------------------------------------------------------------------
4807         // Transition from Present Filter to Attribute Description List
4808         // --------------------------------------------------------------------------------------------
4809         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
4810         //     ...
4811         //     filter      Filter,
4812         //     attributes  AttributeDescriptionList }
4813         //
4814         // AttributeDescriptionList ::= SEQUENCE OF
4815         //     AttributeDescription
4816         //
4817         // Init attribute description list
4818         super.transitions[LdapStatesEnum.PRESENT_STATE.ordinal()][SEQUENCE.getValue()] =
4819             new GrammarTransition(
4820                 LdapStatesEnum.PRESENT_STATE,
4821                 LdapStatesEnum.ATTRIBUTE_DESCRIPTION_LIST_STATE,
4822                 SEQUENCE,
4823                 new InitSearchRequestAttributeDescList() );
4824 
4825         // --------------------------------------------------------------------------------------------
4826         // Transition from Approx Match to Attribute Desc Filter
4827         // --------------------------------------------------------------------------------------------
4828         // Filter ::= CHOICE {
4829         //     ...
4830         //     approxMatch  [8] AttributeValueAssertion,
4831         //     ...
4832         //
4833         // AttributeValueAssertion ::= SEQUENCE {
4834         //     attributeDesc   AttributeDescription,
4835         //     ...
4836         //
4837         // Init Attribute Desc filter
4838         super.transitions[LdapStatesEnum.APPROX_MATCH_STATE.ordinal()][OCTET_STRING.getValue()] =
4839             new GrammarTransition(
4840                 LdapStatesEnum.APPROX_MATCH_STATE,
4841                 LdapStatesEnum.ATTRIBUTE_DESC_FILTER_STATE,
4842                 OCTET_STRING,
4843                 new InitAttributeDescFilter() );
4844 
4845         // --------------------------------------------------------------------------------------------
4846         // Transition from Extensible Match to MatchingRule
4847         // --------------------------------------------------------------------------------------------
4848         // Filter ::= CHOICE {
4849         //     ...
4850         //     extensibleMatch  [9] MatchingRuleAssertion }
4851         //
4852         // MatchingRuleAssertion ::= SEQUENCE {
4853         //     matchingRule [1] MatchingRuleId OPTIONAL,
4854         //     ...
4855         //
4856         // Store the matching rule ID
4857         super.transitions[LdapStatesEnum.EXTENSIBLE_MATCH_STATE.ordinal()][LdapConstants.MATCHING_RULE_ID_TAG] = new GrammarTransition(
4858             LdapStatesEnum.EXTENSIBLE_MATCH_STATE, LdapStatesEnum.MATCHING_RULE_STATE,
4859             LdapConstants.MATCHING_RULE_ID_TAG, new GrammarAction<LdapMessageContainer<SearchRequestDecorator>>(
4860                 "Store matching rule Value" )
4861             {
4862                 public void action( LdapMessageContainer<SearchRequestDecorator> container ) throws DecoderException
4863                 {
4864                     SearchRequestDecorator searchRequest = container.getMessage();
4865 
4866                     TLV tlv = container.getCurrentTLV();
4867 
4868                     // Store the value.
4869                     ExtensibleMatchFilter extensibleMatchFilter = ( ExtensibleMatchFilter )
4870                         searchRequest.getTerminalFilter();
4871 
4872                     if ( tlv.getLength() == 0 )
4873                     {
4874                         String msg = I18n.err( I18n.ERR_04109 );
4875                         LOG.error( msg );
4876 
4877                         // It will generate a PROTOCOL_ERROR
4878                         throw new DecoderException( I18n.err( I18n.ERR_04109 ) );
4879                     }
4880                     else
4881                     {
4882                         extensibleMatchFilter.setMatchingRule( Strings.utf8ToString( tlv.getValue().getData() ) );
4883                     }
4884                 }
4885             } );
4886 
4887         // --------------------------------------------------------------------------------------------
4888         // Transition from Extensible Match to type matching rule
4889         // --------------------------------------------------------------------------------------------
4890         // Filter ::= CHOICE {
4891         //     ...
4892         //     extensibleMatch  [9] MatchingRuleAssertion }
4893         //
4894         // MatchingRuleAssertion ::= SEQUENCE {
4895         //     ...
4896         //     type [2] AttributeDescription OPTIONAL,
4897         //     ...
4898         //
4899         // Store the matching rule ID
4900         super.transitions[LdapStatesEnum.EXTENSIBLE_MATCH_STATE.ordinal()][LdapConstants.MATCHING_RULE_TYPE_TAG] =
4901             new GrammarTransition(
4902                 LdapStatesEnum.EXTENSIBLE_MATCH_STATE,
4903                 LdapStatesEnum.TYPE_MATCHING_RULE_STATE,
4904                 LdapConstants.MATCHING_RULE_TYPE_TAG,
4905                 new StoreTypeMatchingRule() );
4906 
4907         // --------------------------------------------------------------------------------------------
4908         // Transition from Extensible Match to match value
4909         // --------------------------------------------------------------------------------------------
4910         // Filter ::= CHOICE {
4911         //     ...
4912         //     extensibleMatch  [9] MatchingRuleAssertion }
4913         //
4914         // MatchingRuleAssertion ::= SEQUENCE {
4915         //     ...
4916         //     matchValue [3] AssertionValue,
4917         //     ...
4918         //
4919         // Store the matching rule ID
4920         super.transitions[LdapStatesEnum.EXTENSIBLE_MATCH_STATE.ordinal()][LdapConstants.MATCH_VALUE_TAG] =
4921             new GrammarTransition(
4922                 LdapStatesEnum.EXTENSIBLE_MATCH_STATE,
4923                 LdapStatesEnum.MATCH_VALUE_STATE,
4924                 LdapConstants.MATCH_VALUE_TAG,
4925                 new StoreMatchValue() );
4926 
4927         // --------------------------------------------------------------------------------------------
4928         // Transition from matching rule to type matching rule
4929         // --------------------------------------------------------------------------------------------
4930         // Filter ::= CHOICE {
4931         //     ...
4932         //     extensibleMatch  [9] MatchingRuleAssertion }
4933         //
4934         // MatchingRuleAssertion ::= SEQUENCE {
4935         //     ...
4936         //     type [2] AttributeDescription OPTIONAL,
4937         //     ...
4938         //
4939         // Store the matching rule ID
4940         super.transitions[LdapStatesEnum.MATCHING_RULE_STATE.ordinal()][LdapConstants.MATCHING_RULE_TYPE_TAG] =
4941             new GrammarTransition(
4942                 LdapStatesEnum.MATCHING_RULE_STATE,
4943                 LdapStatesEnum.TYPE_MATCHING_RULE_STATE,
4944                 LdapConstants.MATCHING_RULE_TYPE_TAG,
4945                 new StoreTypeMatchingRule() );
4946 
4947         // --------------------------------------------------------------------------------------------
4948         // Transition from matching rule to match value
4949         // --------------------------------------------------------------------------------------------
4950         // Filter ::= CHOICE {
4951         //     ...
4952         //     extensibleMatch  [9] MatchingRuleAssertion }
4953         //
4954         // MatchingRuleAssertion ::= SEQUENCE {
4955         //     ...
4956         //     matchValue [3] AssertionValue,
4957         //     ...
4958         //
4959         // Store the matching rule ID
4960         super.transitions[LdapStatesEnum.MATCHING_RULE_STATE.ordinal()][LdapConstants.MATCH_VALUE_TAG] =
4961             new GrammarTransition(
4962                 LdapStatesEnum.MATCHING_RULE_STATE,
4963                 LdapStatesEnum.MATCH_VALUE_STATE,
4964                 LdapConstants.MATCH_VALUE_TAG,
4965                 new StoreMatchValue() );
4966 
4967         // --------------------------------------------------------------------------------------------
4968         // Transition from matching type to match value
4969         // --------------------------------------------------------------------------------------------
4970         // Filter ::= CHOICE {
4971         //     ...
4972         //     extensibleMatch  [9] MatchingRuleAssertion }
4973         //
4974         // MatchingRuleAssertion ::= SEQUENCE {
4975         //     ...
4976         //     matchValue [3] AssertionValue,
4977         //     ...
4978         //
4979         // Store the matching rule ID
4980         super.transitions[LdapStatesEnum.TYPE_MATCHING_RULE_STATE.ordinal()][LdapConstants.MATCH_VALUE_TAG] =
4981             new GrammarTransition(
4982                 LdapStatesEnum.TYPE_MATCHING_RULE_STATE,
4983                 LdapStatesEnum.MATCH_VALUE_STATE,
4984                 LdapConstants.MATCH_VALUE_TAG,
4985                 new StoreMatchValue() );
4986 
4987         // --------------------------------------------------------------------------------------------
4988         // Transition from match value to dnAttributes
4989         // --------------------------------------------------------------------------------------------
4990         // Filter ::= CHOICE {
4991         //     ...
4992         //     extensibleMatch  [9] MatchingRuleAssertion }
4993         //
4994         // MatchingRuleAssertion ::= SEQUENCE {
4995         //     ...
4996         //     dnAttributes [4] BOOLEAN DEFAULT FALSE }
4997         //
4998         // Store the dnAttributes flag
4999         super.transitions[LdapStatesEnum.MATCH_VALUE_STATE.ordinal()][LdapConstants.DN_ATTRIBUTES_FILTER_TAG] =
5000             new GrammarTransition(
5001                 LdapStatesEnum.MATCH_VALUE_STATE,
5002                 LdapStatesEnum.DN_ATTRIBUTES_STATE,
5003                 LdapConstants.DN_ATTRIBUTES_FILTER_TAG,
5004                 new StoreMatchingRuleDnAttributes() );
5005 
5006         // --------------------------------------------------------------------------------------------
5007         // Transition from match value to AND filter
5008         // --------------------------------------------------------------------------------------------
5009         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5010         //     ...
5011         //     filter Filter,
5012         //     ...
5013         //
5014         // Filter ::= CHOICE {
5015         //     and             [0] SET OF Filter,
5016         //     ...
5017         //
5018         // Init AND filter
5019         super.transitions[LdapStatesEnum.MATCH_VALUE_STATE.ordinal()][LdapConstants.AND_FILTER_TAG] =
5020             new GrammarTransition(
5021                 LdapStatesEnum.MATCH_VALUE_STATE,
5022                 LdapStatesEnum.AND_STATE,
5023                 LdapConstants.AND_FILTER_TAG,
5024                 new InitAndFilter() );
5025 
5026         // --------------------------------------------------------------------------------------------
5027         // Transition from match value to OR filter
5028         // --------------------------------------------------------------------------------------------
5029         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5030         //     ...
5031         //     filter Filter,
5032         //     ...
5033         //
5034         // Filter ::= CHOICE {
5035         //     ...
5036         //     or              [1] SET OF Filter,
5037         //     ...
5038         //
5039         // Init OR filter
5040         super.transitions[LdapStatesEnum.MATCH_VALUE_STATE.ordinal()][LdapConstants.OR_FILTER_TAG] =
5041             new GrammarTransition(
5042                 LdapStatesEnum.MATCH_VALUE_STATE,
5043                 LdapStatesEnum.OR_STATE,
5044                 LdapConstants.OR_FILTER_TAG,
5045                 new InitOrFilter() );
5046 
5047         // --------------------------------------------------------------------------------------------
5048         // Transition from match value to NOT filter
5049         // --------------------------------------------------------------------------------------------
5050         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5051         //     ...
5052         //     filter Filter,
5053         //     ...
5054         //
5055         // Filter ::= CHOICE {
5056         //     ...
5057         //     not             [2] SET OF Filter,
5058         //     ...
5059         //
5060         // Init NOT filter
5061         super.transitions[LdapStatesEnum.MATCH_VALUE_STATE.ordinal()][LdapConstants.NOT_FILTER_TAG] =
5062             new GrammarTransition(
5063                 LdapStatesEnum.MATCH_VALUE_STATE,
5064                 LdapStatesEnum.NOT_STATE,
5065                 LdapConstants.NOT_FILTER_TAG,
5066                 new InitNotFilter() );
5067 
5068         // --------------------------------------------------------------------------------------------
5069         // Transition from match value to Equality Match filter
5070         // --------------------------------------------------------------------------------------------
5071         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5072         //     ...
5073         //     filter Filter,
5074         //     ...
5075         //
5076         // Filter ::= CHOICE {
5077         //     ...
5078         //     equalityMatch   [3] AttributeValueAssertion,
5079         //     ...
5080         //
5081         // Init NOT filter
5082         super.transitions[LdapStatesEnum.MATCH_VALUE_STATE.ordinal()][LdapConstants.EQUALITY_MATCH_FILTER_TAG] =
5083             new GrammarTransition(
5084                 LdapStatesEnum.MATCH_VALUE_STATE,
5085                 LdapStatesEnum.EQUALITY_MATCH_STATE,
5086                 LdapConstants.EQUALITY_MATCH_FILTER_TAG,
5087                 new InitEqualityMatchFilter() );
5088 
5089         // --------------------------------------------------------------------------------------------
5090         // Transition from match value to Substrings filter
5091         // --------------------------------------------------------------------------------------------
5092         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5093         //     ...
5094         //     filter Filter,
5095         //     ...
5096         //
5097         // Filter ::= CHOICE {
5098         //     ...
5099         //     substrings     [4] SubstringFilter,
5100         //     ...
5101         //
5102         // Init Substrings filter
5103         super.transitions[LdapStatesEnum.MATCH_VALUE_STATE.ordinal()][LdapConstants.SUBSTRINGS_FILTER_TAG] =
5104             new GrammarTransition(
5105                 LdapStatesEnum.MATCH_VALUE_STATE,
5106                 LdapStatesEnum.SUBSTRING_FILTER_STATE,
5107                 LdapConstants.SUBSTRINGS_FILTER_TAG,
5108                 new InitSubstringsFilter() );
5109 
5110         // --------------------------------------------------------------------------------------------
5111         // Transition from match value to GreaterOrEqual filter
5112         // --------------------------------------------------------------------------------------------
5113         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5114         //     ...
5115         //     filter Filter,
5116         //     ...
5117         //
5118         // Filter ::= CHOICE {
5119         //     ...
5120         //     greaterOrEqual  [5] AttributeValueAssertion,
5121         //     ...
5122         //
5123         // Init Greater Or Equal filter
5124         super.transitions[LdapStatesEnum.MATCH_VALUE_STATE.ordinal()][LdapConstants.GREATER_OR_EQUAL_FILTER_TAG] =
5125             new GrammarTransition(
5126                 LdapStatesEnum.MATCH_VALUE_STATE,
5127                 LdapStatesEnum.GREATER_OR_EQUAL_STATE,
5128                 LdapConstants.GREATER_OR_EQUAL_FILTER_TAG,
5129                 new InitGreaterOrEqualFilter() );
5130 
5131         // --------------------------------------------------------------------------------------------
5132         // Transition from match value to LessOrEqual filter
5133         // --------------------------------------------------------------------------------------------
5134         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5135         //     ...
5136         //     filter Filter,
5137         //     ...
5138         //
5139         // Filter ::= CHOICE {
5140         //     ...
5141         //     LessOrEqual    [6] AttributeValueAssertion,
5142         //     ...
5143         //
5144         // Init Less Or Equal filter
5145         super.transitions[LdapStatesEnum.MATCH_VALUE_STATE.ordinal()][LdapConstants.LESS_OR_EQUAL_FILTER_TAG] =
5146             new GrammarTransition(
5147                 LdapStatesEnum.MATCH_VALUE_STATE,
5148                 LdapStatesEnum.LESS_OR_EQUAL_STATE,
5149                 LdapConstants.LESS_OR_EQUAL_FILTER_TAG,
5150                 new InitLessOrEqualFilter() );
5151 
5152         // --------------------------------------------------------------------------------------------
5153         // Transition from match value to Present filter
5154         // --------------------------------------------------------------------------------------------
5155         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5156         //     ...
5157         //     filter Filter,
5158         //     ...
5159         //
5160         // Filter ::= CHOICE {
5161         //     ...
5162         //     present        [7] AttributeDescription,
5163         //     ...
5164         //
5165         // Init present filter
5166         super.transitions[LdapStatesEnum.MATCH_VALUE_STATE.ordinal()][LdapConstants.PRESENT_FILTER_TAG] =
5167             new GrammarTransition(
5168                 LdapStatesEnum.MATCH_VALUE_STATE,
5169                 LdapStatesEnum.PRESENT_STATE,
5170                 LdapConstants.PRESENT_FILTER_TAG,
5171                 new InitPresentFilter() );
5172 
5173         // --------------------------------------------------------------------------------------------
5174         // Transition from match value to Approx Match filter
5175         // --------------------------------------------------------------------------------------------
5176         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5177         //     ...
5178         //     filter Filter,
5179         //     ...
5180         //
5181         // Filter ::= CHOICE {
5182         //     ...
5183         //     approxMatch     [8] AttributeValueAssertion,
5184         //     ...
5185         //
5186         // Init Approx Match filter
5187         super.transitions[LdapStatesEnum.MATCH_VALUE_STATE.ordinal()][LdapConstants.APPROX_MATCH_FILTER_TAG] =
5188             new GrammarTransition(
5189                 LdapStatesEnum.MATCH_VALUE_STATE,
5190                 LdapStatesEnum.APPROX_MATCH_STATE,
5191                 LdapConstants.APPROX_MATCH_FILTER_TAG,
5192                 new InitApproxMatchFilter() );
5193 
5194         // --------------------------------------------------------------------------------------------
5195         // Transition from match value to Extensible Match filter
5196         // --------------------------------------------------------------------------------------------
5197         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5198         //     ...
5199         //     filter Filter,
5200         //     ...
5201         //
5202         // Filter ::= CHOICE {
5203         //     ...
5204         //     extensibleMatch  [9] MatchingRuleAssertion,
5205         //     ...
5206         //
5207         // Init Assertion Value Filter filter
5208         super.transitions[LdapStatesEnum.MATCH_VALUE_STATE.ordinal()][LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG] =
5209             new GrammarTransition(
5210                 LdapStatesEnum.MATCH_VALUE_STATE,
5211                 LdapStatesEnum.EXTENSIBLE_MATCH_STATE,
5212                 LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG,
5213                 new InitExtensibleMatchFilter() );
5214 
5215         // --------------------------------------------------------------------------------------------
5216         // Transition from match value to Attribute Description List
5217         // --------------------------------------------------------------------------------------------
5218         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5219         //     ...
5220         //     filter      Filter,
5221         //     attributes  AttributeDescriptionList }
5222         //
5223         // AttributeDescriptionList ::= SEQUENCE OF
5224         //     AttributeDescription
5225         //
5226         // Init attribute description list
5227         super.transitions[LdapStatesEnum.MATCH_VALUE_STATE.ordinal()][SEQUENCE.getValue()] =
5228             new GrammarTransition(
5229                 LdapStatesEnum.MATCH_VALUE_STATE,
5230                 LdapStatesEnum.ATTRIBUTE_DESCRIPTION_LIST_STATE,
5231                 SEQUENCE,
5232                 new InitSearchRequestAttributeDescList() );
5233 
5234         // --------------------------------------------------------------------------------------------
5235         // Transition from dnAttributes to AND filter
5236         // --------------------------------------------------------------------------------------------
5237         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5238         //     ...
5239         //     filter Filter,
5240         //     ...
5241         //
5242         // Filter ::= CHOICE {
5243         //     and             [0] SET OF Filter,
5244         //     ...
5245         //
5246         // Init AND filter
5247         super.transitions[LdapStatesEnum.DN_ATTRIBUTES_STATE.ordinal()][LdapConstants.AND_FILTER_TAG] =
5248             new GrammarTransition(
5249                 LdapStatesEnum.DN_ATTRIBUTES_STATE,
5250                 LdapStatesEnum.AND_STATE,
5251                 LdapConstants.AND_FILTER_TAG,
5252                 new InitAndFilter() );
5253 
5254         // --------------------------------------------------------------------------------------------
5255         // Transition from dnAttributes to OR filter
5256         // --------------------------------------------------------------------------------------------
5257         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5258         //     ...
5259         //     filter Filter,
5260         //     ...
5261         //
5262         // Filter ::= CHOICE {
5263         //     ...
5264         //     or              [1] SET OF Filter,
5265         //     ...
5266         //
5267         // Init OR filter
5268         super.transitions[LdapStatesEnum.DN_ATTRIBUTES_STATE.ordinal()][LdapConstants.OR_FILTER_TAG] =
5269             new GrammarTransition(
5270                 LdapStatesEnum.DN_ATTRIBUTES_STATE,
5271                 LdapStatesEnum.OR_STATE,
5272                 LdapConstants.OR_FILTER_TAG,
5273                 new InitOrFilter() );
5274 
5275         // --------------------------------------------------------------------------------------------
5276         // Transition from dnAttributes to NOT filter
5277         // --------------------------------------------------------------------------------------------
5278         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5279         //     ...
5280         //     filter Filter,
5281         //     ...
5282         //
5283         // Filter ::= CHOICE {
5284         //     ...
5285         //     not             [2] SET OF Filter,
5286         //     ...
5287         //
5288         // Init NOT filter
5289         super.transitions[LdapStatesEnum.DN_ATTRIBUTES_STATE.ordinal()][LdapConstants.NOT_FILTER_TAG] =
5290             new GrammarTransition(
5291                 LdapStatesEnum.DN_ATTRIBUTES_STATE,
5292                 LdapStatesEnum.NOT_STATE,
5293                 LdapConstants.NOT_FILTER_TAG,
5294                 new InitNotFilter() );
5295 
5296         // --------------------------------------------------------------------------------------------
5297         // Transition from dnAttributes to Equality Match filter
5298         // --------------------------------------------------------------------------------------------
5299         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5300         //     ...
5301         //     filter Filter,
5302         //     ...
5303         //
5304         // Filter ::= CHOICE {
5305         //     ...
5306         //     equalityMatch   [3] AttributeValueAssertion,
5307         //     ...
5308         //
5309         // Init NOT filter
5310         super.transitions[LdapStatesEnum.DN_ATTRIBUTES_STATE.ordinal()][LdapConstants.EQUALITY_MATCH_FILTER_TAG] =
5311             new GrammarTransition(
5312                 LdapStatesEnum.DN_ATTRIBUTES_STATE,
5313                 LdapStatesEnum.EQUALITY_MATCH_STATE,
5314                 LdapConstants.EQUALITY_MATCH_FILTER_TAG,
5315                 new InitEqualityMatchFilter() );
5316 
5317         // --------------------------------------------------------------------------------------------
5318         // Transition from dnAttributes to Substrings filter
5319         // --------------------------------------------------------------------------------------------
5320         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5321         //     ...
5322         //     filter Filter,
5323         //     ...
5324         //
5325         // Filter ::= CHOICE {
5326         //     ...
5327         //     substrings     [4] SubstringFilter,
5328         //     ...
5329         //
5330         // Init Substrings filter
5331         super.transitions[LdapStatesEnum.DN_ATTRIBUTES_STATE.ordinal()][LdapConstants.SUBSTRINGS_FILTER_TAG] =
5332             new GrammarTransition(
5333                 LdapStatesEnum.DN_ATTRIBUTES_STATE,
5334                 LdapStatesEnum.SUBSTRING_FILTER_STATE,
5335                 LdapConstants.SUBSTRINGS_FILTER_TAG,
5336                 new InitSubstringsFilter() );
5337 
5338         // --------------------------------------------------------------------------------------------
5339         // Transition from dnAttributes to GreaterOrEqual filter
5340         // --------------------------------------------------------------------------------------------
5341         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5342         //     ...
5343         //     filter Filter,
5344         //     ...
5345         //
5346         // Filter ::= CHOICE {
5347         //     ...
5348         //     greaterOrEqual  [5] AttributeValueAssertion,
5349         //     ...
5350         //
5351         // Init Greater Or Equal filter
5352         super.transitions[LdapStatesEnum.DN_ATTRIBUTES_STATE.ordinal()][LdapConstants.GREATER_OR_EQUAL_FILTER_TAG] =
5353             new GrammarTransition(
5354                 LdapStatesEnum.DN_ATTRIBUTES_STATE,
5355                 LdapStatesEnum.GREATER_OR_EQUAL_STATE,
5356                 LdapConstants.GREATER_OR_EQUAL_FILTER_TAG,
5357                 new InitGreaterOrEqualFilter() );
5358 
5359         // --------------------------------------------------------------------------------------------
5360         // Transition from dnAttributes to LessOrEqual filter
5361         // --------------------------------------------------------------------------------------------
5362         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5363         //     ...
5364         //     filter Filter,
5365         //     ...
5366         //
5367         // Filter ::= CHOICE {
5368         //     ...
5369         //     LessOrEqual    [6] AttributeValueAssertion,
5370         //     ...
5371         //
5372         // Init Less Or Equal filter
5373         super.transitions[LdapStatesEnum.DN_ATTRIBUTES_STATE.ordinal()][LdapConstants.LESS_OR_EQUAL_FILTER_TAG] =
5374             new GrammarTransition(
5375                 LdapStatesEnum.DN_ATTRIBUTES_STATE,
5376                 LdapStatesEnum.LESS_OR_EQUAL_STATE,
5377                 LdapConstants.LESS_OR_EQUAL_FILTER_TAG,
5378                 new InitLessOrEqualFilter() );
5379 
5380         // --------------------------------------------------------------------------------------------
5381         // Transition from dnAttributes to Present filter
5382         // --------------------------------------------------------------------------------------------
5383         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5384         //     ...
5385         //     filter Filter,
5386         //     ...
5387         //
5388         // Filter ::= CHOICE {
5389         //     ...
5390         //     present        [7] AttributeDescription,
5391         //     ...
5392         //
5393         // Init present filter
5394         super.transitions[LdapStatesEnum.DN_ATTRIBUTES_STATE.ordinal()][LdapConstants.PRESENT_FILTER_TAG] =
5395             new GrammarTransition(
5396                 LdapStatesEnum.DN_ATTRIBUTES_STATE,
5397                 LdapStatesEnum.PRESENT_STATE,
5398                 LdapConstants.PRESENT_FILTER_TAG,
5399                 new InitPresentFilter() );
5400 
5401         // --------------------------------------------------------------------------------------------
5402         // Transition from dnAttributes to Approx Match filter
5403         // --------------------------------------------------------------------------------------------
5404         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5405         //     ...
5406         //     filter Filter,
5407         //     ...
5408         //
5409         // Filter ::= CHOICE {
5410         //     ...
5411         //     approxMatch     [8] AttributeValueAssertion,
5412         //     ...
5413         //
5414         // Init Approx Match filter
5415         super.transitions[LdapStatesEnum.DN_ATTRIBUTES_STATE.ordinal()][LdapConstants.APPROX_MATCH_FILTER_TAG] =
5416             new GrammarTransition(
5417                 LdapStatesEnum.DN_ATTRIBUTES_STATE,
5418                 LdapStatesEnum.APPROX_MATCH_STATE,
5419                 LdapConstants.APPROX_MATCH_FILTER_TAG,
5420                 new InitApproxMatchFilter() );
5421 
5422         // --------------------------------------------------------------------------------------------
5423         // Transition from dnAttributes to Extensible Match filter
5424         // --------------------------------------------------------------------------------------------
5425         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5426         //     ...
5427         //     filter Filter,
5428         //     ...
5429         //
5430         // Filter ::= CHOICE {
5431         //     ...
5432         //     extensibleMatch  [9] MatchingRuleAssertion,
5433         //     ...
5434         //
5435         // Init Assertion Value Filter filter
5436         super.transitions[LdapStatesEnum.DN_ATTRIBUTES_STATE.ordinal()][LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG] =
5437             new GrammarTransition(
5438                 LdapStatesEnum.DN_ATTRIBUTES_STATE,
5439                 LdapStatesEnum.EXTENSIBLE_MATCH_STATE,
5440                 LdapConstants.EXTENSIBLE_MATCH_FILTER_TAG,
5441                 new InitExtensibleMatchFilter() );
5442 
5443         // --------------------------------------------------------------------------------------------
5444         // Transition from dnAttributes to Attribute Description List
5445         // --------------------------------------------------------------------------------------------
5446         // SearchRequest ::= [APPLICATION 3] SEQUENCE {
5447         //     ...
5448         //     filter      Filter,
5449         //     attributes  AttributeDescriptionList }
5450         //
5451         // AttributeDescriptionList ::= SEQUENCE OF
5452         //     AttributeDescription
5453         //
5454         // Init attribute description list
5455         super.transitions[LdapStatesEnum.DN_ATTRIBUTES_STATE.ordinal()][SEQUENCE.getValue()] =
5456             new GrammarTransition(
5457                 LdapStatesEnum.DN_ATTRIBUTES_STATE,
5458                 LdapStatesEnum.ATTRIBUTE_DESCRIPTION_LIST_STATE,
5459                 SEQUENCE,
5460                 new InitSearchRequestAttributeDescList() );
5461     }
5462 
5463 
5464     /**
5465      * Get the instance of this grammar
5466      *
5467      * @return An instance on the LdapMessage Grammar
5468      */
5469     @SuppressWarnings("rawtypes")
5470     public static Grammar getInstance()
5471     {
5472         return instance;
5473     }
5474 }