From commits-return-22218-apmail-directory-commits-archive=directory.apache.org@directory.apache.org Tue Jul 21 17:04:10 2009 Return-Path: Delivered-To: apmail-directory-commits-archive@www.apache.org Received: (qmail 22699 invoked from network); 21 Jul 2009 17:04:09 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (140.211.11.3) by minotaur.apache.org with SMTP; 21 Jul 2009 17:04:09 -0000 Received: (qmail 73952 invoked by uid 500); 21 Jul 2009 17:05:15 -0000 Delivered-To: apmail-directory-commits-archive@directory.apache.org Received: (qmail 73883 invoked by uid 500); 21 Jul 2009 17:05:14 -0000 Mailing-List: contact commits-help@directory.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@directory.apache.org Delivered-To: mailing list commits@directory.apache.org Received: (qmail 73807 invoked by uid 99); 21 Jul 2009 17:05:14 -0000 Received: from athena.apache.org (HELO athena.apache.org) (140.211.11.136) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 21 Jul 2009 17:05:14 +0000 X-ASF-Spam-Status: No, hits=-2000.0 required=10.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.4] (HELO eris.apache.org) (140.211.11.4) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 21 Jul 2009 17:05:09 +0000 Received: by eris.apache.org (Postfix, from userid 65534) id 1C5AD238890C; Tue, 21 Jul 2009 17:04:49 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r796383 [4/23] - in /directory/shared/trunk: ./ dsml-parser/ dsml-parser/src/ dsml-parser/src/main/ dsml-parser/src/main/java/ dsml-parser/src/main/java/org/ dsml-parser/src/main/java/org/apache/ dsml-parser/src/main/java/org/apache/directo... Date: Tue, 21 Jul 2009 17:04:29 -0000 To: commits@directory.apache.org From: pamarcelot@apache.org X-Mailer: svnmailer-1.0.8 Message-Id: <20090721170449.1C5AD238890C@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org Added: directory/shared/trunk/dsml-parser/src/main/java/org/apache/directory/studio/dsmlv2/reponse/Dsmlv2ResponseGrammar.java URL: http://svn.apache.org/viewvc/directory/shared/trunk/dsml-parser/src/main/java/org/apache/directory/studio/dsmlv2/reponse/Dsmlv2ResponseGrammar.java?rev=796383&view=auto ============================================================================== --- directory/shared/trunk/dsml-parser/src/main/java/org/apache/directory/studio/dsmlv2/reponse/Dsmlv2ResponseGrammar.java (added) +++ directory/shared/trunk/dsml-parser/src/main/java/org/apache/directory/studio/dsmlv2/reponse/Dsmlv2ResponseGrammar.java Tue Jul 21 17:04:13 2009 @@ -0,0 +1,1812 @@ +/* + * 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.studio.dsmlv2.reponse; + + +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.shared.asn1.codec.DecoderException; +import org.apache.directory.shared.asn1.primitives.OID; +import org.apache.directory.shared.ldap.codec.ControlCodec; +import org.apache.directory.shared.ldap.codec.LdapMessageCodec; +import org.apache.directory.shared.ldap.codec.LdapResponseCodec; +import org.apache.directory.shared.ldap.codec.LdapResultCodec; +import org.apache.directory.shared.ldap.codec.add.AddResponseCodec; +import org.apache.directory.shared.ldap.codec.bind.BindResponseCodec; +import org.apache.directory.shared.ldap.codec.compare.CompareResponseCodec; +import org.apache.directory.shared.ldap.codec.del.DelResponseCodec; +import org.apache.directory.shared.ldap.codec.extended.ExtendedResponseCodec; +import org.apache.directory.shared.ldap.codec.modify.ModifyResponseCodec; +import org.apache.directory.shared.ldap.codec.modifyDn.ModifyDNResponseCodec; +import org.apache.directory.shared.ldap.codec.search.SearchResultDoneCodec; +import org.apache.directory.shared.ldap.codec.search.SearchResultEntryCodec; +import org.apache.directory.shared.ldap.codec.search.SearchResultReferenceCodec; +import org.apache.directory.shared.ldap.util.LdapURL; +import org.apache.directory.shared.ldap.codec.util.LdapURLEncodingException; +import org.apache.directory.shared.ldap.message.ResultCodeEnum; +import org.apache.directory.shared.ldap.name.LdapDN; +import org.apache.directory.shared.ldap.util.Base64; +import org.apache.directory.studio.dsmlv2.AbstractGrammar; +import org.apache.directory.studio.dsmlv2.Dsmlv2Container; +import org.apache.directory.studio.dsmlv2.Dsmlv2StatesEnum; +import org.apache.directory.studio.dsmlv2.GrammarAction; +import org.apache.directory.studio.dsmlv2.GrammarTransition; +import org.apache.directory.studio.dsmlv2.IGrammar; +import org.apache.directory.studio.dsmlv2.ParserUtils; +import org.apache.directory.studio.dsmlv2.Tag; +import org.apache.directory.studio.dsmlv2.reponse.ErrorResponse.ErrorResponseType; +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; + + +/** + * This Class represents the DSMLv2 Response Grammar + * + * @author Apache Directory Project + * @version $Rev$, $Date$ + */ +public class Dsmlv2ResponseGrammar extends AbstractGrammar implements IGrammar +{ + /** The instance of grammar. Dsmlv2ResponseGrammar is a singleton */ + private static Dsmlv2ResponseGrammar instance = new Dsmlv2ResponseGrammar(); + + // Initializing DESCR_TAGS + private static Set DSMLV2_DESCR_TAGS = null; + static + { + DSMLV2_DESCR_TAGS = new HashSet(); + 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[] ) Array.newInstance( HashMap.class, 300 );; // TODO Change this value + + //==================================================== + // Transitions concerning : BATCH RESPONSE + //==================================================== + super.transitions[Dsmlv2StatesEnum.INIT_GRAMMAR_STATE] = new HashMap(); + + // ** OPEN BATCH Reponse ** + // State: [INIT_GRAMMAR_STATE] - Tag: + 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(); + + // State: [BATCH_RESPONSE_LOOP] - Tag: + 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: + 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: + 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: + 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: + 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: + 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: + 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: + 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: + 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: + 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(); + super.transitions[Dsmlv2StatesEnum.MESSAGE_END] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.DETAIL_START] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.DETAIL_END] = new HashMap(); + + // State: [ERROR_RESPONSE] - Tag: + super.transitions[Dsmlv2StatesEnum.ERROR_RESPONSE].put( new Tag( "message", Tag.START ), new GrammarTransition( + Dsmlv2StatesEnum.ERROR_RESPONSE, Dsmlv2StatesEnum.MESSAGE_END, errorResponseAddMessage ) ); + + // State: [ERROR_RESPONSE] - Tag: + super.transitions[Dsmlv2StatesEnum.ERROR_RESPONSE].put( new Tag( "detail", Tag.START ), new GrammarTransition( + Dsmlv2StatesEnum.ERROR_RESPONSE, Dsmlv2StatesEnum.DETAIL_START, errorResponseAddDetail ) ); + + // State: [MESSAGE_END] - Tag: + 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: + super.transitions[Dsmlv2StatesEnum.MESSAGE_END].put( new Tag( "detail", Tag.START ), new GrammarTransition( + Dsmlv2StatesEnum.MESSAGE_END, Dsmlv2StatesEnum.DETAIL_START, errorResponseAddDetail ) ); + + // State: [DETAIL_START] - Tag: + super.transitions[Dsmlv2StatesEnum.DETAIL_START].put( new Tag( "detail", Tag.END ), new GrammarTransition( + Dsmlv2StatesEnum.DETAIL_START, Dsmlv2StatesEnum.DETAIL_END, null ) ); + + // State: [DETAIL_END] - Tag: + super.transitions[Dsmlv2StatesEnum.DETAIL_END].put( new Tag( "detail", Tag.END ), new GrammarTransition( + Dsmlv2StatesEnum.DETAIL_END, Dsmlv2StatesEnum.DETAIL_END, errorResponseAddDetail ) ); + + // State: [ERROR_RESPONSE] - Tag: + 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(); + super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_START] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_END] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_CONTROL_VALUE_END] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_START] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.RESPONSE_NAME_END] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.RESPONSE_END] = new HashMap(); + + // State: [EXTENDED_RESPONSE] - Tag: + 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: + 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_END, ldapResultControlValueCreation ) ); + + // State: [EXTENDED_RESPONSE_CONTROL_VALUE_END] - Tag: + 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: + 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: + 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: + 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: + 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: + 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: + 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_END, extendedResponseAddErrorMessage ) ); + + // State: [EXTENDED_RESPONSE_RESULT_CODE_END] - Tag: + 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_END, extendedResponseAddReferral ) ); + + // State: [EXTENDED_RESPONSE_RESULT_CODE_END] - Tag: + 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_END, + extendedResponseAddResponseName ) ); + + // State: [EXTENDED_RESPONSE_RESULT_CODE_END] - Tag: + super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END].put( new Tag( "response", Tag.START ), + new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_RESULT_CODE_END, Dsmlv2StatesEnum.RESPONSE_END, + extendedResponseAddResponse ) ); + + // State: [EXTENDED_RESPONSE_RESULT_CODE_END] - Tag: + 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_END] - Tag: + 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_END, extendedResponseAddReferral ) ); + + // State: [EXTENDED_RESPONSE_ERROR_MESSAGE_END] - Tag: + 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_END, + extendedResponseAddResponseName ) ); + + // State: [EXTENDED_RESPONSE_ERROR_MESSAGE_END] - Tag: + super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END].put( new Tag( "response", Tag.START ), + new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_ERROR_MESSAGE_END, + Dsmlv2StatesEnum.RESPONSE_END, extendedResponseAddResponse ) ); + + // State: [EXTENDED_RESPONSE_ERROR_MESSAGE_END] - Tag: + 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_END] - Tag: + super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END].put( new Tag( "referral", Tag.START ), + new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END, + Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END, extendedResponseAddReferral ) ); + + // State: [EXTENDED_RESPONSE_REFERRAL_END] - Tag: + super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END].put( new Tag( "responseName", Tag.START ), + new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END, + Dsmlv2StatesEnum.RESPONSE_NAME_END, extendedResponseAddResponseName ) ); + + // State: [EXTENDED_RESPONSE_REFERRAL_END] - Tag: + super.transitions[Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END].put( new Tag( "reponse", Tag.START ), + new GrammarTransition( Dsmlv2StatesEnum.EXTENDED_RESPONSE_REFERRAL_END, Dsmlv2StatesEnum.RESPONSE_END, + extendedResponseAddResponse ) ); + + // State: [EXTENDED_RESPONSE_REFERRAL_END] - Tag: + 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_END] - Tag: + super.transitions[Dsmlv2StatesEnum.RESPONSE_NAME_END].put( new Tag( "response", Tag.START ), + new GrammarTransition( Dsmlv2StatesEnum.RESPONSE_NAME_END, Dsmlv2StatesEnum.RESPONSE_END, + extendedResponseAddResponse ) ); + + // State: [RESPONSE_NAME_END] - Tag: + 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_END] - Tag: + 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(); + super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_START] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_END] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_CONTROL_VALUE_END] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_START] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_RESULT_CODE_END] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_ERROR_MESSAGE_END] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_DONE_END] = new HashMap(); + + // State: [LDAP_RESULT] - Tag: + 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: + 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: + 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_END, ldapResultControlValueCreation ) ); + + // State: [LDAP_RESULT_CONTROL_VALUE_END] - Tag: + 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: + 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: + 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: + 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: + 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: + 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_END, ldapResultAddErrorMessage ) ); + + // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: + 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_END, ldapResultAddReferral ) ); + + // State: [LDAP_RESULT_RESULT_CODE_END] - Tag: + 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: + 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: + 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: + 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: + 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: + 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: + 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: + 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_END] - Tag: + 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_END, ldapResultAddReferral ) ); + + // State: [LDAP_RESULT_ERROR_MESSAGE_END] - Tag: + 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: + 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: + 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: + 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: + 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: + 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: + 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_END] - Tag: + super.transitions[Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END].put( new Tag( "referral", Tag.START ), + new GrammarTransition( Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, + Dsmlv2StatesEnum.LDAP_RESULT_REFERRAL_END, ldapResultAddReferral ) ); + + // State: [LDAP_RESULT_REFERRAL_END] - Tag: + 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: + 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: + 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: + 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: + 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: + 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: + 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(); + + // State: [SEARCH_REPONSE] - Tag: + 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: + 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: + 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(); + super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_START] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_END] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_CONTROL_VALUE_END] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_START] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_ATTR_END] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_ENTRY_VALUE_END] = new HashMap(); + + // State: [SEARCH_RESULT_ENTRY] - Tag: + 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: + 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: + 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: + 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_END, searchResultEntryControlValueCreation ) ); + + // State: [SEARCH_RESULT_ENTRY_CONTROL_VALUE_END] - Tag: + 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: + 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: + 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: + 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: + 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: + 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: + 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_END, searchResultEntryAddValue ) ); + + // State: [SEARCH_RESULT_ENTRY_ATTR_END] - Tag: + 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: + 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_END] - Tag: + 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_END, searchResultEntryAddValue ) ); + + // State: [SEARCH_RESULT_ENTRY_VALUE_END] - Tag: + 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(); + + // State: [SEARCH_RESULT_ENTRY_LOOP] - Tag: + 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: + 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: + 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(); + super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_START] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_END] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_CONTROL_VALUE_END] = new HashMap(); + super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_END] = new HashMap(); + + // State: [SEARCH_RESULT_REFERENCE] - Tag: + 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: + super.transitions[Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE].put( new Tag( "ref", Tag.START ), + new GrammarTransition( Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE, + Dsmlv2StatesEnum.SEARCH_RESULT_REFERENCE_REF_END, searchResultReferenceAddRef ) ); + + // State: [SEARCH_RESULT_REFERENCE_CONTROL_START] - Tag: + 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_END, searchResultReferenceControlValueCreation ) ); + + // State: [sEARCH_RESULT_REFERENCE_CONTROL_VALUE_END] - Tag: + 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: + 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: + 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: + 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_END, searchResultReferenceAddRef ) ); + + // State: [SEARCH_RESULT_REFERENCE_REF_END] - Tag: + 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_END, searchResultReferenceAddRef ) ); + + // State: [SEARCH_RESULT_REFERENCE_REF_END] - Tag: + 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(); + + // State: [SEARCH_RESULT_REFERENCE_LOOP] - Tag: + 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: + 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 ) + { + batchResponse.setRequestID( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) ); + } + } + }; + + /** + * GrammarAction that creates the Add Response + */ + private final GrammarAction addResponseCreation = new GrammarAction( "Create Add Response" ) + { + public void action( Dsmlv2Container container ) throws XmlPullParserException + { + AddResponseCodec addResponse = new AddResponseCodec(); + + container.getBatchResponse().addResponse( addResponse ); + + LdapResultCodec ldapResult = new LdapResultCodec(); + + addResponse.setLdapResult( ldapResult ); + + XmlPullParser xpp = container.getParser(); + + // Checking and adding the batchRequest's attributes + String attributeValue; + // requestID + attributeValue = xpp.getAttributeValue( "", "requestID" ); + if ( attributeValue != null ) + { + addResponse.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) ); + } + // 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 + { + BindResponseCodec bindResponse = new BindResponseCodec(); + + container.getBatchResponse().addResponse( bindResponse ); + + LdapResultCodec ldapResult = new LdapResultCodec(); + + bindResponse.setLdapResult( ldapResult ); + + XmlPullParser xpp = container.getParser(); + + // Checking and adding the batchRequest's attributes + String attributeValue; + // requestID + attributeValue = xpp.getAttributeValue( "", "requestID" ); + if ( attributeValue != null ) + { + bindResponse.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) ); + + } + // 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 + { + CompareResponseCodec compareResponse = new CompareResponseCodec(); + + container.getBatchResponse().addResponse( compareResponse ); + + LdapResultCodec ldapResult = new LdapResultCodec(); + + compareResponse.setLdapResult( ldapResult ); + + XmlPullParser xpp = container.getParser(); + + // Checking and adding the batchRequest's attributes + String attributeValue; + // requestID + attributeValue = xpp.getAttributeValue( "", "requestID" ); + if ( attributeValue != null ) + { + compareResponse.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) ); + } + // 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 + { + DelResponseCodec delResponse = new DelResponseCodec(); + + container.getBatchResponse().addResponse( delResponse ); + + LdapResultCodec ldapResult = new LdapResultCodec(); + + delResponse.setLdapResult( ldapResult ); + + XmlPullParser xpp = container.getParser(); + + // Checking and adding the batchRequest's attributes + String attributeValue; + // requestID + attributeValue = xpp.getAttributeValue( "", "requestID" ); + if ( attributeValue != null ) + { + delResponse.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) ); + } + // 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 + { + ModifyResponseCodec modifyResponse = new ModifyResponseCodec(); + + container.getBatchResponse().addResponse( modifyResponse ); + + LdapResultCodec ldapResult = new LdapResultCodec(); + + modifyResponse.setLdapResult( ldapResult ); + + XmlPullParser xpp = container.getParser(); + + // Checking and adding the batchRequest's attributes + String attributeValue; + // requestID + attributeValue = xpp.getAttributeValue( "", "requestID" ); + if ( attributeValue != null ) + { + modifyResponse.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) ); + } + // 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 + { + ModifyDNResponseCodec modifyDNResponse = new ModifyDNResponseCodec(); + + container.getBatchResponse().addResponse( modifyDNResponse ); + + LdapResultCodec ldapResult = new LdapResultCodec(); + + modifyDNResponse.setLdapResult( ldapResult ); + + XmlPullParser xpp = container.getParser(); + + // Checking and adding the batchRequest's attributes + String attributeValue; + // requestID + attributeValue = xpp.getAttributeValue( "", "requestID" ); + if ( attributeValue != null ) + { + modifyDNResponse.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) ); + } + // 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 + { + ExtendedResponseCodec extendedResponse = new ExtendedResponseCodec(); + + container.getBatchResponse().addResponse( extendedResponse ); + + LdapResultCodec ldapResult = new LdapResultCodec(); + + extendedResponse.setLdapResult( ldapResult ); + + XmlPullParser xpp = container.getParser(); + + // Checking and adding the batchRequest's attributes + String attributeValue; + // requestID + attributeValue = xpp.getAttributeValue( "", "requestID" ); + if ( attributeValue != null ) + { + extendedResponse.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) ); + } + // 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 ) + { + errorResponse.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) ); + } + // 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(); + try + { + String nextText = xpp.nextText(); + if ( !nextText.equals( "" ) ) + { + errorResponse.setMessage( nextText.trim() ); + } + } + catch ( IOException e ) + { + throw new XmlPullParserException( e.getMessage(), xpp, null ); + } + } + }; + + /** + * 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, LdapMessageCodec parent ) throws XmlPullParserException + { + ControlCodec control = new ControlCodec(); + + parent.addControl( control ); + + XmlPullParser xpp = container.getParser(); + + // Checking and adding the Control's attributes + String attributeValue; + // TYPE + attributeValue = xpp.getAttributeValue( "", "type" ); + if ( attributeValue != null ) + { + if ( !OID.isOID( attributeValue ) ) + { + throw new XmlPullParserException( "Incorrect value for 'type' attribute. This is not an OID.", xpp, null ); + } + control.setControlType( attributeValue ); + } + 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 + { + LdapResponseCodec 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 + { + LdapMessageCodec 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 + { + LdapMessageCodec 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, LdapMessageCodec parent ) + throws XmlPullParserException + { + ControlCodec control = parent.getCurrentControl(); + + XmlPullParser xpp = container.getParser(); + try + { + // We have to catch the type Attribute Value before going to the next Text node + String typeValue = ParserUtils.getXsiTypeAttributeValue( xpp ); + + // Getting the value + String nextText = xpp.nextText(); + if ( !nextText.equals( "" ) ) + { + if ( ParserUtils.isBase64BinaryValue( xpp, typeValue ) ) + { + control.setControlValue( Base64.decode( nextText.trim().toCharArray() ) ); + } + else + { + control.setControlValue( nextText.trim() ); + } + } + } + catch ( IOException e ) + { + throw new XmlPullParserException( "An unexpected error ocurred : " + e.getMessage(), xpp, null ); + } + } + + /** + * 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 + { + LdapResponseCodec 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 + { + LdapMessageCodec 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 + { + LdapMessageCodec 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 + { + LdapResponseCodec ldapResponse = container.getBatchResponse().getCurrentResponse(); + + LdapResultCodec 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( ResultCodeEnum.getResultCode( 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 + { + LdapResponseCodec ldapResponse = container.getBatchResponse().getCurrentResponse(); + + LdapResultCodec 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(); + try + { + String nextText = xpp.nextText(); + if ( !nextText.equals( "" ) ) + { + ldapResult.setErrorMessage( nextText.trim() ); + } + } + catch ( IOException e ) + { + throw new XmlPullParserException( "An unexpected error ocurred : " + e.getMessage(), xpp, null ); + } + } + }; + + /** + * 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 + { + LdapResponseCodec ldapResponse = container.getBatchResponse().getCurrentResponse(); + + LdapResultCodec 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(); + try + { + String nextText = xpp.nextText(); + if ( !nextText.equals( "" ) ) + { + try + { + ldapResult.addReferral( new LdapURL( nextText.trim() ) ); + } + catch ( LdapURLEncodingException e ) + { + throw new XmlPullParserException( e.getMessage(), xpp, null ); + } + } + } + catch ( IOException e ) + { + throw new XmlPullParserException( "An unexpected error ocurred : " + 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 ) + { + searchResponse.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) ); + } + } + }; + + /** + * 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 + { + SearchResultEntryCodec searchResultEntry = new SearchResultEntryCodec(); + + 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 ) + { + searchResultEntry.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) ); + } + // 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 + { + SearchResultReferenceCodec searchResultReference = new SearchResultReferenceCodec(); + + 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 ) + { + searchResultReference.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) ); + } + } + }; + + /** + * 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 + { + SearchResultDoneCodec searchResultDone = new SearchResultDoneCodec(); + + searchResultDone.setLdapResult( new LdapResultCodec() ); + + 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 ) + { + searchResultDone.setMessageId( ParserUtils.parseAndVerifyRequestID( attributeValue, xpp ) ); + } + // 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" ) + { + public void action( Dsmlv2Container container ) throws XmlPullParserException + { + SearchResponse searchResponse = ( SearchResponse ) container.getBatchResponse().getCurrentResponse(); + + SearchResultEntryCodec searchResultEntry = searchResponse.getCurrentSearchResultEntry(); + + XmlPullParser xpp = container.getParser(); + + // Checking and adding the request's attributes + String attributeValue; + // name + attributeValue = xpp.getAttributeValue( "", "name" ); + if ( attributeValue != null ) + { + searchResultEntry.addAttributeValues( attributeValue ); + } + else + { + throw new XmlPullParserException( "name attribute is required", xpp, null ); + } + } + }; + + /** + * GrammarAction that adds a Value to an Attr of a Search Result Entry + */ + private final GrammarAction searchResultEntryAddValue = new GrammarAction( + "Add a Value to an Attr of a Search Result Entry" ) + { + public void action( Dsmlv2Container container ) throws XmlPullParserException + { + SearchResponse searchResponse = ( SearchResponse ) container.getBatchResponse().getCurrentResponse(); + SearchResultEntryCodec searchResultEntry = searchResponse.getCurrentSearchResultEntry(); + + XmlPullParser xpp = container.getParser(); + try + { + // We have to catch the type Attribute Value before going to the next Text node + String typeValue = ParserUtils.getXsiTypeAttributeValue( xpp ); + + // Getting the value + String nextText = xpp.nextText(); + if ( ParserUtils.isBase64BinaryValue( xpp, typeValue ) ) + { + searchResultEntry.addAttributeValue( Base64.decode( nextText.toCharArray() ) ); + } + else + { + searchResultEntry.addAttributeValue( nextText ); + } + } + catch ( IOException e ) + { + throw new XmlPullParserException( "An unexpected error ocurred : " + e.getMessage(), xpp, null ); + } + } + }; + + /** + * GrammarAction that adds a Ref to a Search Result Reference + */ + private final GrammarAction searchResultReferenceAddRef = new GrammarAction( + "Add a Ref to a Search Result Reference" ) + { + public void action( Dsmlv2Container container ) throws XmlPullParserException + { + SearchResponse searchResponse = ( SearchResponse ) container.getBatchResponse().getCurrentResponse(); + SearchResultReferenceCodec searchResultReference = searchResponse.getCurrentSearchResultReference(); + + XmlPullParser xpp = container.getParser(); + try + { + String nextText = xpp.nextText(); + if ( !nextText.equals( "" ) ) + { + searchResultReference.addSearchResultReference( new LdapURL( nextText ) ); + } + } + catch ( IOException e ) + { + throw new XmlPullParserException( "An unexpected error ocurred : " + e.getMessage(), xpp, null ); + } + catch ( LdapURLEncodingException e ) + { + throw new XmlPullParserException( e.getMessage(), xpp, null ); + } + } + }; + + /** + * GrammarAction that adds Result Code to an Extended Response + */ + private final GrammarAction extendedResponseAddResultCode = ldapResultAddResultCode; + + /** + * GrammarAction that creates the Search Response + */ + private final GrammarAction extendedResponseAddErrorMessage = ldapResultAddErrorMessage; + + /** + * GrammarAction that adds a Referral to an Extended Response + */ + private final GrammarAction extendedResponseAddReferral = ldapResultAddReferral; + + /** + * GrammarAction that adds a Response Name to an Extended Response + */ + private final GrammarAction extendedResponseAddResponseName = new GrammarAction( + "Add Response Name to Extended Response" ) + { + public void action( Dsmlv2Container container ) throws XmlPullParserException + { + ExtendedResponseCodec extendedResponse = ( ExtendedResponseCodec ) container.getBatchResponse().getCurrentResponse(); + + XmlPullParser xpp = container.getParser(); + try + { + String nextText = xpp.nextText(); + if ( !nextText.equals( "" ) ) + { + extendedResponse.setResponseName( new OID( nextText.trim() ) ); + } + + } + catch ( IOException e ) + { + throw new XmlPullParserException( "An unexpected error ocurred : " + e.getMessage(), xpp, null ); + } + catch ( DecoderException e ) + { + throw new XmlPullParserException( e.getMessage(), xpp, null ); + } + } + }; + + /** + * GrammarAction that adds a Response to an Extended Response + */ + private final GrammarAction extendedResponseAddResponse = new GrammarAction( "Add Response to Extended Response" ) + { + public void action( Dsmlv2Container container ) throws XmlPullParserException + { [... 39 lines stripped ...]