You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@directory.apache.org by pa...@apache.org on 2006/11/16 17:38:51 UTC
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...
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 ...]