001    /*
002     *  Licensed to the Apache Software Foundation (ASF) under one
003     *  or more contributor license agreements.  See the NOTICE file
004     *  distributed with this work for additional information
005     *  regarding copyright ownership.  The ASF licenses this file
006     *  to you under the Apache License, Version 2.0 (the
007     *  "License"); you may not use this file except in compliance
008     *  with the License.  You may obtain a copy of the License at
009     *  
010     *    http://www.apache.org/licenses/LICENSE-2.0
011     *  
012     *  Unless required by applicable law or agreed to in writing,
013     *  software distributed under the License is distributed on an
014     *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015     *  KIND, either express or implied.  See the License for the
016     *  specific language governing permissions and limitations
017     *  under the License. 
018     *  
019     */
020    
021    package org.apache.directory.shared.dsmlv2.reponse;
022    
023    
024    import java.io.IOException;
025    import java.lang.reflect.Array;
026    import java.util.HashMap;
027    import java.util.HashSet;
028    import java.util.Set;
029    
030    import org.apache.directory.shared.asn1.codec.DecoderException;
031    import org.apache.directory.shared.asn1.primitives.OID;
032    import org.apache.directory.shared.dsmlv2.AbstractGrammar;
033    import org.apache.directory.shared.dsmlv2.Dsmlv2Container;
034    import org.apache.directory.shared.dsmlv2.Dsmlv2StatesEnum;
035    import org.apache.directory.shared.dsmlv2.GrammarAction;
036    import org.apache.directory.shared.dsmlv2.GrammarTransition;
037    import org.apache.directory.shared.dsmlv2.IGrammar;
038    import org.apache.directory.shared.dsmlv2.ParserUtils;
039    import org.apache.directory.shared.dsmlv2.Tag;
040    import org.apache.directory.shared.dsmlv2.reponse.ErrorResponse.ErrorResponseType;
041    import org.apache.directory.shared.i18n.I18n;
042    import org.apache.directory.shared.ldap.codec.LdapMessageCodec;
043    import org.apache.directory.shared.ldap.codec.LdapResponseCodec;
044    import org.apache.directory.shared.ldap.codec.LdapResultCodec;
045    import org.apache.directory.shared.ldap.codec.add.AddResponseCodec;
046    import org.apache.directory.shared.ldap.codec.bind.BindResponseCodec;
047    import org.apache.directory.shared.ldap.codec.compare.CompareResponseCodec;
048    import org.apache.directory.shared.ldap.codec.controls.ControlImpl;
049    import org.apache.directory.shared.ldap.codec.del.DelResponseCodec;
050    import org.apache.directory.shared.ldap.codec.extended.ExtendedResponseCodec;
051    import org.apache.directory.shared.ldap.codec.modify.ModifyResponseCodec;
052    import org.apache.directory.shared.ldap.codec.modifyDn.ModifyDNResponseCodec;
053    import org.apache.directory.shared.ldap.codec.search.SearchResultDoneCodec;
054    import org.apache.directory.shared.ldap.codec.search.SearchResultEntryCodec;
055    import org.apache.directory.shared.ldap.codec.search.SearchResultReferenceCodec;
056    import org.apache.directory.shared.ldap.codec.util.LdapURLEncodingException;
057    import org.apache.directory.shared.ldap.exception.LdapInvalidDnException;
058    import org.apache.directory.shared.ldap.message.ResultCodeEnum;
059    import org.apache.directory.shared.ldap.message.control.Control;
060    import org.apache.directory.shared.ldap.name.DN;
061    import org.apache.directory.shared.ldap.util.Base64;
062    import org.apache.directory.shared.ldap.util.LdapURL;
063    import org.xmlpull.v1.XmlPullParser;
064    import org.xmlpull.v1.XmlPullParserException;
065    
066    
067    /**
068     * This Class represents the DSMLv2 Response Grammar
069     * 
070     * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
071     * @version $Rev$, $Date$
072     */
073    public class Dsmlv2ResponseGrammar extends AbstractGrammar implements IGrammar
074    {
075        /** The instance of grammar. Dsmlv2ResponseGrammar is a singleton */
076        private static Dsmlv2ResponseGrammar instance = new Dsmlv2ResponseGrammar();
077    
078        // Initializing DESCR_TAGS
079        private static Set<String> DSMLV2_DESCR_TAGS = null;
080        static
081        {
082            DSMLV2_DESCR_TAGS = new HashSet<String>();
083            DSMLV2_DESCR_TAGS.add( "success" );
084            DSMLV2_DESCR_TAGS.add( "operationsError" );
085            DSMLV2_DESCR_TAGS.add( "protocolError" );
086            DSMLV2_DESCR_TAGS.add( "timeLimitExceeded" );
087            DSMLV2_DESCR_TAGS.add( "sizeLimitExceeded" );
088            DSMLV2_DESCR_TAGS.add( "compareFalse" );
089            DSMLV2_DESCR_TAGS.add( "compareTrue" );
090            DSMLV2_DESCR_TAGS.add( "authMethodNotSupported" );
091            DSMLV2_DESCR_TAGS.add( "strongAuthRequired" );
092            DSMLV2_DESCR_TAGS.add( "referral" );
093            DSMLV2_DESCR_TAGS.add( "adminLimitExceeded" );
094            DSMLV2_DESCR_TAGS.add( "unavailableCriticalExtension" );
095            DSMLV2_DESCR_TAGS.add( "confidentialityRequired" );
096            DSMLV2_DESCR_TAGS.add( "saslBindInProgress" );
097            DSMLV2_DESCR_TAGS.add( "noSuchAttribute" );
098            DSMLV2_DESCR_TAGS.add( "undefinedAttributeType" );
099            DSMLV2_DESCR_TAGS.add( "inappropriateMatching" );
100            DSMLV2_DESCR_TAGS.add( "constraintViolation" );
101            DSMLV2_DESCR_TAGS.add( "attributeOrValueExists" );
102            DSMLV2_DESCR_TAGS.add( "invalidAttributeSyntax" );
103            DSMLV2_DESCR_TAGS.add( "noSuchObject" );
104            DSMLV2_DESCR_TAGS.add( "aliasProblem" );
105            DSMLV2_DESCR_TAGS.add( "invalidDNSyntax" );
106            DSMLV2_DESCR_TAGS.add( "aliasDereferencingProblem" );
107            DSMLV2_DESCR_TAGS.add( "inappropriateAuthentication" );
108            DSMLV2_DESCR_TAGS.add( "invalidCredentials" );
109            DSMLV2_DESCR_TAGS.add( "insufficientAccessRights" );
110            DSMLV2_DESCR_TAGS.add( "busy" );
111            DSMLV2_DESCR_TAGS.add( "unavailable" );
112            DSMLV2_DESCR_TAGS.add( "unwillingToPerform" );
113            DSMLV2_DESCR_TAGS.add( "loopDetect" );
114            DSMLV2_DESCR_TAGS.add( "namingViolation" );
115            DSMLV2_DESCR_TAGS.add( "objectClassViolation" );
116            DSMLV2_DESCR_TAGS.add( "notAllowedOnNonLeaf" );
117            DSMLV2_DESCR_TAGS.add( "notAllowedOnRDN" );
118            DSMLV2_DESCR_TAGS.add( "entryAlreadyExists" );
119            DSMLV2_DESCR_TAGS.add( "objectClassModsProhibited" );
120            DSMLV2_DESCR_TAGS.add( "affectMultipleDSAs" );
121            DSMLV2_DESCR_TAGS.add( "other" );
122        }
123    
124    
125        @SuppressWarnings("unchecked")
126        private Dsmlv2ResponseGrammar()
127        {
128            name = Dsmlv2ResponseGrammar.class.getName();
129            statesEnum = Dsmlv2StatesEnum.getInstance();
130    
131            // Create the transitions table
132            super.transitions = ( HashMap<Tag, GrammarTransition>[] ) Array.newInstance( HashMap.class, 300 );; // TODO Change this value
133    
134            //====================================================
135            //  Transitions concerning : BATCH RESPONSE
136            //====================================================
137            super.transitions[Dsmlv2StatesEnum.INIT_GRAMMAR_STATE] = new HashMap<Tag, GrammarTransition>();
138    
139            // ** OPEN BATCH Reponse **
140            // State: [INIT_GRAMMAR_STATE] - Tag: <batchResponse>
141            super.transitions[Dsmlv2StatesEnum.INIT_GRAMMAR_STATE].put( new Tag( "batchResponse", Tag.START ),
142                new GrammarTransition( Dsmlv2StatesEnum.INIT_GRAMMAR_STATE, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP,
143                    batchResponseCreation ) );
144    
145            //====================================================
146            //  Transitions concerning : BATCH RESPONSE LOOP
147            //====================================================
148            super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP] = new HashMap<Tag, GrammarTransition>();
149    
150            // State: [BATCH_RESPONSE_LOOP] - Tag: <addResponse>
151            super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "addResponse", Tag.START ),
152                new GrammarTransition( Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.LDAP_RESULT,
153                    addResponseCreation ) );
154    
155            // State: [BATCH_RESPONSE_LOOP] - Tag: <authResponse>
156            super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "authResponse", Tag.START ),
157                new GrammarTransition( Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.LDAP_RESULT,
158                    authResponseCreation ) );
159    
160            // State: [BATCH_RESPONSE_LOOP] - Tag: <compareResponse>
161            super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "compareResponse", Tag.START ),
162                new GrammarTransition( Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.LDAP_RESULT,
163                    compareResponseCreation ) );
164    
165            // State: [BATCH_RESPONSE_LOOP] - Tag: <delResponse>
166            super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "delResponse", Tag.START ),
167                new GrammarTransition( Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.LDAP_RESULT,
168                    delResponseCreation ) );
169    
170            // State: [BATCH_RESPONSE_LOOP] - Tag: <modifyResponse>
171            super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "modifyResponse", Tag.START ),
172                new GrammarTransition( Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.LDAP_RESULT,
173                    modifyResponseCreation ) );
174    
175            // State: [BATCH_RESPONSE_LOOP] - Tag: <modDNResponse>
176            super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "modDNResponse", Tag.START ),
177                new GrammarTransition( Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.LDAP_RESULT,
178                    modDNResponseCreation ) );
179    
180            // State: [BATCH_RESPONSE_LOOP] - Tag: <extendedResponse>
181            super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "extendedResponse", Tag.START ),
182                new GrammarTransition( Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.EXTENDED_RESPONSE,
183                    extendedResponseCreation ) );
184    
185            // State: [BATCH_RESPONSE_LOOP] - Tag: <errorResponse>
186            super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "errorResponse", Tag.START ),
187                new GrammarTransition( Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.ERROR_RESPONSE,
188                    errorResponseCreation ) );
189    
190            // State: [BATCH_RESPONSE_LOOP] - Tag: <searchReponse>
191            super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "searchResponse", Tag.START ),
192                new GrammarTransition( Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.SEARCH_RESPONSE,
193                    searchResponseCreation ) );
194    
195            // State: [BATCH_RESPONSE_LOOP] - Tag: </batchResponse>
196            super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "batchResponse", Tag.END ),
197                new GrammarTransition( Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.GRAMMAR_END, null ) );
198    
199            //====================================================
200            //  Transitions concerning : ERROR RESPONSE
201            //====================================================
202            super.transitions[Dsmlv2StatesEnum.ERROR_RESPONSE] = new HashMap<Tag, GrammarTransition>();
203            super.transitions[Dsmlv2StatesEnum.MESSAGE_END] = new HashMap<Tag, GrammarTransition>();
204            super.transitions[Dsmlv2StatesEnum.DETAIL_START] = new HashMap<Tag, GrammarTransition>();
205            super.transitions[Dsmlv2StatesEnum.DETAIL_END] = new HashMap<Tag, GrammarTransition>();
206    
207            // State: [ERROR_RESPONSE] - Tag: <message>
208            super.transitions[Dsmlv2StatesEnum.ERROR_RESPONSE].put( new Tag( "message", Tag.START ), new GrammarTransition(
209                Dsmlv2StatesEnum.ERROR_RESPONSE, Dsmlv2StatesEnum.MESSAGE_END, errorResponseAddMessage ) );
210    
211            // State: [ERROR_RESPONSE] - Tag: <detail>
212            super.transitions[Dsmlv2StatesEnum.ERROR_RESPONSE].put( new Tag( "detail", Tag.START ), new GrammarTransition(
213                Dsmlv2StatesEnum.ERROR_RESPONSE, Dsmlv2StatesEnum.DETAIL_START, errorResponseAddDetail ) );
214    
215            // State: [MESSAGE_END] - Tag: </errorResponse>
216            super.transitions[Dsmlv2StatesEnum.MESSAGE_END].put( new Tag( "errorResponse", Tag.END ),
217                new GrammarTransition( Dsmlv2StatesEnum.MESSAGE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ) );
218    
219            // State: [MESSAGE_END] - Tag: <detail>
220            super.transitions[Dsmlv2StatesEnum.MESSAGE_END].put( new Tag( "detail", Tag.START ), new GrammarTransition(
221                Dsmlv2StatesEnum.MESSAGE_END, Dsmlv2StatesEnum.DETAIL_START, errorResponseAddDetail ) );
222    
223            // State: [DETAIL_START] - Tag: </detail>
224            super.transitions[Dsmlv2StatesEnum.DETAIL_START].put( new Tag( "detail", Tag.END ), new GrammarTransition(
225                Dsmlv2StatesEnum.DETAIL_START, Dsmlv2StatesEnum.DETAIL_END, null ) );
226    
227            // State: [DETAIL_END] - Tag: <detail>
228            super.transitions[Dsmlv2StatesEnum.DETAIL_END].put( new Tag( "detail", Tag.END ), new GrammarTransition(
229                Dsmlv2StatesEnum.DETAIL_END, Dsmlv2StatesEnum.DETAIL_END, errorResponseAddDetail ) );
230    
231            // State: [ERROR_RESPONSE] - Tag: </errorResponse>
232            super.transitions[Dsmlv2StatesEnum.ERROR_RESPONSE].put( new Tag( "errorResponse", Tag.END ),
233                new GrammarTransition( Dsmlv2StatesEnum.ERROR_RESPONSE, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ) );
234    
235            //====================================================
236            //  Transitions concerning : EXTENDED RESPONSE
237            //====================================================
238            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE] = new HashMap<Tag, GrammarTransition>();
239            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_START] = new HashMap<Tag, GrammarTransition>();
240            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_END] = new HashMap<Tag, GrammarTransition>();
241            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_VALUE_END] = new HashMap<Tag, GrammarTransition>();
242            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_START] = new HashMap<Tag, GrammarTransition>();
243            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END] = new HashMap<Tag, GrammarTransition>();
244            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END] = new HashMap<Tag, GrammarTransition>();
245            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END] = new HashMap<Tag, GrammarTransition>();
246            super.transitions[Dsmlv2StatesEnum.RESPONSE_NAME_END] = new HashMap<Tag, GrammarTransition>();
247            super.transitions[Dsmlv2StatesEnum.RESPONSE_END] = new HashMap<Tag, GrammarTransition>();
248    
249            // State: [EXTENDED_RESPONSE] - Tag: <control>
250            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE].put( new Tag( "control", Tag.START ),
251                new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE,
252                    Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_START, ldapResultControlCreation ) );
253    
254            // State: [EXTENDED_RESPONSE_CONTROL_START] - Tag: <controlValue>
255            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_START].put( new Tag( "controlValue", Tag.START ),
256                new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_START,
257                    Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_VALUE_END, ldapResultControlValueCreation ) );
258    
259            // State: [EXTENDED_RESPONSE_CONTROL_VALUE_END] - Tag: </control>
260            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_VALUE_END].put( new Tag( "control", Tag.END ),
261                new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_VALUE_END,
262                    Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_END, null ) );
263    
264            // State: [EXTENDED_RESPONSE_CONTROL_START] - Tag: </control>
265            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_START].put( new Tag( "control", Tag.END ),
266                new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_START,
267                    Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_END, null ) );
268    
269            // State: [EXTENDED_RESPONSE_CONTROL_END] - Tag: <control>
270            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_END].put( new Tag( "control", Tag.START ),
271                new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_END,
272                    Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_START, ldapResultControlCreation ) );
273    
274            // State: [EXTENDED_RESPONSE_CONTROL_END] - Tag: <resultCode>
275            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_END].put( new Tag( "resultCode", Tag.START ),
276                new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_END,
277                    Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_START, extendedResponseAddResultCode ) );
278    
279            // State: [EXTENDED_RESPONSE] - Tag: <resultCode>
280            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE].put( new Tag( "resultCode", Tag.START ),
281                new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE,
282                    Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_START, extendedResponseAddResultCode ) );
283    
284            // State: [EXTENDED_RESPONSE_RESULT_CODE_START] - Tag: </resultCode>
285            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_START].put( new Tag( "resultCode", Tag.END ),
286                new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_START,
287                    Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END, null ) );
288    
289            // State: [EXTENDED_RESPONSE_RESULT_CODE_END] - Tag: <errorMessage>
290            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END].put(
291                new Tag( "errorMessage", Tag.START ), new GrammarTransition(
292                    Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END,
293                    Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END, extendedResponseAddErrorMessage ) );
294    
295            // State: [EXTENDED_RESPONSE_RESULT_CODE_END] - Tag: <referral>
296            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END].put( new Tag( "referral", Tag.START ),
297                new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END,
298                    Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END, extendedResponseAddReferral ) );
299    
300            // State: [EXTENDED_RESPONSE_RESULT_CODE_END] - Tag: <responseName>
301            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END].put(
302                new Tag( "responseName", Tag.START ), new GrammarTransition(
303                    Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END, Dsmlv2StatesEnum.RESPONSE_NAME_END,
304                    extendedResponseAddResponseName ) );
305    
306            // State: [EXTENDED_RESPONSE_RESULT_CODE_END] - Tag: <response>
307            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END].put( new Tag( "response", Tag.START ),
308                new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END, Dsmlv2StatesEnum.RESPONSE_END,
309                    extendedResponseAddResponse ) );
310    
311            // State: [EXTENDED_RESPONSE_RESULT_CODE_END] - Tag: </extendedResponse>
312            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END].put(
313                new Tag( "extendedResponse", Tag.END ), new GrammarTransition(
314                    Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ) );
315    
316            // State: [EXTENDED_RESPONSE_ERROR_MESSAGE_END] - Tag: <referral>
317            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END].put( new Tag( "referral", Tag.START ),
318                new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END,
319                    Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END, extendedResponseAddReferral ) );
320    
321            // State: [EXTENDED_RESPONSE_ERROR_MESSAGE_END] - Tag: <responseName>
322            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END].put(
323                new Tag( "responseName", Tag.START ), new GrammarTransition(
324                    Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END, Dsmlv2StatesEnum.RESPONSE_NAME_END,
325                    extendedResponseAddResponseName ) );
326    
327            // State: [EXTENDED_RESPONSE_ERROR_MESSAGE_END] - Tag: <response>
328            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END].put( new Tag( "response", Tag.START ),
329                new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END,
330                    Dsmlv2StatesEnum.RESPONSE_END, extendedResponseAddResponse ) );
331    
332            // State: [EXTENDED_RESPONSE_ERROR_MESSAGE_END] - Tag: </extendedResponse>
333            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END].put( new Tag( "extendedResponse",
334                Tag.END ), new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END,
335                Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ) );
336    
337            // State: [EXTENDED_RESPONSE_REFERRAL_END] - Tag: <referral>
338            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END].put( new Tag( "referral", Tag.START ),
339                new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END,
340                    Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END, extendedResponseAddReferral ) );
341    
342            // State: [EXTENDED_RESPONSE_REFERRAL_END] - Tag: <responseName>
343            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END].put( new Tag( "responseName", Tag.START ),
344                new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END,
345                    Dsmlv2StatesEnum.RESPONSE_NAME_END, extendedResponseAddResponseName ) );
346    
347            // State: [EXTENDED_RESPONSE_REFERRAL_END] - Tag: <reponse>
348            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END].put( new Tag( "reponse", Tag.START ),
349                new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END, Dsmlv2StatesEnum.RESPONSE_END,
350                    extendedResponseAddResponse ) );
351    
352            // State: [EXTENDED_RESPONSE_REFERRAL_END] - Tag: </extendedResponse>
353            super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END].put( new Tag( "extendedResponse", Tag.END ),
354                new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END,
355                    Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ) );
356    
357            // State: [RESPONSE_NAME_END] - Tag: <response>
358            super.transitions[Dsmlv2StatesEnum.RESPONSE_NAME_END].put( new Tag( "response", Tag.START ),
359                new GrammarTransition( Dsmlv2StatesEnum.RESPONSE_NAME_END, Dsmlv2StatesEnum.RESPONSE_END,
360                    extendedResponseAddResponse ) );
361    
362            // State: [RESPONSE_NAME_END] - Tag: </extendedResponse>
363            super.transitions[Dsmlv2StatesEnum.RESPONSE_NAME_END].put( new Tag( "extendedResponse", Tag.END ),
364                new GrammarTransition( Dsmlv2StatesEnum.RESPONSE_NAME_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ) );
365    
366            // State: [RESPONSE_END] - Tag: </extendedResponse>
367            super.transitions[Dsmlv2StatesEnum.RESPONSE_END].put( new Tag( "extendedResponse", Tag.END ),
368                new GrammarTransition( Dsmlv2StatesEnum.RESPONSE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ) );
369    
370            //====================================================
371            //  Transitions concerning : LDAP RESULT
372            //====================================================
373            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT] = new HashMap<Tag, GrammarTransition>();
374            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_START] = new HashMap<Tag, GrammarTransition>();
375            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_END] = new HashMap<Tag, GrammarTransition>();
376            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_VALUE_END] = new HashMap<Tag, GrammarTransition>();
377            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_START] = new HashMap<Tag, GrammarTransition>();
378            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END] = new HashMap<Tag, GrammarTransition>();
379            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END] = new HashMap<Tag, GrammarTransition>();
380            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END] = new HashMap<Tag, GrammarTransition>();
381            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_DONE_END] = new HashMap<Tag, GrammarTransition>();
382    
383            // State: [LDAP_RESULT] - Tag: <control>
384            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT].put( new Tag( "control", Tag.START ), new GrammarTransition(
385                Dsmlv2StatesEnum.LDAP_RESULT, Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_START, ldapResultControlCreation ) );
386    
387            // State: [LDAP_RESULT] - Tag: <resultCode>
388            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT].put( new Tag( "resultCode", Tag.START ), new GrammarTransition(
389                Dsmlv2StatesEnum.LDAP_RESULT, Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_START, ldapResultAddResultCode ) );
390    
391            // State: [LDAP_RESULT_CONTROL_START] - Tag: <controlValue>
392            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_START].put( new Tag( "controlValue", Tag.START ),
393                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_START,
394                    Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_VALUE_END, ldapResultControlValueCreation ) );
395    
396            // State: [LDAP_RESULT_CONTROL_VALUE_END] - Tag: </control>
397            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_VALUE_END].put( new Tag( "control", Tag.END ),
398                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_VALUE_END,
399                    Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_END, null ) );
400    
401            // State: [LDAP_RESULT_CONTROL_START] - Tag: </control>
402            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_START].put( new Tag( "control", Tag.END ),
403                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_START,
404                    Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_END, null ) );
405    
406            // State: [LDAP_RESULT_CONTROL_END] - Tag: <control>
407            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_END].put( new Tag( "control", Tag.START ),
408                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_END,
409                    Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_START, ldapResultControlCreation ) );
410    
411            // State: [LDAP_RESULT_CONTROL_END] - Tag: <resultCode>
412            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_END].put( new Tag( "resultCode", Tag.START ),
413                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_END,
414                    Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_START, ldapResultAddResultCode ) );
415    
416            // State: [LDAP_RESULT_RESULT_CODE_START] - Tag: </resultCode>
417            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_START].put( new Tag( "resultCode", Tag.END ),
418                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_START,
419                    Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END, null ) );
420    
421            // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: <errorMessage>
422            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END].put( new Tag( "errorMessage", Tag.START ),
423                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END,
424                    Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END, ldapResultAddErrorMessage ) );
425    
426            // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: <referral>
427            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END].put( new Tag( "referral", Tag.START ),
428                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END,
429                    Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, ldapResultAddReferral ) );
430    
431            // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: </addResponse>
432            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END].put( new Tag( "addResponse", Tag.END ),
433                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP,
434                    null ) );
435    
436            // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: </authResponse>
437            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END].put( new Tag( "authResponse", Tag.END ),
438                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP,
439                    null ) );
440    
441            // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: </compareResponse>
442            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END].put( new Tag( "compareResponse", Tag.END ),
443                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP,
444                    null ) );
445    
446            // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: </delResponse>
447            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END].put( new Tag( "delResponse", Tag.END ),
448                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP,
449                    null ) );
450    
451            // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: </modifyResponse>
452            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END].put( new Tag( "modifyResponse", Tag.END ),
453                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP,
454                    null ) );
455    
456            // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: </modDNResponse>
457            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END].put( new Tag( "modDNResponse", Tag.END ),
458                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP,
459                    null ) );
460    
461            // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: </searchResultDone>
462            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END].put( new Tag( "searchResultDone", Tag.END ),
463                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END,
464                    Dsmlv2StatesEnum.SEARCH_RESULT_DONE_END, null ) );
465    
466            // State: [SEARCH_RESULT_DONE_END] - Tag: </searchResponse>
467            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_DONE_END]
468                .put( new Tag( "searchResponse", Tag.END ), new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_DONE_END,
469                    Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ) );
470    
471            // State: [LDAP_RESULT_ERROR_MESSAGE_END] - Tag: <referral>
472            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END].put( new Tag( "referral", Tag.START ),
473                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END,
474                    Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, ldapResultAddReferral ) );
475    
476            // State: [LDAP_RESULT_ERROR_MESSAGE_END] - Tag: </addResponse>
477            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END].put( new Tag( "addResponse", Tag.END ),
478                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END,
479                    Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ) );
480    
481            // State: [LDAP_RESULT_ERROR_MESSAGE_END] - Tag: </authResponse>
482            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END].put( new Tag( "authResponse", Tag.END ),
483                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END,
484                    Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ) );
485    
486            // State: [LDAP_RESULT_ERROR_MESSAGE_END] - Tag: </compareResponse>
487            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END].put( new Tag( "compareResponse", Tag.END ),
488                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END,
489                    Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ) );
490    
491            // State: [LDAP_RESULT_ERROR_MESSAGE_END] - Tag: </delResponse>
492            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END].put( new Tag( "delResponse", Tag.END ),
493                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END,
494                    Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ) );
495    
496            // State: [LDAP_RESULT_ERROR_MESSAGE_END] - Tag: </modifyResponse>
497            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END].put( new Tag( "modifyResponse", Tag.END ),
498                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END,
499                    Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ) );
500    
501            // State: [LDAP_RESULT_ERROR_MESSAGE_END] - Tag: </modDNResponse>
502            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END].put( new Tag( "modDNResponse", Tag.END ),
503                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END,
504                    Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ) );
505    
506            // State: [LDAP_RESULT_ERROR_MESSAGE_END] - Tag: </searchResultDone>
507            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END].put( new Tag( "searchResultDone", Tag.END ),
508                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END,
509                    Dsmlv2StatesEnum.SEARCH_RESULT_DONE_END, null ) );
510    
511            // State: [LDAP_RESULT_REFERRAL_END] - Tag: <referral>
512            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END].put( new Tag( "referral", Tag.START ),
513                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END,
514                    Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, ldapResultAddReferral ) );
515    
516            // State: [LDAP_RESULT_REFERRAL_END] - Tag: </addResponse>
517            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END].put( new Tag( "addResponse", Tag.END ),
518                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP,
519                    null ) );
520    
521            // State: [LDAP_RESULT_REFERRAL_END] - Tag: </authResponse>
522            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END].put( new Tag( "authResponse", Tag.END ),
523                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP,
524                    null ) );
525    
526            // State: [LDAP_RESULT_REFERRAL_END] - Tag: </compareResponse>
527            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END].put( new Tag( "compareResponse", Tag.END ),
528                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP,
529                    null ) );
530    
531            // State: [LDAP_RESULT_REFERRAL_END] - Tag: </delResponse>
532            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END].put( new Tag( "delResponse", Tag.END ),
533                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP,
534                    null ) );
535    
536            // State: [LDAP_RESULT_REFERRAL_END] - Tag: </modifyResponse>
537            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END].put( new Tag( "modifyResponse", Tag.END ),
538                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP,
539                    null ) );
540    
541            // State: [LDAP_RESULT_REFERRAL_END] - Tag: </modDNResponse>
542            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END].put( new Tag( "modDNResponse", Tag.END ),
543                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP,
544                    null ) );
545    
546            // State: [LDAP_RESULT_REFERRAL_END] - Tag: </searchResultDone>
547            super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END].put( new Tag( "searchResultDone", Tag.END ),
548                new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, Dsmlv2StatesEnum.SEARCH_RESULT_DONE_END,
549                    null ) );
550    
551            //====================================================
552            //  Transitions concerning : SEARCH RESPONSE
553            //====================================================
554            super.transitions[Dsmlv2StatesEnum.SEARCH_RESPONSE] = new HashMap<Tag, GrammarTransition>();
555    
556            // State: [SEARCH_REPONSE] - Tag: <searchResultEntry>
557            super.transitions[Dsmlv2StatesEnum.SEARCH_RESPONSE].put( new Tag( "searchResultEntry", Tag.START ),
558                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESPONSE, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY,
559                    searchResultEntryCreation ) );
560    
561            // State: [SEARCH_REPONSE] - Tag: <searchResultReference>
562            super.transitions[Dsmlv2StatesEnum.SEARCH_RESPONSE].put( new Tag( "searchResultReference", Tag.START ),
563                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESPONSE, Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE,
564                    searchResultReferenceCreation ) );
565    
566            // State: [SEARCH_REPONSE] - Tag: <searchResultDone>
567            super.transitions[Dsmlv2StatesEnum.SEARCH_RESPONSE].put( new Tag( "searchResultDone", Tag.START ),
568                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESPONSE, Dsmlv2StatesEnum.LDAP_RESULT,
569                    searchResultDoneCreation ) );
570    
571            //====================================================
572            //  Transitions concerning : SEARCH RESULT ENTRY
573            //====================================================
574            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY] = new HashMap<Tag, GrammarTransition>();
575            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_START] = new HashMap<Tag, GrammarTransition>();
576            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_END] = new HashMap<Tag, GrammarTransition>();
577            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_VALUE_END] = new HashMap<Tag, GrammarTransition>();
578            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_START] = new HashMap<Tag, GrammarTransition>();
579            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_END] = new HashMap<Tag, GrammarTransition>();
580            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_VALUE_END] = new HashMap<Tag, GrammarTransition>();
581    
582            // State: [SEARCH_RESULT_ENTRY] - Tag: <control>
583            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY].put( new Tag( "control", Tag.START ),
584                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY,
585                    Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_START, searchResultEntryControlCreation ) );
586    
587            // State: [SEARCH_RESULT_ENTRY] - Tag: <attr>
588            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY].put( new Tag( "attr", Tag.START ),
589                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY,
590                    Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_START, searchResultEntryAddAttr ) );
591    
592            // State: [SEARCH_RESULT_ENTRY] - Tag: </searchResultEntry>
593            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY].put( new Tag( "searchResultEntry", Tag.END ),
594                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP,
595                    null ) );
596    
597            // State: [SEARCH_RESULT_ENTRY_CONTROL_START] - Tag: <controlValue>
598            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_START].put(
599                new Tag( "controlValue", Tag.START ), new GrammarTransition(
600                    Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_START,
601                    Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_VALUE_END, searchResultEntryControlValueCreation ) );
602    
603            // State: [SEARCH_RESULT_ENTRY_CONTROL_VALUE_END] - Tag: </control>
604            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_VALUE_END].put( new Tag( "control", Tag.END ),
605                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_VALUE_END,
606                    Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_END, null ) );
607    
608            // State: [SEARCH_RESULT_ENTRY_CONTROL_START] - Tag: </control>
609            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_START].put( new Tag( "control", Tag.END ),
610                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_START,
611                    Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_END, null ) );
612    
613            // State: [SEARCH_RESULT_ENTRY_CONTROL_END] - Tag: <control>
614            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_END].put( new Tag( "control", Tag.START ),
615                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_END,
616                    Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_START, searchResultEntryControlCreation ) );
617    
618            // State: [SEARCH_RESULT_ENTRY_CONTROL_END] - Tag: </searchResultEntry>
619            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_END].put(
620                new Tag( "searchResultEntry", Tag.END ), new GrammarTransition(
621                    Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_END, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP, null ) );
622    
623            // State: [SEARCH_RESULT_ENTRY_CONTROL_END] - Tag: <attr>
624            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_END].put( new Tag( "attr", Tag.START ),
625                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_END,
626                    Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_START, null ) );
627    
628            // State: [SEARCH_RESULT_ENTRY_ATTR_START] - Tag: </attr>
629            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_START].put( new Tag( "attr", Tag.END ),
630                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_START,
631                    Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_END, null ) );
632    
633            // State: [SEARCH_RESULT_ENTRY_ATTR_START] - Tag: <value>
634            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_START].put( new Tag( "value", Tag.START ),
635                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_START,
636                    Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_VALUE_END, searchResultEntryAddValue ) );
637    
638            // State: [SEARCH_RESULT_ENTRY_ATTR_END] - Tag: <attr>
639            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_END].put( new Tag( "attr", Tag.START ),
640                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_END,
641                    Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_START, searchResultEntryAddAttr ) );
642    
643            // State: [SEARCH_RESULT_ENTRY_ATTR_END] - Tag: </searchResultEntry>
644            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_END].put( new Tag( "searchResultEntry", Tag.END ),
645                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_END,
646                    Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP, null ) );
647    
648            // State: [SEARCH_RESULT_ENTRY_VALUE_END] - Tag: <value>
649            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_VALUE_END].put( new Tag( "value", Tag.START ),
650                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_VALUE_END,
651                    Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_VALUE_END, searchResultEntryAddValue ) );
652    
653            // State: [SEARCH_RESULT_ENTRY_VALUE_END] - Tag: </attr>
654            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_VALUE_END].put( new Tag( "attr", Tag.END ),
655                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_VALUE_END,
656                    Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_END, null ) );
657    
658            //====================================================
659            //  Transitions concerning : SEARCH RESULT ENTRY LOOP
660            //====================================================
661            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP] = new HashMap<Tag, GrammarTransition>();
662    
663            // State: [SEARCH_RESULT_ENTRY_LOOP] - Tag: <searchResultEntry>
664            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP].put( new Tag( "searchResultEntry", Tag.START ),
665                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY,
666                    searchResultEntryCreation ) );
667    
668            // State: [SEARCH_RESULT_ENTRY_LOOP] - Tag: <searchResultReference>
669            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP].put(
670                new Tag( "searchResultReference", Tag.START ), new GrammarTransition(
671                    Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP, Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE,
672                    searchResultReferenceCreation ) );
673    
674            // State: [SEARCH_RESULT_ENTRY_LOOP] - Tag: <searchResultDone>
675            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP].put( new Tag( "searchResultDone", Tag.START ),
676                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP, Dsmlv2StatesEnum.LDAP_RESULT,
677                    searchResultDoneCreation ) );
678    
679            //====================================================
680            //  Transitions concerning : SEARCH RESULT REFERENCE
681            //====================================================
682            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE] = new HashMap<Tag, GrammarTransition>();
683            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_START] = new HashMap<Tag, GrammarTransition>();
684            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_END] = new HashMap<Tag, GrammarTransition>();
685            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_VALUE_END] = new HashMap<Tag, GrammarTransition>();
686            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_END] = new HashMap<Tag, GrammarTransition>();
687    
688            // State: [SEARCH_RESULT_REFERENCE] - Tag: <control>
689            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE].put( new Tag( "control", Tag.START ),
690                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE,
691                    Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_START, searchResultReferenceControlCreation ) );
692    
693            // State: [SEARCH_RESULT_REFERENCE] - Tag: <ref>
694            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE].put( new Tag( "ref", Tag.START ),
695                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE,
696                    Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_END, searchResultReferenceAddRef ) );
697    
698            // State: [SEARCH_RESULT_REFERENCE_CONTROL_START] - Tag: <controlValue>
699            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_START].put( new Tag( "controlValue",
700                Tag.START ), new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_START,
701                Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_VALUE_END, searchResultReferenceControlValueCreation ) );
702    
703            // State: [sEARCH_RESULT_REFERENCE_CONTROL_VALUE_END] - Tag: </control>
704            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_VALUE_END].put(
705                new Tag( "control", Tag.END ), new GrammarTransition(
706                    Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_VALUE_END,
707                    Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_END, null ) );
708    
709            // State: [SEARCH_RESULT_REFERENCE_CONTROL_START] - Tag: </control>
710            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_START].put( new Tag( "control", Tag.END ),
711                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_START,
712                    Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_END, null ) );
713    
714            // State: [SEARCH_RESULT_REFERENCE_CONTROL_END] - Tag: <control>
715            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_END].put( new Tag( "control", Tag.START ),
716                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_END,
717                    Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_START, searchResultReferenceControlCreation ) );
718    
719            // State: [SEARCH_RESULT_REFERENCE_CONTROL_END] - Tag: <ref>
720            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_END].put( new Tag( "ref", Tag.START ),
721                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_END,
722                    Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_END, searchResultReferenceAddRef ) );
723    
724            // State: [SEARCH_RESULT_REFERENCE_REF_END] - Tag: <ref>
725            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_END].put( new Tag( "ref", Tag.START ),
726                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_END,
727                    Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_END, searchResultReferenceAddRef ) );
728    
729            // State: [SEARCH_RESULT_REFERENCE_REF_END] - Tag: </searchResultReference>
730            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_END].put( new Tag( "searchResultReference",
731                Tag.END ), new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_END,
732                Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_LOOP, null ) );
733    
734            //==========================================================
735            //  Transitions concerning : SEARCH RESULT REFERENCE LOOP
736            //==========================================================
737            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_LOOP] = new HashMap<Tag, GrammarTransition>();
738    
739            // State: [SEARCH_RESULT_REFERENCE_LOOP] - Tag: <searchResultReference>
740            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_LOOP].put( new Tag( "searchResultReference",
741                Tag.START ), new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_LOOP,
742                Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE, searchResultReferenceCreation ) );
743    
744            // State: [SEARCH_RESULT_REFERENCE_LOOP] - Tag: <searchResultDone>
745            super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_LOOP].put( new Tag( "searchResultDone", Tag.START ),
746                new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_LOOP, Dsmlv2StatesEnum.LDAP_RESULT,
747                    searchResultDoneCreation ) );
748        }
749    
750        /**
751         * GrammarAction that creates the Batch Response
752         */
753        private final GrammarAction batchResponseCreation = new GrammarAction( "Create Batch Response" )
754        {
755            public void action( Dsmlv2Container container ) throws XmlPullParserException
756            {
757                BatchResponse batchResponse = new BatchResponse();
758    
759                container.setBatchResponse( batchResponse );
760    
761                XmlPullParser xpp = container.getParser();
762    
763                // Checking and adding the batchRequest's attributes
764                String attributeValue;
765                // requestID
766                attributeValue = xpp.getAttributeValue( "", "requestID" );
767                if ( attributeValue != null )
768                {
769                    batchResponse.setRequestID( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) );
770                }
771            }
772        };
773    
774        /**
775         * GrammarAction that creates the Add Response
776         */
777        private final GrammarAction addResponseCreation = new GrammarAction( "Create Add Response" )
778        {
779            public void action( Dsmlv2Container container ) throws XmlPullParserException
780            {
781                AddResponseCodec addResponse = new AddResponseCodec();
782    
783                container.getBatchResponse().addResponse( addResponse );
784    
785                LdapResultCodec ldapResult = new LdapResultCodec();
786    
787                addResponse.setLdapResult( ldapResult );
788    
789                XmlPullParser xpp = container.getParser();
790    
791                // Checking and adding the batchRequest's attributes
792                String attributeValue;
793                // requestID
794                attributeValue = xpp.getAttributeValue( "", "requestID" );
795                if ( attributeValue != null )
796                {
797                    addResponse.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) );
798                }
799                // MatchedDN
800                attributeValue = xpp.getAttributeValue( "", "matchedDN" );
801                if ( attributeValue != null )
802                {
803                    try
804                    {
805                        ldapResult.setMatchedDN( new DN( attributeValue ) );
806                    }
807                    catch ( LdapInvalidDnException e )
808                    {
809                        throw new XmlPullParserException( "" + e.getMessage(), xpp, null );
810                    }
811                }
812            }
813        };
814    
815        /**
816         * GrammarAction that creates the Auth Response
817         */
818        private final GrammarAction authResponseCreation = new GrammarAction( "Create Auth Response" )
819        {
820            public void action( Dsmlv2Container container ) throws XmlPullParserException
821            {
822                BindResponseCodec bindResponse = new BindResponseCodec();
823    
824                container.getBatchResponse().addResponse( bindResponse );
825    
826                LdapResultCodec ldapResult = new LdapResultCodec();
827    
828                bindResponse.setLdapResult( ldapResult );
829    
830                XmlPullParser xpp = container.getParser();
831    
832                // Checking and adding the batchRequest's attributes
833                String attributeValue;
834                // requestID
835                attributeValue = xpp.getAttributeValue( "", "requestID" );
836                if ( attributeValue != null )
837                {
838                    bindResponse.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) );
839                   
840                }
841                // MatchedDN
842                attributeValue = xpp.getAttributeValue( "", "matchedDN" );
843                if ( attributeValue != null )
844                {
845                    try
846                    {
847                        ldapResult.setMatchedDN( new DN( attributeValue ) );
848                    }
849                    catch ( LdapInvalidDnException e )
850                    {
851                        throw new XmlPullParserException( "" + e.getMessage(), xpp, null );
852                    }
853                }
854            }
855        };
856    
857        /**
858         * GrammarAction that creates the Compare Response
859         */
860        private final GrammarAction compareResponseCreation = new GrammarAction( "Create Compare Response" )
861        {
862            public void action( Dsmlv2Container container ) throws XmlPullParserException
863            {
864                CompareResponseCodec compareResponse = new CompareResponseCodec();
865    
866                container.getBatchResponse().addResponse( compareResponse );
867    
868                LdapResultCodec ldapResult = new LdapResultCodec();
869    
870                compareResponse.setLdapResult( ldapResult );
871    
872                XmlPullParser xpp = container.getParser();
873    
874                // Checking and adding the batchRequest's attributes
875                String attributeValue;
876                // requestID
877                attributeValue = xpp.getAttributeValue( "", "requestID" );
878                if ( attributeValue != null )
879                {
880                    compareResponse.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) );
881                }
882                // MatchedDN
883                attributeValue = xpp.getAttributeValue( "", "matchedDN" );
884                if ( attributeValue != null )
885                {
886                    try
887                    {
888                        ldapResult.setMatchedDN( new DN( attributeValue ) );
889                    }
890                    catch ( LdapInvalidDnException e )
891                    {
892                        throw new XmlPullParserException( "" + e.getMessage(), xpp, null );
893                    }
894                }
895            }
896        };
897    
898        /**
899         * GrammarAction that creates the Del Response
900         */
901        private final GrammarAction delResponseCreation = new GrammarAction( "Create Del Response" )
902        {
903            public void action( Dsmlv2Container container ) throws XmlPullParserException
904            {
905                DelResponseCodec delResponse = new DelResponseCodec();
906    
907                container.getBatchResponse().addResponse( delResponse );
908    
909                LdapResultCodec ldapResult = new LdapResultCodec();
910    
911                delResponse.setLdapResult( ldapResult );
912    
913                XmlPullParser xpp = container.getParser();
914    
915                // Checking and adding the batchRequest's attributes
916                String attributeValue;
917                // requestID
918                attributeValue = xpp.getAttributeValue( "", "requestID" );
919                if ( attributeValue != null )
920                {
921                    delResponse.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) );        
922                }
923                // MatchedDN
924                attributeValue = xpp.getAttributeValue( "", "matchedDN" );
925                if ( attributeValue != null )
926                {
927                    try
928                    {
929                        ldapResult.setMatchedDN( new DN( attributeValue ) );
930                    }
931                    catch ( LdapInvalidDnException e )
932                    {
933                        throw new XmlPullParserException( "" + e.getMessage(), xpp, null );
934                    }
935                }
936            }
937        };
938    
939        /**
940         * GrammarAction that creates the Modify Response
941         */
942        private final GrammarAction modifyResponseCreation = new GrammarAction( "Create Modify Response" )
943        {
944            public void action( Dsmlv2Container container ) throws XmlPullParserException
945            {
946                ModifyResponseCodec modifyResponse = new ModifyResponseCodec();
947    
948                container.getBatchResponse().addResponse( modifyResponse );
949    
950                LdapResultCodec ldapResult = new LdapResultCodec();
951    
952                modifyResponse.setLdapResult( ldapResult );
953    
954                XmlPullParser xpp = container.getParser();
955    
956                // Checking and adding the batchRequest's attributes
957                String attributeValue;
958                // requestID
959                attributeValue = xpp.getAttributeValue( "", "requestID" );
960                if ( attributeValue != null )
961                {
962                    modifyResponse.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) );
963                }
964                // MatchedDN
965                attributeValue = xpp.getAttributeValue( "", "matchedDN" );
966                if ( attributeValue != null )
967                {
968                    try
969                    {
970                        ldapResult.setMatchedDN( new DN( attributeValue ) );
971                    }
972                    catch ( LdapInvalidDnException e )
973                    {
974                        throw new XmlPullParserException( "" + e.getMessage(), xpp, null );
975                    }
976                }
977            }
978        };
979    
980        /**
981         * GrammarAction that creates the Mod DN Response
982         */
983        private final GrammarAction modDNResponseCreation = new GrammarAction( "Create Mod DN Response" )
984        {
985            public void action( Dsmlv2Container container ) throws XmlPullParserException
986            {
987                ModifyDNResponseCodec modifyDNResponse = new ModifyDNResponseCodec();
988    
989                container.getBatchResponse().addResponse( modifyDNResponse );
990    
991                LdapResultCodec ldapResult = new LdapResultCodec();
992    
993                modifyDNResponse.setLdapResult( ldapResult );
994    
995                XmlPullParser xpp = container.getParser();
996    
997                // Checking and adding the batchRequest's attributes
998                String attributeValue;
999                // requestID
1000                attributeValue = xpp.getAttributeValue( "", "requestID" );
1001                if ( attributeValue != null )
1002                {
1003                    modifyDNResponse.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) );  
1004                }
1005                // MatchedDN
1006                attributeValue = xpp.getAttributeValue( "", "matchedDN" );
1007                if ( attributeValue != null )
1008                {
1009                    try
1010                    {
1011                        ldapResult.setMatchedDN( new DN( attributeValue ) );
1012                    }
1013                    catch ( LdapInvalidDnException e )
1014                    {
1015                        throw new XmlPullParserException( "" + e.getMessage(), xpp, null );
1016                    }
1017                }
1018            }
1019        };
1020    
1021        /**
1022         * GrammarAction that creates the Extended Response
1023         */
1024        private final GrammarAction extendedResponseCreation = new GrammarAction( "Create Extended Response" )
1025        {
1026            public void action( Dsmlv2Container container ) throws XmlPullParserException
1027            {
1028                ExtendedResponseCodec extendedResponse = new ExtendedResponseCodec();
1029    
1030                container.getBatchResponse().addResponse( extendedResponse );
1031    
1032                LdapResultCodec ldapResult = new LdapResultCodec();
1033    
1034                extendedResponse.setLdapResult( ldapResult );
1035    
1036                XmlPullParser xpp = container.getParser();
1037    
1038                // Checking and adding the batchRequest's attributes
1039                String attributeValue;
1040                // requestID
1041                attributeValue = xpp.getAttributeValue( "", "requestID" );
1042                if ( attributeValue != null )
1043                {
1044                    extendedResponse.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) );
1045                }
1046                // MatchedDN
1047                attributeValue = xpp.getAttributeValue( "", "matchedDN" );
1048                if ( attributeValue != null )
1049                {
1050                    try
1051                    {
1052                        ldapResult.setMatchedDN( new DN( attributeValue ) );
1053                    }
1054                    catch ( LdapInvalidDnException e )
1055                    {
1056                        throw new XmlPullParserException( "" + e.getMessage(), xpp, null );
1057                    }
1058                }
1059            }
1060        };
1061    
1062        /**
1063         * GrammarAction that creates the Error Response
1064         */
1065        private final GrammarAction errorResponseCreation = new GrammarAction( "Create Error Response" )
1066        {
1067            public void action( Dsmlv2Container container ) throws XmlPullParserException
1068            {
1069                ErrorResponse errorResponse = new ErrorResponse();
1070    
1071                container.getBatchResponse().addResponse( errorResponse );
1072    
1073                XmlPullParser xpp = container.getParser();
1074    
1075                // Checking and adding the batchRequest's attributes
1076                String attributeValue;
1077                // requestID
1078                attributeValue = xpp.getAttributeValue( "", "requestID" );
1079                if ( attributeValue != null )
1080                {
1081                    errorResponse.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) );
1082                }
1083                // type
1084                attributeValue = xpp.getAttributeValue( "", "type" );
1085                if ( attributeValue != null )
1086                {
1087                    if ( attributeValue.equals( errorResponse.getTypeDescr( ErrorResponseType.NOT_ATTEMPTED ) ) )
1088                    {
1089                        errorResponse.setType( ErrorResponseType.NOT_ATTEMPTED );
1090                    }
1091                    else if ( attributeValue.equals( errorResponse.getTypeDescr( ErrorResponseType.COULD_NOT_CONNECT ) ) )
1092                    {
1093                        errorResponse.setType( ErrorResponseType.COULD_NOT_CONNECT );
1094                    }
1095                    else if ( attributeValue.equals( errorResponse.getTypeDescr( ErrorResponseType.CONNECTION_CLOSED ) ) )
1096                    {
1097                        errorResponse.setType( ErrorResponseType.CONNECTION_CLOSED );
1098                    }
1099                    else if ( attributeValue.equals( errorResponse.getTypeDescr( ErrorResponseType.MALFORMED_REQUEST ) ) )
1100                    {
1101                        errorResponse.setType( ErrorResponseType.MALFORMED_REQUEST );
1102                    }
1103                    else if ( attributeValue
1104                        .equals( errorResponse.getTypeDescr( ErrorResponseType.GATEWAY_INTERNAL_ERROR ) ) )
1105                    {
1106                        errorResponse.setType( ErrorResponseType.GATEWAY_INTERNAL_ERROR );
1107                    }
1108                    else if ( attributeValue.equals( errorResponse.getTypeDescr( ErrorResponseType.AUTHENTICATION_FAILED ) ) )
1109                    {
1110                        errorResponse.setType( ErrorResponseType.AUTHENTICATION_FAILED );
1111                    }
1112                    else if ( attributeValue.equals( errorResponse.getTypeDescr( ErrorResponseType.UNRESOLVABLE_URI ) ) )
1113                    {
1114                        errorResponse.setType( ErrorResponseType.UNRESOLVABLE_URI );
1115                    }
1116                    else if ( attributeValue.equals( errorResponse.getTypeDescr( ErrorResponseType.OTHER ) ) )
1117                    {
1118                        errorResponse.setType( ErrorResponseType.OTHER );
1119                    }
1120                    else
1121                    {
1122                        throw new XmlPullParserException( I18n.err( I18n.ERR_03004 ), xpp, null );
1123                    }
1124                }
1125                else
1126                {
1127                    throw new XmlPullParserException( I18n.err( I18n.ERR_03005 ), xpp, null );
1128                }
1129            }
1130        };
1131    
1132        /**
1133         * GrammarAction that adds Message to an Error Response
1134         */
1135        private final GrammarAction errorResponseAddMessage = new GrammarAction( "Add Message to Error Response" )
1136        {
1137            public void action( Dsmlv2Container container ) throws XmlPullParserException
1138            {
1139                ErrorResponse errorResponse = ( ErrorResponse ) container.getBatchResponse().getCurrentResponse();
1140                
1141                XmlPullParser xpp = container.getParser();
1142                try
1143                {
1144                    String nextText = xpp.nextText();
1145                    if ( !nextText.equals( "" ) )
1146                    {
1147                        errorResponse.setMessage( nextText.trim() );
1148                    }
1149                }
1150                catch ( IOException e )
1151                {
1152                    throw new XmlPullParserException( e.getMessage(), xpp, null );
1153                }
1154            }
1155        };
1156    
1157        /**
1158         * GrammarAction that adds Detail to an Error Response
1159         */
1160        private final GrammarAction errorResponseAddDetail = null; // TODO Look for documentation about this Detail element (the DSML documentation doesn't give enough information)
1161    
1162    
1163        /**
1164         * Creates a Control parsing the current node and adds it to the given parent 
1165         * @param container the DSMLv2Container
1166         * @param parent the parent 
1167         * @throws XmlPullParserException
1168         */
1169        private void createAndAddControl( Dsmlv2Container container, LdapMessageCodec parent ) throws XmlPullParserException
1170        {
1171            Control control = null;
1172    
1173            XmlPullParser xpp = container.getParser();
1174    
1175            // Checking and adding the Control's attributes
1176            String attributeValue;
1177            // TYPE
1178            attributeValue = xpp.getAttributeValue( "", "type" );
1179            
1180            if ( attributeValue != null )
1181            {
1182                if ( !OID.isOID( attributeValue ) )
1183                {
1184                    throw new XmlPullParserException( I18n.err( I18n.ERR_03006 ), xpp, null );
1185                }
1186                
1187                control = new ControlImpl( attributeValue );
1188                parent.addControl( control );
1189            }
1190            else
1191            {
1192                throw new XmlPullParserException( I18n.err( I18n.ERR_03005 ), xpp, null );
1193            }
1194            // CRITICALITY
1195            attributeValue = xpp.getAttributeValue( "", "criticality" );
1196            
1197            if ( attributeValue != null )
1198            {
1199                if ( attributeValue.equals( "true" ) )
1200                {
1201                    control.setCritical( true );
1202                }
1203                else if ( attributeValue.equals( "false" ) )
1204                {
1205                    control.setCritical( false );
1206                }
1207                else
1208                {
1209                    throw new XmlPullParserException( I18n.err( I18n.ERR_03007 ), xpp, null );
1210                }
1211            }
1212        }
1213    
1214        /**
1215         * GrammarAction that creates a Control for LDAP Result
1216         */
1217        private final GrammarAction ldapResultControlCreation = new GrammarAction( "Create Control for LDAP Result" )
1218        {
1219            public void action( Dsmlv2Container container ) throws XmlPullParserException
1220            {
1221                LdapResponseCodec ldapResponse = container.getBatchResponse().getCurrentResponse();
1222                // Search Response is a special case
1223                if ( ldapResponse instanceof SearchResponse )
1224                {
1225                    ldapResponse = ( ( SearchResponse ) ldapResponse ).getSearchResultDone();
1226                }
1227    
1228                createAndAddControl( container, ldapResponse );
1229            }
1230        };
1231    
1232        /**
1233         * GrammarAction that creates a Control for Search Result Entry
1234         */
1235        private final GrammarAction searchResultEntryControlCreation = new GrammarAction(
1236            "Create Control for Search Result Entry" )
1237        {
1238            public void action( Dsmlv2Container container ) throws XmlPullParserException
1239            {
1240                LdapMessageCodec ldapMessage = ( ( SearchResponse ) container.getBatchResponse().getCurrentResponse() )
1241                    .getCurrentSearchResultEntry();
1242                createAndAddControl( container, ldapMessage );
1243            }
1244        };
1245    
1246        /**
1247         * GrammarAction that creates a Control for Search Result Entry
1248         */
1249        private final GrammarAction searchResultReferenceControlCreation = new GrammarAction(
1250            "Create Control for Search Result Reference" )
1251        {
1252            public void action( Dsmlv2Container container ) throws XmlPullParserException
1253            {
1254                LdapMessageCodec ldapMessage = ( ( SearchResponse ) container.getBatchResponse().getCurrentResponse() )
1255                    .getCurrentSearchResultReference();
1256                createAndAddControl( container, ldapMessage );
1257            }
1258        };
1259    
1260    
1261        /**
1262         * Creates a Control Value parsing the current node and adds it to the given parent 
1263         * @param container the DSMLv2Container
1264         * @param parent the parent 
1265         * @throws XmlPullParserException
1266         */
1267        private void createAndAddControlValue( Dsmlv2Container container, LdapMessageCodec parent )
1268            throws XmlPullParserException
1269        {
1270            Control control = parent.getCurrentControl();
1271    
1272            XmlPullParser xpp = container.getParser();
1273            try
1274            {
1275                // We have to catch the type Attribute Value before going to the next Text node
1276                String typeValue = ParserUtils.getXsiTypeAttributeValue( xpp );
1277                
1278                // Getting the value
1279                String nextText = xpp.nextText();
1280                
1281                if ( !nextText.equals( "" ) )
1282                {
1283                    if ( ParserUtils.isBase64BinaryValue( xpp, typeValue ) )
1284                    {
1285                        control.setValue( Base64.decode( nextText.trim().toCharArray() ) );
1286                    }
1287                    else
1288                    {
1289                        control.setValue( nextText.trim().getBytes() );
1290                    }
1291                }
1292            }
1293            catch ( IOException e )
1294            {
1295                throw new XmlPullParserException( I18n.err( I18n.ERR_03008, e.getMessage() ), xpp, null );
1296            }
1297        }
1298    
1299        /**
1300         * GrammarAction that creates a Control Value for LDAP Result
1301         */
1302        private final GrammarAction ldapResultControlValueCreation = new GrammarAction(
1303            "Add ControlValue to Control for LDAP Result" )
1304        {
1305            public void action( Dsmlv2Container container ) throws XmlPullParserException
1306            {
1307                LdapResponseCodec ldapResponse = container.getBatchResponse().getCurrentResponse();
1308                // Search Response is a special case
1309                if ( ldapResponse instanceof SearchResponse )
1310                {
1311                    ldapResponse = ( ( SearchResponse ) ldapResponse ).getSearchResultDone();
1312                }
1313    
1314                createAndAddControlValue( container, ldapResponse );
1315            }
1316        };
1317    
1318        /**
1319         * GrammarAction that creates a Control Value for Search Result Entry
1320         */
1321        private final GrammarAction searchResultEntryControlValueCreation = new GrammarAction(
1322            "Add ControlValue to Control for Search Result Entry" )
1323        {
1324            public void action( Dsmlv2Container container ) throws XmlPullParserException
1325            {
1326                LdapMessageCodec ldapMessage = ( ( SearchResponse ) container.getBatchResponse().getCurrentResponse() )
1327                    .getCurrentSearchResultEntry();
1328                createAndAddControlValue( container, ldapMessage );
1329            }
1330        };
1331    
1332        /**
1333         * GrammarAction that creates a Control Value for Search Result Reference
1334         */
1335        private final GrammarAction searchResultReferenceControlValueCreation = new GrammarAction(
1336            "Add ControlValue to Control for Search Result Entry" )
1337        {
1338            public void action( Dsmlv2Container container ) throws XmlPullParserException
1339            {
1340                LdapMessageCodec ldapMessage = ( ( SearchResponse ) container.getBatchResponse().getCurrentResponse() )
1341                    .getCurrentSearchResultReference();
1342                createAndAddControlValue( container, ldapMessage );
1343            }
1344        };
1345    
1346        /**
1347         * GrammarAction that adds a Result Code to a LDAP Result
1348         */
1349        private final GrammarAction ldapResultAddResultCode = new GrammarAction( "Add ResultCode to LDAP Result" )
1350        {
1351            public void action( Dsmlv2Container container ) throws XmlPullParserException
1352            {
1353                LdapResponseCodec ldapResponse = container.getBatchResponse().getCurrentResponse();
1354    
1355                LdapResultCodec ldapResult = null;
1356    
1357                // Search Response is a special case
1358                // ResultCode can only occur in a case of Search Result Done in a Search Response
1359                if ( ldapResponse instanceof SearchResponse )
1360                {
1361                    SearchResponse searchResponse = ( SearchResponse ) ldapResponse;
1362                    ldapResult = searchResponse.getSearchResultDone().getLdapResult();
1363                }
1364                else
1365                {
1366                    ldapResult = ldapResponse.getLdapResult();
1367                }
1368    
1369                XmlPullParser xpp = container.getParser();
1370    
1371                // Checking and adding the request's attributes
1372                String attributeValue;
1373                // code
1374                attributeValue = xpp.getAttributeValue( "", "code" );
1375                if ( attributeValue != null )
1376                {
1377                    try
1378                    {
1379                        ldapResult.setResultCode( ResultCodeEnum.getResultCode( Integer.parseInt( attributeValue ) ) );
1380                    }
1381                    catch ( NumberFormatException e )
1382                    {
1383                        throw new XmlPullParserException( I18n.err( I18n.ERR_03009 ), xpp, null );
1384                    }
1385                }
1386                else
1387                {
1388                    throw new XmlPullParserException( I18n.err( I18n.ERR_03010 ), xpp, null );
1389                }
1390                // descr
1391                attributeValue = xpp.getAttributeValue( "", "descr" );
1392                if ( attributeValue != null )
1393                {
1394                    if ( DSMLV2_DESCR_TAGS.contains( attributeValue ) == false )
1395                    {
1396                        throw new XmlPullParserException( I18n.err( I18n.ERR_03011, attributeValue ), xpp, null );
1397                    }
1398    
1399                }
1400            }
1401        };
1402    
1403        /**
1404         * GrammarAction that adds a Error Message to a LDAP Result
1405         */
1406        private final GrammarAction ldapResultAddErrorMessage = new GrammarAction( "Add Error Message to LDAP Result" )
1407        {
1408            public void action( Dsmlv2Container container ) throws XmlPullParserException
1409            {
1410                LdapResponseCodec ldapResponse = container.getBatchResponse().getCurrentResponse();
1411    
1412                LdapResultCodec ldapResult = null;
1413    
1414                // Search Response is a special case
1415                // ResultCode can only occur in a case of Search Result Done in a Search Response
1416                if ( ldapResponse instanceof SearchResponse )
1417                {
1418                    SearchResponse searchResponse = ( SearchResponse ) ldapResponse;
1419                    ldapResult = searchResponse.getSearchResultDone().getLdapResult();
1420                }
1421                else
1422                {
1423                    ldapResult = ldapResponse.getLdapResult();
1424                }
1425    
1426                XmlPullParser xpp = container.getParser();
1427                try
1428                {
1429                    String nextText = xpp.nextText();
1430                    if ( !nextText.equals( "" ) )
1431                    {
1432                        ldapResult.setErrorMessage( nextText.trim() );
1433                    }
1434                }
1435                catch ( IOException e )
1436                {
1437                    throw new XmlPullParserException( I18n.err( I18n.ERR_03008, e.getMessage() ), xpp, null );
1438                }
1439            }
1440        };
1441    
1442        /**
1443         * GrammarAction that adds a Referral to a LDAP Result
1444         */
1445        private final GrammarAction ldapResultAddReferral = new GrammarAction( "Add Referral to LDAP Result" )
1446        {
1447            public void action( Dsmlv2Container container ) throws XmlPullParserException
1448            {
1449                LdapResponseCodec ldapResponse = container.getBatchResponse().getCurrentResponse();
1450    
1451                LdapResultCodec ldapResult = null;
1452    
1453                // Search Response is a special case
1454                // ResultCode can only occur in a case of Search Result Done in a Search Response
1455                if ( ldapResponse instanceof SearchResponse )
1456                {
1457                    SearchResponse searchResponse = ( SearchResponse ) ldapResponse;
1458                    ldapResult = searchResponse.getSearchResultDone().getLdapResult();
1459                }
1460                else
1461                {
1462                    ldapResult = ldapResponse.getLdapResult();
1463                }
1464    
1465                // Initialization of the Referrals if needed
1466                if ( ldapResult.getReferrals() == null )
1467                {
1468                    ldapResult.initReferrals();
1469                }
1470    
1471                XmlPullParser xpp = container.getParser();
1472                try
1473                {
1474                    String nextText = xpp.nextText();
1475                    if ( !nextText.equals( "" ) )
1476                    {
1477                        try
1478                        {
1479                            ldapResult.addReferral( new LdapURL( nextText.trim() ) );
1480                        }
1481                        catch ( LdapURLEncodingException e )
1482                        {
1483                            throw new XmlPullParserException( e.getMessage(), xpp, null );
1484                        }
1485                    }
1486                }
1487                catch ( IOException e )
1488                {
1489                    throw new XmlPullParserException( I18n.err( I18n.ERR_03008, e.getMessage() ), xpp, null );
1490                }
1491            }
1492        };
1493    
1494        /**
1495         * GrammarAction that creates the Search Response
1496         */
1497        private final GrammarAction searchResponseCreation = new GrammarAction( "Create Search Response" )
1498        {
1499            public void action( Dsmlv2Container container ) throws XmlPullParserException
1500            {
1501                SearchResponse searchResponse = new SearchResponse();
1502    
1503                container.getBatchResponse().addResponse( searchResponse );
1504    
1505                XmlPullParser xpp = container.getParser();
1506    
1507                // Checking and adding the batchRequest's attributes
1508                String attributeValue;
1509                // requestID
1510                attributeValue = xpp.getAttributeValue( "", "requestID" );
1511                if ( attributeValue != null )
1512                {
1513                    searchResponse.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) );
1514                }
1515            }
1516        };
1517    
1518        /**
1519         * GrammarAction that creates a Search Result Entry
1520         */
1521        private final GrammarAction searchResultEntryCreation = new GrammarAction(
1522            "Add Search Result Entry to Search Response" )
1523        {
1524            public void action( Dsmlv2Container container ) throws XmlPullParserException
1525            {
1526                SearchResultEntryCodec searchResultEntry = new SearchResultEntryCodec();
1527    
1528                SearchResponse searchResponse = ( SearchResponse ) container.getBatchResponse().getCurrentResponse();
1529    
1530                searchResponse.addSearchResultEntry( searchResultEntry );
1531    
1532                XmlPullParser xpp = container.getParser();
1533    
1534                // Checking and adding the request's attributes
1535                String attributeValue;
1536                // requestID
1537                attributeValue = xpp.getAttributeValue( "", "requestID" );
1538                if ( attributeValue != null )
1539                {
1540                    searchResultEntry.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) );
1541                }
1542                // dn
1543                attributeValue = xpp.getAttributeValue( "", "dn" );
1544                if ( attributeValue != null )
1545                {
1546                    try
1547                    {
1548                        searchResultEntry.setObjectName( new DN( attributeValue ) );
1549                    }
1550                    catch ( LdapInvalidDnException e )
1551                    {
1552                        throw new XmlPullParserException( e.getMessage(), xpp, null );
1553                    }
1554                }
1555                else
1556                {
1557                    throw new XmlPullParserException( "dn attribute is required", xpp, null );
1558                }
1559            }
1560        };
1561    
1562        /**
1563         * GrammarAction that creates a Search Result Reference
1564         */
1565        private final GrammarAction searchResultReferenceCreation = new GrammarAction(
1566            "Add Search Result Reference to Search Response" )
1567        {
1568            public void action( Dsmlv2Container container ) throws XmlPullParserException
1569            {
1570                SearchResultReferenceCodec searchResultReference = new SearchResultReferenceCodec();
1571    
1572                SearchResponse searchResponse = ( SearchResponse ) container.getBatchResponse().getCurrentResponse();
1573    
1574                searchResponse.addSearchResultReference( searchResultReference );
1575    
1576                XmlPullParser xpp = container.getParser();
1577    
1578                // Checking and adding the request's attributes
1579                String attributeValue;
1580                // requestID
1581                attributeValue = xpp.getAttributeValue( "", "requestID" );
1582                if ( attributeValue != null )
1583                {
1584                    searchResultReference.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) );
1585                }
1586            }
1587        };
1588    
1589        /**
1590         * GrammarAction that creates a Search Result Done
1591         */
1592        private final GrammarAction searchResultDoneCreation = new GrammarAction(
1593            "Add Search Result Done to Search Response" )
1594        {
1595            public void action( Dsmlv2Container container ) throws XmlPullParserException
1596            {
1597                SearchResultDoneCodec searchResultDone = new SearchResultDoneCodec();
1598    
1599                searchResultDone.setLdapResult( new LdapResultCodec() );
1600    
1601                SearchResponse searchResponse = ( SearchResponse ) container.getBatchResponse().getCurrentResponse();
1602    
1603                searchResponse.setSearchResultDone( searchResultDone );
1604    
1605                XmlPullParser xpp = container.getParser();
1606    
1607                // Checking and adding the batchRequest's attributes
1608                String attributeValue;
1609                // requestID
1610                attributeValue = xpp.getAttributeValue( "", "requestID" );
1611                if ( attributeValue != null )
1612                {
1613                    searchResultDone.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) );
1614                }
1615                // MatchedDN
1616                attributeValue = xpp.getAttributeValue( "", "matchedDN" );
1617                if ( attributeValue != null )
1618                {
1619                    try
1620                    {
1621                        searchResultDone.getLdapResult().setMatchedDN( new DN( attributeValue ) );
1622                    }
1623                    catch ( LdapInvalidDnException e )
1624                    {
1625                        throw new XmlPullParserException( "" + e.getMessage(), xpp, null );
1626                    }
1627                }
1628            }
1629        };
1630    
1631        /**
1632         * GrammarAction that adds an Attr to a Search Result Entry
1633         */
1634        private final GrammarAction searchResultEntryAddAttr = new GrammarAction( "Add Attr to Search Result Entry" )
1635        {
1636            public void action( Dsmlv2Container container ) throws XmlPullParserException
1637            {
1638                SearchResponse searchResponse = ( SearchResponse ) container.getBatchResponse().getCurrentResponse();
1639    
1640                SearchResultEntryCodec searchResultEntry = searchResponse.getCurrentSearchResultEntry();
1641    
1642                XmlPullParser xpp = container.getParser();
1643    
1644                // Checking and adding the request's attributes
1645                String attributeValue;
1646                // name
1647                attributeValue = xpp.getAttributeValue( "", "name" );
1648                if ( attributeValue != null )
1649                {
1650                    searchResultEntry.addAttributeValues( attributeValue );
1651                }
1652                else
1653                {
1654                    throw new XmlPullParserException( I18n.err( I18n.ERR_03012 ), xpp, null );
1655                }
1656            }
1657        };
1658    
1659        /**
1660         * GrammarAction that adds a Value to an Attr of a Search Result Entry
1661         */
1662        private final GrammarAction searchResultEntryAddValue = new GrammarAction(
1663            "Add a Value to an Attr of a Search Result Entry" )
1664        {
1665            public void action( Dsmlv2Container container ) throws XmlPullParserException
1666            {
1667                SearchResponse searchResponse = ( SearchResponse ) container.getBatchResponse().getCurrentResponse();
1668                SearchResultEntryCodec searchResultEntry = searchResponse.getCurrentSearchResultEntry();
1669    
1670                XmlPullParser xpp = container.getParser();
1671                try
1672                {
1673                    // We have to catch the type Attribute Value before going to the next Text node
1674                    String typeValue = ParserUtils.getXsiTypeAttributeValue( xpp );
1675                    
1676                    // Getting the value
1677                    String nextText = xpp.nextText();
1678                    if ( ParserUtils.isBase64BinaryValue( xpp, typeValue ) )
1679                    {
1680                        searchResultEntry.addAttributeValue( Base64.decode( nextText.toCharArray() ) );
1681                    }
1682                    else
1683                    {
1684                        searchResultEntry.addAttributeValue( nextText );
1685                    }
1686                }
1687                catch ( IOException e )
1688                {
1689                    throw new XmlPullParserException( I18n.err( I18n.ERR_03008, e.getMessage() ), xpp, null );
1690                }
1691            }
1692        };
1693    
1694        /**
1695         * GrammarAction that adds a Ref to a Search Result Reference
1696         */
1697        private final GrammarAction searchResultReferenceAddRef = new GrammarAction(
1698            "Add a Ref to a Search Result Reference" )
1699        {
1700            public void action( Dsmlv2Container container ) throws XmlPullParserException
1701            {
1702                SearchResponse searchResponse = ( SearchResponse ) container.getBatchResponse().getCurrentResponse();
1703                SearchResultReferenceCodec searchResultReference = searchResponse.getCurrentSearchResultReference();
1704    
1705                XmlPullParser xpp = container.getParser();
1706                try
1707                {
1708                    String nextText = xpp.nextText();
1709                    if ( !nextText.equals( "" ) )
1710                    {
1711                        searchResultReference.addSearchResultReference( new LdapURL( nextText ) );
1712                    }
1713                }
1714                catch ( IOException e )
1715                {
1716                    throw new XmlPullParserException( I18n.err( I18n.ERR_03008, e.getMessage() ), xpp, null );
1717                }
1718                catch ( LdapURLEncodingException e )
1719                {
1720                    throw new XmlPullParserException( e.getMessage(), xpp, null );
1721                }
1722            }
1723        };
1724    
1725        /**
1726         * GrammarAction that adds Result Code to an Extended Response
1727         */
1728        private final GrammarAction extendedResponseAddResultCode = ldapResultAddResultCode;
1729    
1730        /**
1731         * GrammarAction that creates the Search Response
1732         */
1733        private final GrammarAction extendedResponseAddErrorMessage = ldapResultAddErrorMessage;
1734    
1735        /**
1736         * GrammarAction that adds a Referral to an Extended Response
1737         */
1738        private final GrammarAction extendedResponseAddReferral = ldapResultAddReferral;
1739    
1740        /**
1741         * GrammarAction that adds a Response Name to an Extended Response
1742         */
1743        private final GrammarAction extendedResponseAddResponseName = new GrammarAction(
1744            "Add Response Name to Extended Response" )
1745        {
1746            public void action( Dsmlv2Container container ) throws XmlPullParserException
1747            {
1748                ExtendedResponseCodec extendedResponse = ( ExtendedResponseCodec ) container.getBatchResponse().getCurrentResponse();
1749    
1750                XmlPullParser xpp = container.getParser();
1751                try
1752                {
1753                    String nextText = xpp.nextText();
1754                    if ( !nextText.equals( "" ) )
1755                    {
1756                        extendedResponse.setResponseName( new OID( nextText.trim() ) );
1757                    }
1758                    
1759                }
1760                catch ( IOException e )
1761                {
1762                    throw new XmlPullParserException( I18n.err( I18n.ERR_03008, e.getMessage() ), xpp, null );
1763                }
1764                catch ( DecoderException e )
1765                {
1766                    throw new XmlPullParserException( e.getMessage(), xpp, null );
1767                }
1768            }
1769        };
1770    
1771        /**
1772         * GrammarAction that adds a Response to an Extended Response
1773         */
1774        private final GrammarAction extendedResponseAddResponse = new GrammarAction( "Add Response to Extended Response" )
1775        {
1776            public void action( Dsmlv2Container container ) throws XmlPullParserException
1777            {
1778                ExtendedResponseCodec extendedResponse = ( ExtendedResponseCodec ) container.getBatchResponse().getCurrentResponse();
1779    
1780                XmlPullParser xpp = container.getParser();
1781                try
1782                {
1783                    // We have to catch the type Attribute Value before going to the next Text node
1784                    String typeValue = ParserUtils.getXsiTypeAttributeValue( xpp );
1785                    
1786                    // Getting the value
1787                    String nextText = xpp.nextText();
1788                    if ( ParserUtils.isBase64BinaryValue( xpp, typeValue ) )
1789                    {
1790                        extendedResponse.setResponse( Base64.decode( nextText.trim().toCharArray() ) );
1791                    }
1792                    else
1793                    {
1794                        extendedResponse.setResponse( nextText.trim() );
1795                    }
1796                }
1797                catch ( IOException e )
1798                {
1799                    throw new XmlPullParserException( I18n.err( I18n.ERR_03008, e.getMessage() ), xpp, null );
1800                }
1801            }
1802        };
1803    
1804    
1805        /**
1806         * Get the instance of this grammar
1807         * 
1808         * @return
1809         *      an instance on this grammar
1810         */
1811        public static Dsmlv2ResponseGrammar getInstance()
1812        {
1813            return instance;
1814        }
1815    }