directory-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pamarce...@apache.org
Subject svn commit: r475805 [5/17] - in /directory/sandbox/pamarcelot/ldapstudio/ldapstudio-dsml-parser: ./ META-INF/ src/ src/main/ src/main/java/ src/main/java/org/ src/main/java/org/apache/ src/main/java/org/apache/directory/ src/main/java/org/apache/direct...
Date Thu, 16 Nov 2006 16:38:51 GMT
Added: directory/sandbox/pamarcelot/ldapstudio/ldapstudio-dsml-parser/src/main/java/org/apache/directory/ldapstudio/dsmlv2/Dsmlv2ResponseGrammar.java
URL: http://svn.apache.org/viewvc/directory/sandbox/pamarcelot/ldapstudio/ldapstudio-dsml-parser/src/main/java/org/apache/directory/ldapstudio/dsmlv2/Dsmlv2ResponseGrammar.java?view=auto&rev=475805
==============================================================================
--- directory/sandbox/pamarcelot/ldapstudio/ldapstudio-dsml-parser/src/main/java/org/apache/directory/ldapstudio/dsmlv2/Dsmlv2ResponseGrammar.java (added)
+++ directory/sandbox/pamarcelot/ldapstudio/ldapstudio-dsml-parser/src/main/java/org/apache/directory/ldapstudio/dsmlv2/Dsmlv2ResponseGrammar.java Thu Nov 16 08:38:31 2006
@@ -0,0 +1,1863 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *  
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *  
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License. 
+ *  
+ */
+
+package org.apache.directory.ldapstudio.dsmlv2;
+
+import java.io.IOException;
+import java.lang.reflect.Array;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.naming.InvalidNameException;
+
+import org.apache.directory.ldapstudio.dsmlv2.reponse.ErrorResponse;
+import org.apache.directory.ldapstudio.dsmlv2.reponse.SearchResponse;
+import org.apache.directory.ldapstudio.dsmlv2.reponse.ErrorResponse.ErrorResponseType;
+import org.apache.directory.shared.asn1.codec.DecoderException;
+import org.apache.directory.shared.asn1.primitives.OID;
+import org.apache.directory.shared.ldap.codec.Control;
+import org.apache.directory.shared.ldap.codec.LdapMessage;
+import org.apache.directory.shared.ldap.codec.LdapResponse;
+import org.apache.directory.shared.ldap.codec.LdapResult;
+import org.apache.directory.shared.ldap.codec.add.AddResponse;
+import org.apache.directory.shared.ldap.codec.bind.BindResponse;
+import org.apache.directory.shared.ldap.codec.compare.CompareResponse;
+import org.apache.directory.shared.ldap.codec.del.DelResponse;
+import org.apache.directory.shared.ldap.codec.extended.ExtendedResponse;
+import org.apache.directory.shared.ldap.codec.modify.ModifyResponse;
+import org.apache.directory.shared.ldap.codec.modifyDn.ModifyDNResponse;
+import org.apache.directory.shared.ldap.codec.search.SearchResultDone;
+import org.apache.directory.shared.ldap.codec.search.SearchResultEntry;
+import org.apache.directory.shared.ldap.codec.search.SearchResultReference;
+import org.apache.directory.shared.ldap.codec.util.LdapURL;
+import org.apache.directory.shared.ldap.codec.util.LdapURLEncodingException;
+import org.apache.directory.shared.ldap.name.LdapDN;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+/**
+ * This Class represents the DSMLv2 Response Grammar
+ */
+public class Dsmlv2ResponseGrammar extends AbstractGrammar implements IGrammar
+{
+	/** The instance of grammar. Dsmlv2ResponseGrammar is a singleton */
+    private static Dsmlv2ResponseGrammar instance = new Dsmlv2ResponseGrammar();
+    
+    private static Set<String> DSMLV2_DESCR_TAGS = null; 
+    
+    static
+    {
+    	// Initializing DESCR_TAGS
+    	DSMLV2_DESCR_TAGS = new HashSet<String>();
+    	DSMLV2_DESCR_TAGS.add( "success");
+    	DSMLV2_DESCR_TAGS.add( "operationsError" );
+	    DSMLV2_DESCR_TAGS.add( "protocolError" );
+	    DSMLV2_DESCR_TAGS.add( "timeLimitExceeded" );
+	    DSMLV2_DESCR_TAGS.add( "sizeLimitExceeded" );
+	    DSMLV2_DESCR_TAGS.add( "compareFalse" );
+        DSMLV2_DESCR_TAGS.add( "compareTrue" );
+	    DSMLV2_DESCR_TAGS.add( "authMethodNotSupported" );
+        DSMLV2_DESCR_TAGS.add( "strongAuthRequired" );
+	    DSMLV2_DESCR_TAGS.add( "referral" );
+        DSMLV2_DESCR_TAGS.add( "adminLimitExceeded" );
+	    DSMLV2_DESCR_TAGS.add( "unavailableCriticalExtension" );
+        DSMLV2_DESCR_TAGS.add( "confidentialityRequired" );
+	    DSMLV2_DESCR_TAGS.add( "saslBindInProgress" );
+        DSMLV2_DESCR_TAGS.add( "noSuchAttribute" );
+	    DSMLV2_DESCR_TAGS.add( "undefinedAttributeType" );
+        DSMLV2_DESCR_TAGS.add( "inappropriateMatching" );
+	    DSMLV2_DESCR_TAGS.add( "constraintViolation" );
+        DSMLV2_DESCR_TAGS.add( "attributeOrValueExists" );
+	    DSMLV2_DESCR_TAGS.add( "invalidAttributeSyntax" );
+        DSMLV2_DESCR_TAGS.add( "noSuchObject" );
+	    DSMLV2_DESCR_TAGS.add( "aliasProblem" );
+        DSMLV2_DESCR_TAGS.add( "invalidDNSyntax" );
+        DSMLV2_DESCR_TAGS.add( "aliasDereferencingProblem" );
+        DSMLV2_DESCR_TAGS.add( "inappropriateAuthentication" );
+        DSMLV2_DESCR_TAGS.add( "invalidCredentials" );
+        DSMLV2_DESCR_TAGS.add( "insufficientAccessRights" );
+        DSMLV2_DESCR_TAGS.add( "busy" );
+        DSMLV2_DESCR_TAGS.add( "unavailable" );
+        DSMLV2_DESCR_TAGS.add( "unwillingToPerform" );
+        DSMLV2_DESCR_TAGS.add( "loopDetect" );
+        DSMLV2_DESCR_TAGS.add( "namingViolation" );
+        DSMLV2_DESCR_TAGS.add( "objectClassViolation" );
+        DSMLV2_DESCR_TAGS.add( "notAllowedOnNonLeaf" );
+        DSMLV2_DESCR_TAGS.add( "notAllowedOnRDN" );
+        DSMLV2_DESCR_TAGS.add( "entryAlreadyExists" );
+        DSMLV2_DESCR_TAGS.add( "objectClassModsProhibited" );
+        DSMLV2_DESCR_TAGS.add( "affectMultipleDSAs" );
+        DSMLV2_DESCR_TAGS.add( "other" );
+    	
+    }
+    
+    @SuppressWarnings("unchecked")
+    private Dsmlv2ResponseGrammar()
+    {
+        name = Dsmlv2ResponseGrammar.class.getName();
+        statesEnum = Dsmlv2StatesEnum.getInstance();
+        
+        // Create the transitions table
+        super.transitions =  (HashMap<Tag, GrammarTransition>[]) Array.newInstance( HashMap.class, 300 );; // TODO Change this value
+        
+        //====================================================
+        //  Transitions concerning : BATCH RESPONSE
+        //====================================================
+        super.transitions[Dsmlv2StatesEnum.INIT_GRAMMAR_STATE] = new HashMap<Tag, GrammarTransition>();
+        
+        // ** OPEN BATCH Reponse **
+        // State: [INIT_GRAMMAR_STATE] - Tag: <batchResponse>
+        super.transitions[Dsmlv2StatesEnum.INIT_GRAMMAR_STATE].put( new Tag( "batchResponse", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.INIT_GRAMMAR_STATE, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, batchResponseCreation ));
+        
+        
+        //====================================================
+        //  Transitions concerning : BATCH RESPONSE LOOP
+        //====================================================
+        super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP] = new HashMap<Tag, GrammarTransition>();
+        
+        // State: [BATCH_RESPONSE_LOOP] - Tag: <addResponse>
+        super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "addResponse", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.LDAP_RESULT, addResponseCreation ));
+        
+        // State: [BATCH_RESPONSE_LOOP] - Tag: <authResponse>
+        super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "authResponse", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.LDAP_RESULT, authResponseCreation ));
+        
+        // State: [BATCH_RESPONSE_LOOP] - Tag: <compareResponse>
+        super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "compareResponse", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.LDAP_RESULT, compareResponseCreation ));
+        
+        // State: [BATCH_RESPONSE_LOOP] - Tag: <delResponse>
+        super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "delResponse", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.LDAP_RESULT, delResponseCreation ));
+       
+        // State: [BATCH_RESPONSE_LOOP] - Tag: <modifyResponse>
+        super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "modifyResponse", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.LDAP_RESULT, modifyResponseCreation ));
+        
+        // State: [BATCH_RESPONSE_LOOP] - Tag: <modDNResponse>
+        super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "modDNResponse", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.LDAP_RESULT, modDNResponseCreation ));
+        
+        // State: [BATCH_RESPONSE_LOOP] - Tag: <extendedResponse>
+        super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "extendedResponse", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.EXTENDED_RESPONSE, extendedResponseCreation ));
+        
+        // State: [BATCH_RESPONSE_LOOP] - Tag: <errorResponse>
+        super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "errorResponse", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.ERROR_RESPONSE, errorResponseCreation ));
+        
+        // State: [BATCH_RESPONSE_LOOP] - Tag: <searchReponse>
+        super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "searchResponse", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.SEARCH_RESPONSE, searchResponseCreation ));
+        
+        // State: [BATCH_RESPONSE_LOOP] - Tag: </batchResponse>
+        super.transitions[Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP].put( new Tag( "batchResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, Dsmlv2StatesEnum.GRAMMAR_END, null ));
+        
+        
+        //====================================================
+        //  Transitions concerning : ERROR RESPONSE
+        //====================================================
+        super.transitions[Dsmlv2StatesEnum.ERROR_RESPONSE] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.MESSAGE_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.MESSAGE_END] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.DETAIL_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.DETAIL_END] = new HashMap<Tag, GrammarTransition>();
+        
+        // State: [ERROR_RESPONSE] - Tag: <message>
+        super.transitions[Dsmlv2StatesEnum.ERROR_RESPONSE].put( new Tag( "message", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.ERROR_RESPONSE, Dsmlv2StatesEnum.MESSAGE_START, errorResponseAddMessage ));
+        
+        // State: [ERROR_RESPONSE] - Tag: <detail>
+        super.transitions[Dsmlv2StatesEnum.ERROR_RESPONSE].put( new Tag( "detail", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.ERROR_RESPONSE, Dsmlv2StatesEnum.DETAIL_START, errorResponseAddDetail ));
+        
+        // State: [MESSAGE_START] - Tag: </message>
+        super.transitions[Dsmlv2StatesEnum.MESSAGE_START].put( new Tag( "message", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.MESSAGE_START, Dsmlv2StatesEnum.MESSAGE_END, null ));
+        
+        // State: [MESSAGE_END] - Tag: </errorResponse>
+        super.transitions[Dsmlv2StatesEnum.MESSAGE_END].put( new Tag( "errorResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.MESSAGE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [MESSAGE_END] - Tag: <detail>
+        super.transitions[Dsmlv2StatesEnum.MESSAGE_END].put( new Tag( "detail", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.MESSAGE_END, Dsmlv2StatesEnum.DETAIL_START, errorResponseAddDetail ));
+        
+        // State: [DETAIL_START] - Tag: </detail>
+        super.transitions[Dsmlv2StatesEnum.DETAIL_START].put( new Tag( "detail", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.DETAIL_START, Dsmlv2StatesEnum.DETAIL_END, null ));
+        
+        // State: [DETAIL_END] - Tag: <detail>
+        super.transitions[Dsmlv2StatesEnum.DETAIL_END].put( new Tag( "detail", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.DETAIL_END, Dsmlv2StatesEnum.DETAIL_END, errorResponseAddDetail ));
+        
+        // State: [ERROR_RESPONSE] - Tag: </errorResponse>
+        super.transitions[Dsmlv2StatesEnum.ERROR_RESPONSE].put( new Tag( "errorResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.ERROR_RESPONSE, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        
+        //====================================================
+        //  Transitions concerning : EXTENDED RESPONSE
+        //====================================================
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_END] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_VALUE_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_VALUE_END] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.RESPONSE_NAME_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.RESPONSE_NAME_END] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.RESPONSE_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.RESPONSE_END] = new HashMap<Tag, GrammarTransition>();
+        
+        // State: [EXTENDED_RESPONSE] - Tag: <control>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE].put( new Tag( "control", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE, Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_START, ldapResultControlCreation ));
+        
+        // State: [EXTENDED_RESPONSE_CONTROL_START] - Tag: <controlValue>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_START].put( new Tag( "controlValue", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_START, Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_VALUE_START, ldapResultControlValueCreation ));
+        
+        // State: [EXTENDED_RESPONSE_CONTROL_VALUE_START] - Tag: </controlValue>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_VALUE_START].put( new Tag( "controlValue", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_VALUE_START, Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_VALUE_END, null ));
+        
+        // State: [EXTENDED_RESPONSE_CONTROL_VALUE_END] - Tag: </control>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_VALUE_END].put( new Tag( "control", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_VALUE_END, Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_END, null ));
+        
+        // State: [EXTENDED_RESPONSE_CONTROL_START] - Tag: </control>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_START].put( new Tag( "control", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_START, Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_END, null ));
+        
+        // State: [EXTENDED_RESPONSE_CONTROL_END] - Tag: <control>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_END].put( new Tag( "control", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_END, Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_START, ldapResultControlCreation ));
+        
+        // State: [EXTENDED_RESPONSE_CONTROL_END] - Tag: <resultCode>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_END].put( new Tag( "resultCode", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_END, Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_START, extendedResponseAddResultCode ));
+        
+        // State: [EXTENDED_RESPONSE] - Tag: <resultCode>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE].put( new Tag( "resultCode", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE, Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_START, extendedResponseAddResultCode ));
+        
+        // State: [EXTENDED_RESPONSE_RESULT_CODE_START] - Tag: </resultCode>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_START].put( new Tag( "resultCode", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_START, Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END, null ));
+        
+        // State: [EXTENDED_RESPONSE_RESULT_CODE_END] - Tag: <errorMessage>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END].put( new Tag( "errorMessage", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END, Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_START, extendedResponseAddErrorMessage ));
+        
+        // State: [EXTENDED_RESPONSE_RESULT_CODE_END] - Tag: <referral>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END].put( new Tag( "referral", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END, Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_START, extendedResponseAddReferral ));
+        
+        // State: [EXTENDED_RESPONSE_RESULT_CODE_END] - Tag: <responseName>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END].put( new Tag( "responseName", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END, Dsmlv2StatesEnum.RESPONSE_NAME_START, extendedResponseAddResponseName ));
+        
+        // State: [EXTENDED_RESPONSE_RESULT_CODE_END] - Tag: <response>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END].put( new Tag( "response", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END, Dsmlv2StatesEnum.RESPONSE_START, extendedResponseAddResponse ));
+        
+        // State: [EXTENDED_RESPONSE_RESULT_CODE_END] - Tag: </extendedResponse>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END].put( new Tag( "extendedResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [EXTENDED_RESPONSE_ERROR_MESSAGE_START] - Tag: </errorMessage>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_START].put( new Tag( "errorMessage", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_START, Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END, null ));
+        
+        // State: [EXTENDED_RESPONSE_ERROR_MESSAGE_END] - Tag: <referral>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END].put( new Tag( "referral", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END, Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_START, extendedResponseAddReferral ));
+        
+        // State: [EXTENDED_RESPONSE_ERROR_MESSAGE_END] - Tag: <responseName>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END].put( new Tag( "responseName", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END, Dsmlv2StatesEnum.RESPONSE_NAME_START, extendedResponseAddResponseName ));
+        
+        // State: [EXTENDED_RESPONSE_ERROR_MESSAGE_END] - Tag: <response>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END].put( new Tag( "response", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END, Dsmlv2StatesEnum.RESPONSE_START, extendedResponseAddResponse ));
+        
+        // State: [EXTENDED_RESPONSE_ERROR_MESSAGE_END] - Tag: </extendedResponse>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END].put( new Tag( "extendedResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [EXTENDED_RESPONSE_REFERRAL_START] - Tag: <referral>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_START].put( new Tag( "referral", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_START, Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END, null ));
+        
+        // State: [EXTENDED_RESPONSE_REFERRAL_START] - Tag: <referral>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_START].put( new Tag( "referral", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_START, Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END, null ));
+        
+        // State: [EXTENDED_RESPONSE_REFERRAL_END] - Tag: <referral>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END].put( new Tag( "referral", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END, Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_START, extendedResponseAddReferral ));
+        
+        // State: [EXTENDED_RESPONSE_REFERRAL_END] - Tag: <responseName>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END].put( new Tag( "responseName", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END, Dsmlv2StatesEnum.RESPONSE_NAME_START, extendedResponseAddResponseName ));
+        
+        // State: [EXTENDED_RESPONSE_REFERRAL_END] - Tag: <reponse>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END].put( new Tag( "reponse", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END, Dsmlv2StatesEnum.RESPONSE_START, extendedResponseAddResponse ));
+        
+        // State: [EXTENDED_RESPONSE_REFERRAL_END] - Tag: </extendedResponse>
+        super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END].put( new Tag( "extendedResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [RESPONSE_NAME_START] - Tag: </responseName>
+        super.transitions[Dsmlv2StatesEnum.RESPONSE_NAME_START].put( new Tag( "responseName", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.RESPONSE_NAME_START, Dsmlv2StatesEnum.RESPONSE_NAME_END, null ));
+        
+        // State: [RESPONSE_NAME_END] - Tag: <response>
+        super.transitions[Dsmlv2StatesEnum.RESPONSE_NAME_END].put( new Tag( "response", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.RESPONSE_NAME_END, Dsmlv2StatesEnum.RESPONSE_START, extendedResponseAddResponse ));
+        
+        // State: [RESPONSE_NAME_END] - Tag: </extendedResponse>
+        super.transitions[Dsmlv2StatesEnum.RESPONSE_NAME_END].put( new Tag( "extendedResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.RESPONSE_NAME_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [RESPONSE_START] - Tag: </response>
+        super.transitions[Dsmlv2StatesEnum.RESPONSE_START].put( new Tag( "response", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.RESPONSE_START, Dsmlv2StatesEnum.RESPONSE_END, null ));
+        
+        // State: [RESPONSE_END] - Tag: </extendedResponse>
+        super.transitions[Dsmlv2StatesEnum.RESPONSE_END].put( new Tag( "extendedResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.RESPONSE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        
+        //====================================================
+        //  Transitions concerning : LDAP RESULT
+        //====================================================
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_END] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_VALUE_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_VALUE_END] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_DONE_END] = new HashMap<Tag, GrammarTransition>();
+        
+        // State: [LDAP_RESULT] - Tag: <control>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT].put( new Tag( "control", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT, Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_START, ldapResultControlCreation ));
+        
+        // State: [LDAP_RESULT] - Tag: <resultCode>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT].put( new Tag( "resultCode", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT, Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_START, ldapResultAddResultCode ));
+        
+        // State: [LDAP_RESULT_CONTROL_START] - Tag: <controlValue>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_START].put( new Tag( "controlValue", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_START, Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_VALUE_START, ldapResultControlValueCreation ));
+        
+        // State: [LDAP_RESULT_CONTROL_VALUE_START] - Tag: </controlValue>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_VALUE_START].put( new Tag( "controlValue", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_VALUE_START, Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_VALUE_END, null ));
+        
+        // State: [LDAP_RESULT_CONTROL_VALUE_END] - Tag: </control>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_VALUE_END].put( new Tag( "control", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_VALUE_END, Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_END, null ));
+        
+        // State: [LDAP_RESULT_CONTROL_START] - Tag: </control>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_START].put( new Tag( "control", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_START, Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_END, null ));
+        
+        // State: [LDAP_RESULT_CONTROL_END] - Tag: <control>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_END].put( new Tag( "control", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_END, Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_START, ldapResultControlCreation ));
+        
+        // State: [LDAP_RESULT_CONTROL_END] - Tag: <resultCode>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_END].put( new Tag( "resultCode", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_END, Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_START, ldapResultAddResultCode ));
+        
+        // State: [LDAP_RESULT_RESULT_CODE_START] - Tag: </resultCode>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_START].put( new Tag( "resultCode", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_START, Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END, null ));
+
+        // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: <errorMessage>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END].put( new Tag( "errorMessage", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END, Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_START, ldapResultAddErrorMessage ));
+        
+        // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: <referral>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END].put( new Tag( "referral", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END, Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_START, ldapResultAddReferral ));
+        
+        // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: </addResponse>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END].put( new Tag( "addResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: </authResponse>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END].put( new Tag( "authResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: </compareResponse>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END].put( new Tag( "compareResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: </delResponse>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END].put( new Tag( "delResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: </modifyResponse>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END].put( new Tag( "modifyResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: </modDNResponse>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END].put( new Tag( "modDNResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: </searchResultDone>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END].put( new Tag( "searchResultDone", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END, Dsmlv2StatesEnum.SEARCH_RESULT_DONE_END, null ));
+        
+        // State: [SEARCH_RESULT_DONE_END] - Tag: </searchResponse>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_DONE_END].put( new Tag( "searchResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_DONE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [LDAP_RESULT_ERROR_MESSAGE_START] - Tag: </errorMessage>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_START].put( new Tag( "errorMessage", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_START, Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END, null ));
+        
+        // State: [LDAP_RESULT_ERROR_MESSAGE_END] - Tag: <referral>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END].put( new Tag( "referral", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END, Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_START, ldapResultAddReferral ));
+        
+        // State: [LDAP_RESULT_ERROR_MESSAGE_END] - Tag: </addResponse>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END].put( new Tag( "addResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [LDAP_RESULT_ERROR_MESSAGE_END] - Tag: </authResponse>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END].put( new Tag( "authResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [LDAP_RESULT_ERROR_MESSAGE_END] - Tag: </compareResponse>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END].put( new Tag( "compareResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [LDAP_RESULT_ERROR_MESSAGE_END] - Tag: </delResponse>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END].put( new Tag( "delResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [LDAP_RESULT_ERROR_MESSAGE_END] - Tag: </modifyResponse>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END].put( new Tag( "modifyResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [LDAP_RESULT_ERROR_MESSAGE_END] - Tag: </modDNResponse>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END].put( new Tag( "modDNResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [LDAP_RESULT_ERROR_MESSAGE_END] - Tag: </searchResultDone>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END].put( new Tag( "searchResultDone", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END, Dsmlv2StatesEnum.SEARCH_RESULT_DONE_END, null ));
+        
+        // State: [LDAP_RESULT_REFERRAL_START] - Tag: </referral>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_START].put( new Tag( "referral", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_START, Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, null ));
+        
+        // State: [LDAP_RESULT_REFERRAL_END] - Tag: <referral>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END].put( new Tag( "referral", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_START, ldapResultAddReferral ));
+        
+        // State: [LDAP_RESULT_REFERRAL_END] - Tag: </addResponse>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END].put( new Tag( "addResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [LDAP_RESULT_REFERRAL_END] - Tag: </authResponse>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END].put( new Tag( "authResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [LDAP_RESULT_REFERRAL_END] - Tag: </compareResponse>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END].put( new Tag( "compareResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [LDAP_RESULT_REFERRAL_END] - Tag: </delResponse>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END].put( new Tag( "delResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [LDAP_RESULT_REFERRAL_END] - Tag: </modifyResponse>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END].put( new Tag( "modifyResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [LDAP_RESULT_REFERRAL_END] - Tag: </modDNResponse>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END].put( new Tag( "modDNResponse", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, Dsmlv2StatesEnum.BATCH_RESPONSE_LOOP, null ));
+        
+        // State: [LDAP_RESULT_REFERRAL_END] - Tag: </searchResultDone>
+        super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END].put( new Tag( "searchResultDone", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, Dsmlv2StatesEnum.SEARCH_RESULT_DONE_END, null ));
+        
+        
+        //====================================================
+        //  Transitions concerning : SEARCH RESPONSE
+        //====================================================
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESPONSE] = new HashMap<Tag, GrammarTransition>();
+        
+        // State: [SEARCH_REPONSE] - Tag: <searchResultEntry>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESPONSE].put( new Tag( "searchResultEntry", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESPONSE, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY, searchResultEntryCreation ));
+        
+        // State: [SEARCH_REPONSE] - Tag: <searchResultReference>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESPONSE].put( new Tag( "searchResultReference", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESPONSE, Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE, searchResultReferenceCreation ));
+        
+        // State: [SEARCH_REPONSE] - Tag: <searchResultDone>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESPONSE].put( new Tag( "searchResultDone", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESPONSE, Dsmlv2StatesEnum.LDAP_RESULT, searchResultDoneCreation ));
+        
+        
+        //====================================================
+        //  Transitions concerning : SEARCH RESULT ENTRY
+        //====================================================
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_END] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_VALUE_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_VALUE_END] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_END] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_VALUE_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_VALUE_END] = new HashMap<Tag, GrammarTransition>();
+        
+        // State: [SEARCH_RESULT_ENTRY] - Tag: <control>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY].put( new Tag( "control", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_START, searchResultEntryControlCreation ));
+        
+        // State: [SEARCH_RESULT_ENTRY] - Tag: <attr>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY].put( new Tag( "attr", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_START, searchResultEntryAddAttr ));
+        
+        // State: [SEARCH_RESULT_ENTRY] - Tag: </searchResultEntry>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY].put( new Tag( "searchResultEntry", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP, null ));
+        
+        // State: [SEARCH_RESULT_ENTRY_CONTROL_START] - Tag: <controlValue>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_START].put( new Tag( "controlValue", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_START, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_VALUE_START, searchResultEntryControlValueCreation ));
+        
+        // State: [SEARCH_RESULT_ENTRY_CONTROL_VALUE_START] - Tag: </controlValue>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_VALUE_START].put( new Tag( "controlValue", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_VALUE_START, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_VALUE_END, null ));
+        
+        // State: [SEARCH_RESULT_ENTRY_CONTROL_VALUE_END] - Tag: </control>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_VALUE_END].put( new Tag( "control", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_VALUE_END, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_END, null ));
+        
+        // State: [SEARCH_RESULT_ENTRY_CONTROL_START] - Tag: </control>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_START].put( new Tag( "control", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_START, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_END, null ));
+        
+        // State: [SEARCH_RESULT_ENTRY_CONTROL_END] - Tag: <control>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_END].put( new Tag( "control", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_END, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_START, searchResultEntryControlCreation ));
+        
+        // State: [SEARCH_RESULT_ENTRY_CONTROL_END] - Tag: </searchResultEntry>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_END].put( new Tag( "searchResultEntry", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_END, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP, null ));
+        
+        // State: [SEARCH_RESULT_ENTRY_CONTROL_END] - Tag: <attr>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_END].put( new Tag( "attr", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_END, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_START, null ));
+        
+        // State: [SEARCH_RESULT_ENTRY_ATTR_START] - Tag: </attr>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_START].put( new Tag( "attr", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_START, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_END, null ));
+        
+        // State: [SEARCH_RESULT_ENTRY_ATTR_START] - Tag: <value>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_START].put( new Tag( "value", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_START, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_VALUE_START, searchResultEntryAddValue ));
+        
+        // State: [SEARCH_RESULT_ENTRY_ATTR_END] - Tag: <attr>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_END].put( new Tag( "attr", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_END, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_START, searchResultEntryAddAttr ));
+        
+        // State: [SEARCH_RESULT_ENTRY_ATTR_END] - Tag: </searchResultEntry>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_END].put( new Tag( "searchResultEntry", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_END, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP, null ));
+        
+        // State: [SEARCH_RESULT_ENTRY_VALUE_START] - Tag: </value>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_VALUE_START].put( new Tag( "value", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_VALUE_START, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_VALUE_END, null ));
+        
+        // State: [SEARCH_RESULT_ENTRY_VALUE_END] - Tag: <value>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_VALUE_END].put( new Tag( "value", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_VALUE_END, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_VALUE_START, searchResultEntryAddValue ));
+        
+        // State: [SEARCH_RESULT_ENTRY_VALUE_END] - Tag: </attr>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_VALUE_END].put( new Tag( "attr", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_VALUE_END, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_END, null ));
+        
+        //====================================================
+        //  Transitions concerning : SEARCH RESULT ENTRY LOOP
+        //====================================================
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP] = new HashMap<Tag, GrammarTransition>();
+        
+        // State: [SEARCH_RESULT_ENTRY_LOOP] - Tag: <searchResultEntry>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP].put( new Tag( "searchResultEntry", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP, Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY, searchResultEntryCreation ));
+        
+        // State: [SEARCH_RESULT_ENTRY_LOOP] - Tag: <searchResultReference>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP].put( new Tag( "searchResultReference", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP, Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE, searchResultReferenceCreation ));
+        
+        // State: [SEARCH_RESULT_ENTRY_LOOP] - Tag: <searchResultDone>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP].put( new Tag( "searchResultDone", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_LOOP, Dsmlv2StatesEnum.LDAP_RESULT, searchResultDoneCreation ));
+        
+        //====================================================
+        //  Transitions concerning : SEARCH RESULT REFERENCE
+        //====================================================
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_END] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_VALUE_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_VALUE_END] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_START] = new HashMap<Tag, GrammarTransition>();
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_END] = new HashMap<Tag, GrammarTransition>();
+        
+        // State: [SEARCH_RESULT_REFERENCE] - Tag: <control>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE].put( new Tag( "control", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE, Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_START, searchResultReferenceControlCreation ));
+        
+        // State: [SEARCH_RESULT_REFERENCE] - Tag: <ref>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE].put( new Tag( "ref", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE, Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_START, searchResultReferenceAddRef ));
+        
+        // State: [SEARCH_RESULT_REFERENCE_CONTROL_START] - Tag: <controlValue>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_START].put( new Tag( "controlValue", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_START, Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_VALUE_START, searchResultReferenceControlValueCreation ));
+        
+        // State: [SEARCH_RESULT_REFERENCE_CONTROL_VALUE_START] - Tag: </controlValue>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_VALUE_START].put( new Tag( "controlValue", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_VALUE_START, Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_VALUE_END, null ));
+        
+        // State: [sEARCH_RESULT_REFERENCE_CONTROL_VALUE_END] - Tag: </control>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_VALUE_END].put( new Tag( "control", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_VALUE_END, Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_END, null ));
+        
+        // State: [SEARCH_RESULT_REFERENCE_CONTROL_START] - Tag: </control>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_START].put( new Tag( "control", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_START, Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_END, null ));
+        
+        // State: [SEARCH_RESULT_REFERENCE_CONTROL_END] - Tag: <control>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_END].put( new Tag( "control", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_END, Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_START, searchResultReferenceControlCreation ));
+        
+        // State: [SEARCH_RESULT_REFERENCE_CONTROL_END] - Tag: <ref>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_END].put( new Tag( "ref", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_END, Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_START, searchResultReferenceAddRef ));
+        
+        // State: [SEARCH_RESULT_REFERENCE_REF_START] - Tag: </ref>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_START].put( new Tag( "ref", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_START, Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_END, null ));
+        
+        // State: [SEARCH_RESULT_REFERENCE_REF_END] - Tag: <ref>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_END].put( new Tag( "ref", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_END, Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_START, searchResultReferenceAddRef ));
+        
+        // State: [SEARCH_RESULT_REFERENCE_REF_END] - Tag: </searchResultReference>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_END].put( new Tag( "searchResultReference", Tag.END), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_END, Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_LOOP, null ));
+        
+        
+        //==========================================================
+        //  Transitions concerning : SEARCH RESULT REFERENCE LOOP
+        //==========================================================
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_LOOP] = new HashMap<Tag, GrammarTransition>();
+        
+        // State: [SEARCH_RESULT_REFERENCE_LOOP] - Tag: <searchResultReference>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_LOOP].put( new Tag( "searchResultReference", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_LOOP, Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE, searchResultReferenceCreation ));
+        
+        // State: [SEARCH_RESULT_REFERENCE_LOOP] - Tag: <searchResultDone>
+        super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_LOOP].put( new Tag( "searchResultDone", Tag.START), new GrammarTransition(
+            Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_LOOP, Dsmlv2StatesEnum.LDAP_RESULT, searchResultDoneCreation ));
+    }
+    
+    /**
+     * GrammarAction that creates the Batch Response
+     */
+	private final GrammarAction batchResponseCreation = new GrammarAction( "Create Batch Response" )
+    {
+        public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+            BatchResponse batchResponse = new BatchResponse();
+            
+            container.setBatchResponse( batchResponse );
+            
+			XmlPullParser xpp = container.getParser();
+            
+            // Checking and adding the batchRequest's attributes
+            String attributeValue;
+            // requestID
+            attributeValue = xpp.getAttributeValue( "", "requestID" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+                	batchResponse.setRequestID( Integer.parseInt( attributeValue ) );
+                }
+                catch (NumberFormatException e) {
+                    throw new XmlPullParserException( "the given requestID is not an integer", xpp, null );
+                }
+            }	
+        }
+    };
+	
+    /**
+     * GrammarAction that creates the Add Response
+     */
+	private final GrammarAction addResponseCreation = new GrammarAction( "Create Add Response" )
+	{
+		public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+			AddResponse addResponse = new AddResponse();
+			
+			container.getBatchResponse().addResponse( addResponse );
+			
+			LdapResult ldapResult = new LdapResult();
+			
+			addResponse.setLdapResult( ldapResult );
+            
+			XmlPullParser xpp = container.getParser();
+			
+            // Checking and adding the batchRequest's attributes
+            String attributeValue;
+            // requestID
+            attributeValue = xpp.getAttributeValue( "", "requestID" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+                	addResponse.setMessageId( Integer.parseInt( attributeValue ) );
+                }
+                catch (NumberFormatException e) {
+                    throw new XmlPullParserException( "the given requestID is not an integer", xpp, null );
+                }
+            }	
+            // MatchedDN
+            attributeValue = xpp.getAttributeValue( "", "matchedDN" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+					ldapResult.setMatchedDN( new LdapDN( attributeValue ) );
+				}
+                catch (InvalidNameException e)
+				{
+                	throw new XmlPullParserException( "" + e.getMessage(), xpp, null );
+				}
+            }
+        }
+	};
+	
+    /**
+     * GrammarAction that creates the Auth Response
+     */
+	private final GrammarAction authResponseCreation = new GrammarAction( "Create Auth Response" )
+	{
+		public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+			BindResponse bindResponse = new BindResponse();
+			
+			container.getBatchResponse().addResponse( bindResponse );
+			
+			LdapResult ldapResult = new LdapResult();
+			
+			bindResponse.setLdapResult( ldapResult );
+            
+			XmlPullParser xpp = container.getParser();
+			
+            // Checking and adding the batchRequest's attributes
+            String attributeValue;
+            // requestID
+            attributeValue = xpp.getAttributeValue( "", "requestID" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+                	bindResponse.setMessageId( Integer.parseInt( attributeValue ) );
+                }
+                catch (NumberFormatException e) {
+                    throw new XmlPullParserException( "the given requestID is not an integer", xpp, null );
+                }
+            }	
+            // MatchedDN
+            attributeValue = xpp.getAttributeValue( "", "matchedDN" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+					ldapResult.setMatchedDN( new LdapDN( attributeValue ) );
+				}
+                catch (InvalidNameException e)
+				{
+                	throw new XmlPullParserException( "" + e.getMessage(), xpp, null );
+				}
+            }
+        }			
+	};
+	
+    /**
+     * GrammarAction that creates the Compare Response
+     */
+	private final GrammarAction compareResponseCreation = new GrammarAction( "Create Compare Response" )
+	{
+		public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+			CompareResponse compareResponse = new CompareResponse();
+			
+			container.getBatchResponse().addResponse( compareResponse );
+			
+			LdapResult ldapResult = new LdapResult();
+			
+			compareResponse.setLdapResult( ldapResult );
+            
+			XmlPullParser xpp = container.getParser();
+			
+            // Checking and adding the batchRequest's attributes
+            String attributeValue;
+            // requestID
+            attributeValue = xpp.getAttributeValue( "", "requestID" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+                	compareResponse.setMessageId( Integer.parseInt( attributeValue ) );
+                }
+                catch (NumberFormatException e) {
+                    throw new XmlPullParserException( "the given requestID is not an integer", xpp, null );
+                }
+            }	
+            // MatchedDN
+            attributeValue = xpp.getAttributeValue( "", "matchedDN" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+					ldapResult.setMatchedDN( new LdapDN( attributeValue ) );
+				}
+                catch (InvalidNameException e)
+				{
+                	throw new XmlPullParserException( "" + e.getMessage(), xpp, null );
+				}
+            }
+        }			
+	};
+	
+    /**
+     * GrammarAction that creates the Del Response
+     */
+	private final GrammarAction delResponseCreation = new GrammarAction( "Create Del Response" )
+	{
+		public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+			DelResponse delResponse = new DelResponse();
+			
+			container.getBatchResponse().addResponse( delResponse );
+			
+			LdapResult ldapResult = new LdapResult();
+			
+			delResponse.setLdapResult( ldapResult );
+            
+			XmlPullParser xpp = container.getParser();
+			
+            // Checking and adding the batchRequest's attributes
+            String attributeValue;
+            // requestID
+            attributeValue = xpp.getAttributeValue( "", "requestID" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+                	delResponse.setMessageId( Integer.parseInt( attributeValue ) );
+                }
+                catch (NumberFormatException e) {
+                    throw new XmlPullParserException( "the given requestID is not an integer", xpp, null );
+                }
+            }	
+            // MatchedDN
+            attributeValue = xpp.getAttributeValue( "", "matchedDN" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+					ldapResult.setMatchedDN( new LdapDN( attributeValue ) );
+				}
+                catch (InvalidNameException e)
+				{
+                	throw new XmlPullParserException( "" + e.getMessage(), xpp, null );
+				}
+            }
+        }			
+	};
+	
+    /**
+     * GrammarAction that creates the Modify Response
+     */
+	private final GrammarAction modifyResponseCreation = new GrammarAction( "Create Modify Response" )
+	{
+		public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+			ModifyResponse modifyResponse = new ModifyResponse();
+			
+			container.getBatchResponse().addResponse( modifyResponse );
+			
+			LdapResult ldapResult = new LdapResult();
+			
+			modifyResponse.setLdapResult( ldapResult );
+            
+			XmlPullParser xpp = container.getParser();
+			
+            // Checking and adding the batchRequest's attributes
+            String attributeValue;
+            // requestID
+            attributeValue = xpp.getAttributeValue( "", "requestID" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+                	modifyResponse.setMessageId( Integer.parseInt( attributeValue ) );
+                }
+                catch (NumberFormatException e) {
+                    throw new XmlPullParserException( "the given requestID is not an integer", xpp, null );
+                }
+            }	
+            // MatchedDN
+            attributeValue = xpp.getAttributeValue( "", "matchedDN" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+					ldapResult.setMatchedDN( new LdapDN( attributeValue ) );
+				}
+                catch (InvalidNameException e)
+				{
+                	throw new XmlPullParserException( "" + e.getMessage(), xpp, null );
+				}
+            }
+        }			
+	};
+	
+    /**
+     * GrammarAction that creates the Mod DN Response
+     */
+	private final GrammarAction modDNResponseCreation = new GrammarAction( "Create Mod DN Response" )
+	{
+		public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+			ModifyDNResponse modifyDNResponse = new ModifyDNResponse();
+			
+			container.getBatchResponse().addResponse( modifyDNResponse );
+			
+			LdapResult ldapResult = new LdapResult();
+			
+			modifyDNResponse.setLdapResult( ldapResult );
+            
+			XmlPullParser xpp = container.getParser();
+			
+            // Checking and adding the batchRequest's attributes
+            String attributeValue;
+            // requestID
+            attributeValue = xpp.getAttributeValue( "", "requestID" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+                	modifyDNResponse.setMessageId( Integer.parseInt( attributeValue ) );
+                }
+                catch (NumberFormatException e) {
+                    throw new XmlPullParserException( "the given requestID is not an integer", xpp, null );
+                }
+            }	
+            // MatchedDN
+            attributeValue = xpp.getAttributeValue( "", "matchedDN" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+					ldapResult.setMatchedDN( new LdapDN( attributeValue ) );
+				}
+                catch (InvalidNameException e)
+				{
+                	throw new XmlPullParserException( "" + e.getMessage(), xpp, null );
+				}
+            }
+        }			
+	};
+	
+    /**
+     * GrammarAction that creates the Extended Response
+     */
+	private final GrammarAction extendedResponseCreation = new GrammarAction( "Create Extended Response" )
+	{
+		public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+			ExtendedResponse extendedResponse = new ExtendedResponse();
+			
+			container.getBatchResponse().addResponse( extendedResponse );
+			
+			LdapResult ldapResult = new LdapResult();
+			
+			extendedResponse.setLdapResult( ldapResult );
+			
+			XmlPullParser xpp = container.getParser();
+            
+            // Checking and adding the batchRequest's attributes
+            String attributeValue;
+            // requestID
+            attributeValue = xpp.getAttributeValue( "", "requestID" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+                	extendedResponse.setMessageId( Integer.parseInt( attributeValue ) );
+                }
+                catch (NumberFormatException e) {
+                    throw new XmlPullParserException( "the given requestID is not an integer", xpp, null );
+                }
+            }
+            // MatchedDN
+            attributeValue = xpp.getAttributeValue( "", "matchedDN" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+					ldapResult.setMatchedDN( new LdapDN( attributeValue ) );
+				}
+                catch (InvalidNameException e)
+				{
+                	throw new XmlPullParserException( "" + e.getMessage(), xpp, null );
+				}
+            }
+        }			
+	};
+	
+    /**
+     * GrammarAction that creates the Error Response
+     */
+	private final GrammarAction errorResponseCreation = new GrammarAction( "Create Error Response" )
+	{
+		public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+			ErrorResponse errorResponse = new ErrorResponse();
+			
+			container.getBatchResponse().addResponse( errorResponse );
+			
+			XmlPullParser xpp = container.getParser();
+            
+            // Checking and adding the batchRequest's attributes
+            String attributeValue;
+            // requestID
+            attributeValue = xpp.getAttributeValue( "", "requestID" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+                	errorResponse.setMessageId( Integer.parseInt( attributeValue ) );
+                }
+                catch (NumberFormatException e) {
+                    throw new XmlPullParserException( "the given requestID is not an integer", xpp, null );
+                }
+            }
+            // type
+            attributeValue = xpp.getAttributeValue( "", "type" );
+            if ( attributeValue != null )
+            {
+                if ( attributeValue.equals( errorResponse.getTypeDescr( ErrorResponseType.NOT_ATTEMPTED ) ) )
+                {
+					errorResponse.setType( ErrorResponseType.NOT_ATTEMPTED );
+				}
+                else if ( attributeValue.equals( errorResponse.getTypeDescr( ErrorResponseType.COULD_NOT_CONNECT ) ) )
+                {
+					errorResponse.setType( ErrorResponseType.COULD_NOT_CONNECT );
+				}
+                else if ( attributeValue.equals( errorResponse.getTypeDescr( ErrorResponseType.CONNECTION_CLOSED ) ) )
+                {
+					errorResponse.setType( ErrorResponseType.CONNECTION_CLOSED );
+				}
+                else if ( attributeValue.equals( errorResponse.getTypeDescr( ErrorResponseType.MALFORMED_REQUEST ) ) )
+                {
+					errorResponse.setType( ErrorResponseType.MALFORMED_REQUEST );
+				}
+                else if ( attributeValue.equals( errorResponse.getTypeDescr( ErrorResponseType.GATEWAY_INTERNAL_ERROR ) ) )
+                {
+					errorResponse.setType( ErrorResponseType.GATEWAY_INTERNAL_ERROR );
+				}
+                else if ( attributeValue.equals( errorResponse.getTypeDescr( ErrorResponseType.AUTHENTICATION_FAILED ) ) )
+                {
+					errorResponse.setType( ErrorResponseType.AUTHENTICATION_FAILED );
+				}
+                else if ( attributeValue.equals( errorResponse.getTypeDescr( ErrorResponseType.UNRESOLVABLE_URI ) ) )
+                {
+					errorResponse.setType( ErrorResponseType.UNRESOLVABLE_URI );
+				}
+                else if ( attributeValue.equals( errorResponse.getTypeDescr( ErrorResponseType.OTHER ) ) )
+                {
+					errorResponse.setType( ErrorResponseType.OTHER );
+				}
+                else 
+                {
+                    throw new XmlPullParserException( "Unknown type", xpp, null );
+                }
+            }
+            else
+            {
+                throw new XmlPullParserException( "type attribute is required", xpp, null );
+            }
+        }			
+	};
+    
+	/**
+     * GrammarAction that adds Message to an Error Response
+     */
+	private final GrammarAction errorResponseAddMessage =  new GrammarAction( "Add Message to Error Response" )
+    {
+        public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+            ErrorResponse errorResponse = (ErrorResponse) container.getBatchResponse().getCurrentResponse();
+            
+            XmlPullParser xpp = container.getParser();
+                        
+            int eventType = 0;
+            try
+            {
+                eventType = xpp.next();
+            }
+            catch ( IOException e )
+            {
+                throw new XmlPullParserException( e.getMessage(), xpp, null );
+            }
+                   
+            if ( eventType == XmlPullParser.TEXT )
+            {
+                errorResponse.setMessage( xpp.getText().trim() );
+            }
+        }
+    };
+
+	/**
+     * GrammarAction that adds Detail to an Error Response
+     */
+	private final GrammarAction errorResponseAddDetail = null; // TODO Look for documentation about this Detail element (the DSML documentation doesn't give enough information)
+	
+	
+	/**
+	 * Creates a Control parsing the current node and adds it to the given parent 
+	 * @param container the DSMLv2Container
+	 * @param parent the parent 
+	 * @throws XmlPullParserException
+	 */
+	private void createAndAddControl( Dsmlv2Container container, LdapMessage parent ) throws XmlPullParserException
+	{
+		Control control = new Control();
+		
+		parent.addControl( control );
+
+    	XmlPullParser xpp = container.getParser();
+        
+        // Checking and adding the Control's attributes
+        String attributeValue;
+        // TYPE
+        attributeValue = xpp.getAttributeValue( "", "type" );
+        if ( attributeValue != null )
+        {
+            // TODO Add a verification for a match with NumericOid format (see
+            // DSMLv2 specifications)
+        	control.setControlType( attributeValue ); // TODO LDAPString uses UTF8 bytes, so the charset must be verified before doing this.
+        }
+        else
+        {
+            throw new XmlPullParserException( "type attribute is required", xpp, null );
+        }
+        // CRITICALITY
+        attributeValue = xpp.getAttributeValue( "", "criticality" );
+        if ( attributeValue != null )
+        {
+            if ( attributeValue.equals( "true" ) )
+            {
+                control.setCriticality( true );
+            }
+            else if ( attributeValue.equals( "false" ) )
+            {
+                control.setCriticality( false );
+            }
+            else
+            {
+                throw new XmlPullParserException( "Incorrect value for 'criticality' attribute", xpp, null );
+            }
+        }
+	}
+	
+	/**
+     * GrammarAction that creates a Control for LDAP Result
+     */
+	private final GrammarAction ldapResultControlCreation = new GrammarAction( "Create Control for LDAP Result" )
+    {
+        public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+        	LdapResponse ldapResponse = container.getBatchResponse().getCurrentResponse();
+        	// Search Response is a special case
+        	if (ldapResponse instanceof SearchResponse) 
+        	{
+				ldapResponse = ( (SearchResponse) ldapResponse ).getSearchResultDone();
+			}
+        		
+        	createAndAddControl(container, ldapResponse);
+        }
+    };
+    
+	/**
+     * GrammarAction that creates a Control for Search Result Entry
+     */
+	private final GrammarAction searchResultEntryControlCreation = new GrammarAction( "Create Control for Search Result Entry" )
+    {
+        public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+        	LdapMessage ldapMessage = ( (SearchResponse) container.getBatchResponse().getCurrentResponse() ).getCurrentSearchResultEntry();
+        	createAndAddControl(container, ldapMessage);
+        }
+    };
+    
+	/**
+     * GrammarAction that creates a Control for Search Result Entry
+     */
+	private final GrammarAction searchResultReferenceControlCreation = new GrammarAction( "Create Control for Search Result Reference" )
+    {
+        public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+        	LdapMessage ldapMessage = ( (SearchResponse) container.getBatchResponse().getCurrentResponse() ).getCurrentSearchResultReference();
+        	createAndAddControl(container, ldapMessage);
+        }
+    };
+	
+    
+    /**
+     * Creates a Control Value parsing the current node and adds it to the given parent 
+	 * @param container the DSMLv2Container
+	 * @param parent the parent 
+     * @throws XmlPullParserException
+     */
+    private void createAndAddControlValue( Dsmlv2Container container, LdapMessage parent ) throws XmlPullParserException
+    {
+    	Control control = parent.getCurrentControl();
+        
+        XmlPullParser xpp = container.getParser();
+                    
+        int eventType = 0;
+        try
+        {
+            eventType = xpp.next();
+        }
+        catch ( IOException e )
+        {
+            throw new XmlPullParserException( "name attribute is required", xpp, null );
+        }
+               
+        if ( eventType != XmlPullParser.TEXT )
+        {
+            // TODO we insert a blank value
+            control.setControlValue( "" );
+        }
+        else
+        {
+            control.setControlValue( xpp.getText().trim() );
+        }
+    }
+    
+	/**
+     * GrammarAction that creates a Control Value for LDAP Result
+     */
+	private final GrammarAction ldapResultControlValueCreation = new GrammarAction( "Add ControlValue to Control for LDAP Result" )
+    {
+        public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+        	LdapResponse ldapResponse = container.getBatchResponse().getCurrentResponse();
+        	// Search Response is a special case
+        	if (ldapResponse instanceof SearchResponse) 
+        	{
+				ldapResponse = ( (SearchResponse) ldapResponse ).getSearchResultDone();
+			}
+        	
+        	createAndAddControlValue( container, ldapResponse );
+        }
+    };
+    
+	/**
+     * GrammarAction that creates a Control Value for Search Result Entry
+     */
+	private final GrammarAction searchResultEntryControlValueCreation = new GrammarAction( "Add ControlValue to Control for Search Result Entry" )
+    {
+        public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+        	LdapMessage ldapMessage = ( (SearchResponse) container.getBatchResponse().getCurrentResponse() ).getCurrentSearchResultEntry();
+        	createAndAddControlValue( container, ldapMessage );
+        }
+    };
+
+	/**
+     * GrammarAction that creates a Control Value for Search Result Reference
+     */
+	private final GrammarAction searchResultReferenceControlValueCreation = new GrammarAction( "Add ControlValue to Control for Search Result Entry" )
+    {
+        public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+        	LdapMessage ldapMessage = ( (SearchResponse) container.getBatchResponse().getCurrentResponse() ).getCurrentSearchResultReference();
+        	createAndAddControlValue( container, ldapMessage );
+        }
+    };
+    
+	/**
+     * GrammarAction that adds a Result Code to a LDAP Result
+     */
+	private final GrammarAction ldapResultAddResultCode = new GrammarAction( "Add ResultCode to LDAP Result" )
+    {
+        public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+        	LdapResponse ldapResponse = container.getBatchResponse().getCurrentResponse();
+        	
+        	LdapResult ldapResult = null;
+        	
+        	// Search Response is a special case
+        	// ResultCode can only occur in a case of Search Result Done in a Search Response
+        	if (ldapResponse instanceof SearchResponse) 
+        	{
+				SearchResponse searchResponse = (SearchResponse) ldapResponse;
+				ldapResult = searchResponse.getSearchResultDone().getLdapResult();
+			}
+        	else
+        	{
+        		ldapResult = ldapResponse.getLdapResult();
+        	}
+        	
+        	XmlPullParser xpp = container.getParser();
+        	
+        	// Checking and adding the request's attributes
+            String attributeValue;
+            // code
+            attributeValue = xpp.getAttributeValue( "", "code" );
+            if ( attributeValue != null )
+            {
+            	try
+            	{
+            		ldapResult.setResultCode( Integer.parseInt( attributeValue ) );
+            	}
+            	catch (NumberFormatException e)
+            	{
+            		throw new XmlPullParserException( "the given resultCode is not an integer", xpp, null );
+				}
+            }
+            else
+            {
+                throw new XmlPullParserException( "code attribute is required", xpp, null );
+            }
+            // descr
+            attributeValue = xpp.getAttributeValue( "", "descr" );
+            if ( attributeValue != null )
+            {
+            	if ( DSMLV2_DESCR_TAGS.contains( attributeValue ) == false )
+            	{
+            		throw new XmlPullParserException( "descr ('" + attributeValue + "') doesn't match with the possible values", xpp, null );
+            	}
+            		
+            }
+        }
+    };
+
+	/**
+     * GrammarAction that adds a Error Message to a LDAP Result
+     */
+	private final GrammarAction ldapResultAddErrorMessage = new GrammarAction( "Add Error Message to LDAP Result" )
+    {
+        public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+        	LdapResponse ldapResponse = container.getBatchResponse().getCurrentResponse();
+        	
+        	LdapResult ldapResult = null;
+        	
+        	// Search Response is a special case
+        	// ResultCode can only occur in a case of Search Result Done in a Search Response
+        	if (ldapResponse instanceof SearchResponse) 
+        	{
+				SearchResponse searchResponse = (SearchResponse) ldapResponse;
+				ldapResult = searchResponse.getSearchResultDone().getLdapResult();
+			}
+        	else
+        	{
+        		ldapResult = ldapResponse.getLdapResult();
+        	}
+        	
+        	XmlPullParser xpp = container.getParser();
+            
+            int eventType = 0 ;
+            try
+            {
+                eventType = xpp.next();
+            }
+            catch ( IOException e )
+            {
+                throw new XmlPullParserException( e.getMessage() , xpp, null );
+            }
+                   
+            if ( eventType != XmlPullParser.TEXT )
+            {
+            	throw new XmlPullParserException( "An error has ocurred." , xpp, null );
+            }
+            else
+            {
+            	ldapResult.setErrorMessage( xpp.getText().trim() );
+            }
+        }
+    };
+
+	/**
+     * GrammarAction that adds a Referral to a LDAP Result
+     */
+	private final GrammarAction ldapResultAddReferral = new GrammarAction( "Add Referral to LDAP Result" )
+    {
+        public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+        	LdapResponse ldapResponse = container.getBatchResponse().getCurrentResponse();
+        	
+        	LdapResult ldapResult = null;
+        	
+        	// Search Response is a special case
+        	// ResultCode can only occur in a case of Search Result Done in a Search Response
+        	if (ldapResponse instanceof SearchResponse) 
+        	{
+				SearchResponse searchResponse = (SearchResponse) ldapResponse;
+				ldapResult = searchResponse.getSearchResultDone().getLdapResult();
+			}
+        	else
+        	{
+        		ldapResult = ldapResponse.getLdapResult();
+        	}
+        	
+        	// Initialization of the Referrals if needed
+        	if ( ldapResult.getReferrals() == null )
+        	{
+        		ldapResult.initReferrals();
+        	}
+        	
+        	XmlPullParser xpp = container.getParser();
+            
+            int eventType = 0 ;
+            try
+            {
+                eventType = xpp.next();
+            }
+            catch ( IOException e )
+            {
+                throw new XmlPullParserException( e.getMessage() , xpp, null );
+            }
+                   
+            if ( eventType != XmlPullParser.TEXT )
+            {
+            	throw new XmlPullParserException( "An error has ocurred." , xpp, null );
+            }
+            else
+            {
+        		try
+        		{
+					ldapResult.addReferral( new LdapURL( xpp.getText().trim() ) );
+				}
+        		catch (LdapURLEncodingException e)
+        		{
+                	throw new XmlPullParserException( e.getMessage() , xpp, null );
+				} 
+            }
+        }
+    };
+    
+	/**
+     * GrammarAction that creates the Search Response
+     */
+    private final GrammarAction searchResponseCreation = new GrammarAction( "Create Search Response" )
+	{
+		public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+			SearchResponse searchResponse = new SearchResponse();
+			
+			container.getBatchResponse().addResponse( searchResponse );
+			
+			XmlPullParser xpp = container.getParser();
+			
+            // Checking and adding the batchRequest's attributes
+            String attributeValue;
+            // requestID
+            attributeValue = xpp.getAttributeValue( "", "requestID" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+                	searchResponse.setMessageId( Integer.parseInt( attributeValue ) );
+                }
+                catch (NumberFormatException e) {
+                    throw new XmlPullParserException( "the given requestID is not an integer", xpp, null );
+                }
+            }
+        }			
+	};
+
+	/**
+     * GrammarAction that creates a Search Result Entry
+     */
+	private final GrammarAction searchResultEntryCreation = new GrammarAction( "Add Search Result Entry to Search Response" )
+	{
+		public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+			SearchResultEntry searchResultEntry = new SearchResultEntry();
+			
+			SearchResponse searchResponse = (SearchResponse) container.getBatchResponse().getCurrentResponse();
+			
+			searchResponse.addSearchResultEntry( searchResultEntry );
+			
+			XmlPullParser xpp = container.getParser();
+        	
+        	// Checking and adding the request's attributes
+            String attributeValue;
+            // requestID
+            attributeValue = xpp.getAttributeValue( "", "requestID" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+                	searchResultEntry.setMessageId( Integer.parseInt( attributeValue ) );
+                }
+                catch (NumberFormatException e) {
+                    throw new XmlPullParserException( "the given requestID is not an integer", xpp, null );
+                }
+            }	
+            // dn
+            attributeValue = xpp.getAttributeValue( "", "dn" );
+            if ( attributeValue != null )
+            {
+            	try
+            	{
+            		searchResultEntry.setObjectName( new LdapDN( attributeValue ) );
+            	}
+            	catch (InvalidNameException e)
+            	{
+            		throw new XmlPullParserException( e.getMessage(), xpp, null );
+				}
+            }
+            else
+            {
+                throw new XmlPullParserException( "dn attribute is required", xpp, null );
+            }
+        }
+	};
+
+	/**
+     * GrammarAction that creates a Search Result Reference
+     */
+	private final GrammarAction searchResultReferenceCreation = new GrammarAction( "Add Search Result Reference to Search Response" )
+	{
+		public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+			SearchResultReference searchResultReference = new SearchResultReference();
+			
+			SearchResponse searchResponse = (SearchResponse) container.getBatchResponse().getCurrentResponse();
+			
+			searchResponse.addSearchResultReference( searchResultReference );
+			
+			XmlPullParser xpp = container.getParser();
+        	
+        	// Checking and adding the request's attributes
+            String attributeValue;
+            // requestID
+            attributeValue = xpp.getAttributeValue( "", "requestID" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+                	searchResultReference.setMessageId( Integer.parseInt( attributeValue ) );
+                }
+                catch (NumberFormatException e) {
+                    throw new XmlPullParserException( "the given requestID is not an integer", xpp, null );
+                }
+            }	
+        }
+	};
+
+	/**
+     * GrammarAction that creates a Search Result Done
+     */
+	private final GrammarAction searchResultDoneCreation = new GrammarAction( "Add Search Result Done to Search Response" )
+	{
+		public void action( Dsmlv2Container container ) throws XmlPullParserException
+        {
+			SearchResultDone searchResultDone = new SearchResultDone();
+			
+			searchResultDone.setLdapResult( new LdapResult() );
+			
+			SearchResponse searchResponse = (SearchResponse) container.getBatchResponse().getCurrentResponse();
+			
+			searchResponse.setSearchResultDone( searchResultDone );
+			
+			XmlPullParser xpp = container.getParser();
+			
+            // Checking and adding the batchRequest's attributes
+            String attributeValue;
+            // requestID
+            attributeValue = xpp.getAttributeValue( "", "requestID" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+                	searchResultDone.setMessageId( Integer.parseInt( attributeValue ) );
+                }
+                catch (NumberFormatException e) {
+                    throw new XmlPullParserException( "the given requestID is not an integer", xpp, null );
+                }
+            }	
+            // MatchedDN
+            attributeValue = xpp.getAttributeValue( "", "matchedDN" );
+            if ( attributeValue != null )
+            {
+                try
+                {
+					searchResultDone.getLdapResult().setMatchedDN( new LdapDN( attributeValue ) );
+				}
+                catch (InvalidNameException e)
+				{
+                	throw new XmlPullParserException( "" + e.getMessage(), xpp, null );
+				}
+            }
+        }
+	};
+
+	/**
+     * GrammarAction that adds an Attr to a Search Result Entry
+     */
+	private final GrammarAction searchResultEntryAddAttr = new GrammarAction( "Add Attr to Search Result Entry" )
+	{

[... 196 lines stripped ...]


Mime
View raw message