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