/* * @(#)ClientRequestInfoImpl.java 1.45 04/06/21 * * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package com.sun.corba.se.impl.interceptors; import java.util.HashMap ; import org.omg.CORBA.Any; import org.omg.CORBA.BAD_INV_ORDER; import org.omg.CORBA.BAD_PARAM; import org.omg.CORBA.CompletionStatus; import org.omg.CORBA.Context; import org.omg.CORBA.ContextList; import org.omg.CORBA.CTX_RESTRICT_SCOPE; import org.omg.CORBA.ExceptionList; import org.omg.CORBA.LocalObject; import org.omg.CORBA.NamedValue; import org.omg.CORBA.NO_IMPLEMENT; import org.omg.CORBA.NO_RESOURCES; import org.omg.CORBA.NVList; import org.omg.CORBA.Object; import org.omg.CORBA.ParameterMode; import org.omg.CORBA.Policy; import org.omg.CORBA.SystemException; import org.omg.CORBA.TypeCode; import org.omg.CORBA.INTERNAL; import org.omg.CORBA.UserException; import org.omg.CORBA.portable.ApplicationException; import org.omg.CORBA.portable.InputStream; import com.sun.corba.se.spi.servicecontext.ServiceContexts; import com.sun.corba.se.spi.servicecontext.UnknownServiceContext; import org.omg.IOP.ServiceContext; import org.omg.IOP.ServiceContextHelper; import org.omg.IOP.TaggedProfile; import org.omg.IOP.TaggedProfileHelper; import org.omg.IOP.TaggedComponent; import org.omg.IOP.TaggedComponentHelper; import org.omg.IOP.TAG_INTERNET_IOP; import org.omg.Dynamic.Parameter; import org.omg.PortableInterceptor.ClientRequestInfo; import org.omg.PortableInterceptor.LOCATION_FORWARD; import org.omg.PortableInterceptor.SUCCESSFUL; import org.omg.PortableInterceptor.SYSTEM_EXCEPTION; import org.omg.PortableInterceptor.TRANSPORT_RETRY; import org.omg.PortableInterceptor.USER_EXCEPTION; import com.sun.corba.se.pept.protocol.MessageMediator; import com.sun.corba.se.spi.ior.IOR; import com.sun.corba.se.spi.ior.iiop.IIOPProfileTemplate; import com.sun.corba.se.spi.ior.iiop.GIOPVersion; import com.sun.corba.se.spi.orb.ORB; import com.sun.corba.se.spi.protocol.CorbaMessageMediator; import com.sun.corba.se.spi.transport.CorbaContactInfo; import com.sun.corba.se.spi.transport.CorbaContactInfoList; import com.sun.corba.se.spi.transport.CorbaContactInfoListIterator; import com.sun.corba.se.impl.encoding.CDROutputStream; import com.sun.corba.se.impl.encoding.CDRInputStream_1_0; import com.sun.corba.se.impl.orbutil.ORBUtility; import com.sun.corba.se.impl.protocol.CorbaInvocationInfo; import com.sun.corba.se.impl.util.RepositoryId; /** * Implementation of the ClientRequestInfo interface as specified in * orbos/99-12-02 section 5.4.2. */ public final class ClientRequestInfoImpl extends RequestInfoImpl implements ClientRequestInfo { // The available constants for startingPointCall static final int CALL_SEND_REQUEST = 0; static final int CALL_SEND_POLL = 1; // The available constants for endingPointCall static final int CALL_RECEIVE_REPLY = 0; static final int CALL_RECEIVE_EXCEPTION = 1; static final int CALL_RECEIVE_OTHER = 2; ////////////////////////////////////////////////////////////////////// // // NOTE: IF AN ATTRIBUTE IS ADDED, PLEASE UPDATE RESET(); // ////////////////////////////////////////////////////////////////////// // The current retry request status. True if this request is being // retried and this info object is to be reused, or false otherwise. private boolean retryRequest; // The number of times this info object has been (re)used. This is // incremented every time a request is retried, and decremented every // time a request is complete. When this reaches zero, the info object // is popped from the ClientRequestInfoImpl ThreadLocal stack in the ORB. private int entryCount = 0; // The RequestImpl is set when the call is DII based. // The DII query calls like ParameterList, ExceptionList, // ContextList will be delegated to RequestImpl. private org.omg.CORBA.Request request; // Sources of client request information private boolean diiInitiate; private CorbaMessageMediator messageMediator; // Cached information: private org.omg.CORBA.Object cachedTargetObject; private org.omg.CORBA.Object cachedEffectiveTargetObject; private Parameter[] cachedArguments; private TypeCode[] cachedExceptions; private String[] cachedContexts; private String[] cachedOperationContext; private String cachedReceivedExceptionId; private Any cachedResult; private Any cachedReceivedException; private TaggedProfile cachedEffectiveProfile; // key = Integer, value = IOP.ServiceContext. private HashMap cachedRequestServiceContexts; // key = Integer, value = IOP.ServiceContext. private HashMap cachedReplyServiceContexts; // key = Integer, value = TaggedComponent private HashMap cachedEffectiveComponents; protected boolean piCurrentPushed; ////////////////////////////////////////////////////////////////////// // // NOTE: IF AN ATTRIBUTE IS ADDED, PLEASE UPDATE RESET(); // ////////////////////////////////////////////////////////////////////// /** * Reset the info object so that it can be reused for a retry, * for example. */ void reset() { super.reset(); // Please keep these in the same order that they're declared above. retryRequest = false; // Do not reset entryCount because we need to know when to pop this // from the stack. request = null; diiInitiate = false; messageMediator = null; // Clear cached attributes: cachedTargetObject = null; cachedEffectiveTargetObject = null; cachedArguments = null; cachedExceptions = null; cachedContexts = null; cachedOperationContext = null; cachedReceivedExceptionId = null; cachedResult = null; cachedReceivedException = null; cachedEffectiveProfile = null; cachedRequestServiceContexts = null; cachedReplyServiceContexts = null; cachedEffectiveComponents = null; piCurrentPushed = false; startingPointCall = CALL_SEND_REQUEST; endingPointCall = CALL_RECEIVE_REPLY; } /* ********************************************************************** * Access protection **********************************************************************/ // Method IDs for all methods in ClientRequestInfo. This allows for a // convenient O(1) lookup for checkAccess(). protected static final int MID_TARGET = MID_RI_LAST + 1; protected static final int MID_EFFECTIVE_TARGET = MID_RI_LAST + 2; protected static final int MID_EFFECTIVE_PROFILE = MID_RI_LAST + 3; protected static final int MID_RECEIVED_EXCEPTION = MID_RI_LAST + 4; protected static final int MID_RECEIVED_EXCEPTION_ID = MID_RI_LAST + 5; protected static final int MID_GET_EFFECTIVE_COMPONENT = MID_RI_LAST + 6; protected static final int MID_GET_EFFECTIVE_COMPONENTS = MID_RI_LAST + 7; protected static final int MID_GET_REQUEST_POLICY = MID_RI_LAST + 8; protected static final int MID_ADD_REQUEST_SERVICE_CONTEXT = MID_RI_LAST + 9; // ClientRequestInfo validity table (see ptc/00-08-06 table 21-1). // Note: These must be in the same order as specified in contants. protected static final boolean validCall[][] = { // LEGEND: // s_req = send_request r_rep = receive_reply // s_pol = send_poll r_exc = receive_exception // r_oth = receive_other // // A true value indicates call is valid at specified point. // A false value indicates the call is invalid. // // // NOTE: If the order or number of columns change, update // checkAccess() accordingly. // // { s_req, s_pol, r_rep, r_exc, r_oth } // RequestInfo methods: /*request_id*/ { true , true , true , true , true }, /*operation*/ { true , true , true , true , true }, /*arguments*/ { true , false, true , false, false }, /*exceptions*/ { true , false, true , true , true }, /*contexts*/ { true , false, true , true , true }, /*operation_context*/ { true , false, true , true , true }, /*result*/ { false, false, true , false, false }, /*response_expected*/ { true , true , true , true , true }, /*sync_scope*/ { true , false, true , true , true }, /*reply_status*/ { false, false, true , true , true }, /*forward_reference*/ { false, false, false, false, true }, /*get_slot*/ { true , true , true , true , true }, /*get_request_service_context*/ { true , false, true , true , true }, /*get_reply_service_context*/ { false, false, true , true , true }, // // ClientRequestInfo methods:: /*target*/ { true , true , true , true , true }, /*effective_target*/ { true , true , true , true , true }, /*effective_profile*/ { true , true , true , true , true }, /*received_exception*/ { false, false, false, true , false }, /*received_exception_id*/ { false, false, false, true , false }, /*get_effective_component*/ { true , false, true , true , true }, /*get_effective_components*/ { true , false, true , true , true }, /*get_request_policy*/ { true , false, true , true , true }, /*add_request_service_context*/ { true , false, false, false, false } }; /* ********************************************************************** * Public ClientRequestInfo interfaces **********************************************************************/ /** * Creates a new ClientRequestInfo implementation. * The constructor is package scope since no other package need create * an instance of this class. */ protected ClientRequestInfoImpl( ORB myORB ) { super( myORB ); startingPointCall = CALL_SEND_REQUEST; endingPointCall = CALL_RECEIVE_REPLY; } /** * The object which the client called to perform the operation. */ public org.omg.CORBA.Object target (){ // access is currently valid for all states: //checkAccess( MID_TARGET ); if (cachedTargetObject == null) { CorbaContactInfo corbaContactInfo = (CorbaContactInfo) messageMediator.getContactInfo(); cachedTargetObject = iorToObject(corbaContactInfo.getTargetIOR()); } return cachedTargetObject; } /** * The actual object on which the operation will be invoked. If the * reply_status is LOCATION_FORWARD, then on subsequent requests, * effective_target will contain the forwarded IOR while target will * remain unchanged. */ public org.omg.CORBA.Object effective_target() { // access is currently valid for all states: //checkAccess( MID_EFFECTIVE_TARGET ); // Note: This is not necessarily the same as locatedIOR. // Reason: See the way we handle COMM_FAILURES in // ClientRequestDispatcher.createRequest, v1.32 if (cachedEffectiveTargetObject == null) { CorbaContactInfo corbaContactInfo = (CorbaContactInfo) messageMediator.getContactInfo(); // REVISIT - get through chain like getLocatedIOR helper below. cachedEffectiveTargetObject = iorToObject(corbaContactInfo.getEffectiveTargetIOR()); } return cachedEffectiveTargetObject; } /** * The profile that will be used to send the request. If a location * forward has occurred for this operation's object and that object's * profile change accordingly, then this profile will be that located * profile. */ public TaggedProfile effective_profile (){ // access is currently valid for all states: //checkAccess( MID_EFFECTIVE_PROFILE ); if( cachedEffectiveProfile == null ) { CorbaContactInfo corbaContactInfo = (CorbaContactInfo) messageMediator.getContactInfo(); cachedEffectiveProfile = corbaContactInfo.getEffectiveProfile().getIOPProfile(); } // Good citizen: In the interest of efficiency, we assume interceptors // will not modify the returned TaggedProfile in any way so we need // not make a deep copy of it. return cachedEffectiveProfile; } /** * Contains the exception to be returned to the client. */ public Any received_exception (){ checkAccess( MID_RECEIVED_EXCEPTION ); if( cachedReceivedException == null ) { cachedReceivedException = exceptionToAny( exception ); } // Good citizen: In the interest of efficiency, we assume interceptors // will not modify the returned Any in any way so we need // not make a deep copy of it. return cachedReceivedException; } /** * The CORBA::RepositoryId of the exception to be returned to the client. */ public String received_exception_id (){ checkAccess( MID_RECEIVED_EXCEPTION_ID ); if( cachedReceivedExceptionId == null ) { String result = null; if( exception == null ) { // Note: exception should never be null here since we will // throw a BAD_INV_ORDER if this is not called from // receive_exception. throw wrapper.exceptionWasNull() ; } else if( exception instanceof SystemException ) { String name = exception.getClass().getName(); result = ORBUtility.repositoryIdOf(name); } else if( exception instanceof ApplicationException ) { result = ((ApplicationException)exception).getId(); } // _REVISIT_ We need to be able to handle a UserException in the // DII case. How do we extract the ID from a UserException? cachedReceivedExceptionId = result; } return cachedReceivedExceptionId; } /** * Returns the IOP::TaggedComponent with the given ID from the profile * selected for this request. IF there is more than one component for a * given component ID, it is undefined which component this operation * returns (get_effective_component should be called instead). */ public TaggedComponent get_effective_component (int id){ checkAccess( MID_GET_EFFECTIVE_COMPONENT ); return get_effective_components( id )[0]; } /** * Returns all the tagged components with the given ID from the profile * selected for this request. */ public TaggedComponent[] get_effective_components (int id){ checkAccess( MID_GET_EFFECTIVE_COMPONENTS ); Integer integerId = new Integer( id ); TaggedComponent[] result = null; boolean justCreatedCache = false; if( cachedEffectiveComponents == null ) { cachedEffectiveComponents = new HashMap(); justCreatedCache = true; } else { // Look in cache: result = (TaggedComponent[])cachedEffectiveComponents.get( integerId ); } // null could mean we cached null or not in cache. if( (result == null) && (justCreatedCache || !cachedEffectiveComponents.containsKey( integerId ) ) ) { // Not in cache. Get it from the profile: CorbaContactInfo corbaContactInfo = (CorbaContactInfo) messageMediator.getContactInfo(); IIOPProfileTemplate ptemp = (IIOPProfileTemplate)corbaContactInfo.getEffectiveProfile(). getTaggedProfileTemplate(); result = ptemp.getIOPComponents(myORB, id); cachedEffectiveComponents.put( integerId, result ); } // As per ptc/00-08-06, section 21.3.13.6., If not found, raise // BAD_PARAM with minor code INVALID_COMPONENT_ID. if( (result == null) || (result.length == 0) ) { throw stdWrapper.invalidComponentId( integerId ) ; } // Good citizen: In the interest of efficiency, we will assume // interceptors will not modify the returned TaggedCompoent[], or // the TaggedComponents inside of it. Otherwise, we would need to // clone the array and make a deep copy of its contents. return result; } /** * Returns the given policy in effect for this operation. */ public Policy get_request_policy (int type){ checkAccess( MID_GET_REQUEST_POLICY ); // _REVISIT_ Our ORB is not policy-based at this time. throw wrapper.piOrbNotPolicyBased() ; } /** * Allows interceptors to add service contexts to the request. *

* There is no declaration of the order of the service contexts. They * may or may not appear in the order they are added. */ public void add_request_service_context (ServiceContext service_context, boolean replace) { checkAccess( MID_ADD_REQUEST_SERVICE_CONTEXT ); if( cachedRequestServiceContexts == null ) { cachedRequestServiceContexts = new HashMap(); } addServiceContext( cachedRequestServiceContexts, messageMediator.getRequestServiceContexts(), service_context, replace ); } // NOTE: When adding a method, be sure to: // 1. Add a MID_* constant for that method // 2. Call checkAccess at the start of the method // 3. Define entries in the validCall[][] table for interception points. /* ********************************************************************** * Public RequestInfo interfaces * * These are implemented here because they have differing * implementations depending on whether this is a client or a server * request info object. **********************************************************************/ /** * See RequestInfoImpl for javadoc. */ public int request_id (){ // access is currently valid for all states: //checkAccess( MID_REQUEST_ID ); /* * NOTE: The requestId in client interceptors is the same as the * GIOP request id. This works because both interceptors and * request ids are scoped by the ORB on the client side. */ return messageMediator.getRequestId(); } /** * See RequestInfoImpl for javadoc. */ public String operation (){ // access is currently valid for all states: //checkAccess( MID_OPERATION ); return messageMediator.getOperationName(); } /** * See RequestInfoImpl for javadoc. */ public Parameter[] arguments (){ checkAccess( MID_ARGUMENTS ); if( cachedArguments == null ) { if( request == null ) { throw stdWrapper.piOperationNotSupported1() ; } // If it is DII request then get the arguments from the DII req // and convert that into parameters. cachedArguments = nvListToParameterArray( request.arguments() ); } // Good citizen: In the interest of efficiency, we assume // interceptors will be "good citizens" in that they will not // modify the contents of the Parameter[] array. We also assume // they will not change the values of the containing Anys. return cachedArguments; } /** * See RequestInfoImpl for javadoc. */ public TypeCode[] exceptions (){ checkAccess( MID_EXCEPTIONS ); if( cachedExceptions == null ) { if( request == null ) { throw stdWrapper.piOperationNotSupported2() ; } // Get the list of exceptions from DII request data, If there are // no exceptions raised then this method will return null. ExceptionList excList = request.exceptions( ); int count = excList.count(); TypeCode[] excTCList = new TypeCode[count]; try { for( int i = 0; i < count; i++ ) { excTCList[i] = excList.item( i ); } } catch( Exception e ) { throw wrapper.exceptionInExceptions( e ) ; } cachedExceptions = excTCList; } // Good citizen: In the interest of efficiency, we assume // interceptors will be "good citizens" in that they will not // modify the contents of the TypeCode[] array. We also assume // they will not change the values of the containing TypeCodes. return cachedExceptions; } /** * See RequestInfoImpl for javadoc. */ public String[] contexts (){ checkAccess( MID_CONTEXTS ); if( cachedContexts == null ) { if( request == null ) { throw stdWrapper.piOperationNotSupported3() ; } // Get the list of contexts from DII request data, If there are // no contexts then this method will return null. ContextList ctxList = request.contexts( ); int count = ctxList.count(); String[] ctxListToReturn = new String[count]; try { for( int i = 0; i < count; i++ ) { ctxListToReturn[i] = ctxList.item( i ); } } catch( Exception e ) { throw wrapper.exceptionInContexts( e ) ; } cachedContexts = ctxListToReturn; } // Good citizen: In the interest of efficiency, we assume // interceptors will be "good citizens" in that they will not // modify the contents of the String[] array. return cachedContexts; } /** * See RequestInfoImpl for javadoc. */ public String[] operation_context (){ checkAccess( MID_OPERATION_CONTEXT ); if( cachedOperationContext == null ) { if( request == null ) { throw stdWrapper.piOperationNotSupported4() ; } // Get the list of contexts from DII request data, If there are // no contexts then this method will return null. Context ctx = request.ctx( ); // _REVISIT_ The API for get_values is not compliant with the spec, // Revisit this code once it's fixed. // _REVISIT_ Our ORB doesn't support Operation Context, This code // will not be excerscised until it's supported. // The first parameter in get_values is the start_scope which // if blank makes it as a global scope. // The second parameter is op_flags which is set to RESTRICT_SCOPE // As there is only one defined in the spec. // The Third param is the pattern which is '*' requiring it to // get all the contexts. NVList nvList = ctx.get_values( "", CTX_RESTRICT_SCOPE.value,"*" ); String[] context = new String[(nvList.count() * 2) ]; if( ( nvList != null ) &&( nvList.count() != 0 ) ) { // The String[] array will contain Name and Value for each // context and hence double the size in the array. int index = 0; for( int i = 0; i < nvList.count(); i++ ) { NamedValue nv; try { nv = nvList.item( i ); } catch (Exception e ) { return (String[]) null; } context[index] = nv.name(); index++; context[index] = nv.value().extract_string(); index++; } } cachedOperationContext = context; } // Good citizen: In the interest of efficiency, we assume // interceptors will be "good citizens" in that they will not // modify the contents of the String[] array. return cachedOperationContext; } /** * See RequestInfoImpl for javadoc. */ public Any result (){ checkAccess( MID_RESULT ); if( cachedResult == null ) { if( request == null ) { throw stdWrapper.piOperationNotSupported5() ; } // Get the result from the DII request data. NamedValue nvResult = request.result( ); if( nvResult == null ) { throw wrapper.piDiiResultIsNull() ; } cachedResult = nvResult.value(); } // Good citizen: In the interest of efficiency, we assume that // interceptors will not modify the contents of the result Any. // Otherwise, we would need to create a deep copy of the Any. return cachedResult; } /** * See RequestInfoImpl for javadoc. */ public boolean response_expected (){ // access is currently valid for all states: //checkAccess( MID_RESPONSE_EXPECTED ); return ! messageMediator.isOneWay(); } /** * See RequestInfoImpl for javadoc. */ public Object forward_reference (){ checkAccess( MID_FORWARD_REFERENCE ); // Check to make sure we are in LOCATION_FORWARD // state as per ptc/00-08-06, table 21-1 // footnote 2. if( replyStatus != LOCATION_FORWARD.value ) { throw stdWrapper.invalidPiCall1() ; } // Do not cache this value since if an interceptor raises // forward request then the next interceptor in the // list should see the new value. IOR ior = getLocatedIOR(); return iorToObject(ior); } private IOR getLocatedIOR() { IOR ior; CorbaContactInfoList contactInfoList = (CorbaContactInfoList) messageMediator.getContactInfo().getContactInfoList(); ior = contactInfoList.getEffectiveTargetIOR(); return ior; } protected void setLocatedIOR(IOR ior) { ORB orb = (ORB) messageMediator.getBroker(); CorbaContactInfoListIterator iterator = (CorbaContactInfoListIterator) ((CorbaInvocationInfo)orb.getInvocationInfo()) .getContactInfoListIterator(); // REVISIT - this most likely causes reportRedirect to happen twice. // Once here and once inside the request dispatcher. iterator.reportRedirect( (CorbaContactInfo)messageMediator.getContactInfo(), ior); } /** * See RequestInfoImpl for javadoc. */ public org.omg.IOP.ServiceContext get_request_service_context( int id ) { checkAccess( MID_GET_REQUEST_SERVICE_CONTEXT ); if( cachedRequestServiceContexts == null ) { cachedRequestServiceContexts = new HashMap(); } return getServiceContext(cachedRequestServiceContexts, messageMediator.getRequestServiceContexts(), id); } /** * does not contain an etry for that ID, BAD_PARAM with a minor code of * TBD_BP is raised. */ public org.omg.IOP.ServiceContext get_reply_service_context( int id ) { checkAccess( MID_GET_REPLY_SERVICE_CONTEXT ); if( cachedReplyServiceContexts == null ) { cachedReplyServiceContexts = new HashMap(); } // In the event this is called from a oneway, we will have no // response object. // // In the event this is called after a IIOPConnection.purgeCalls, // we will have a response object, but that object will // not contain a header (which would hold the service context // container). See bug 4624102. // // REVISIT: this is the only thing used // from response at this time. However, a more general solution // would avoid accessing other parts of response's header. // // Instead of throwing a NullPointer, we will // "gracefully" handle these with a BAD_PARAM with minor code 25. try { ServiceContexts serviceContexts = messageMediator.getReplyServiceContexts(); if (serviceContexts == null) { throw new NullPointerException(); } return getServiceContext(cachedReplyServiceContexts, serviceContexts, id); } catch (NullPointerException e) { // REVISIT how this is programmed - not what it does. // See purge calls test. The waiter is woken up by the // call to purge calls - but there is no reply containing // service contexts. throw stdWrapper.invalidServiceContextId( e ) ; } } // // REVISIT // Override RequestInfoImpl connection to work in framework. // public com.sun.corba.se.spi.legacy.connection.Connection connection() { return (com.sun.corba.se.spi.legacy.connection.Connection) messageMediator.getConnection(); } /* ********************************************************************** * Package-scope interfaces **********************************************************************/ protected void setInfo(MessageMediator messageMediator) { this.messageMediator = (CorbaMessageMediator)messageMediator; // REVISIT - so mediator can handle DII in subcontract. this.messageMediator.setDIIInfo(request); } /** * Set or reset the retry request flag. */ void setRetryRequest( boolean retryRequest ) { this.retryRequest = retryRequest; } /** * Retrieve the current retry request status. */ boolean getRetryRequest() { return this.retryRequest; } /** * Increases the entry count by 1. */ void incrementEntryCount() { this.entryCount++; } /** * Decreases the entry count by 1. */ void decrementEntryCount() { this.entryCount--; } /** * Retrieve the current entry count */ int getEntryCount() { return this.entryCount; } /** * Overridden from RequestInfoImpl. Calls the super class, then * sets the ending point call depending on the reply status. */ protected void setReplyStatus( short replyStatus ) { super.setReplyStatus( replyStatus ); switch( replyStatus ) { case SUCCESSFUL.value: endingPointCall = CALL_RECEIVE_REPLY; break; case SYSTEM_EXCEPTION.value: case USER_EXCEPTION.value: endingPointCall = CALL_RECEIVE_EXCEPTION; break; case LOCATION_FORWARD.value: case TRANSPORT_RETRY.value: endingPointCall = CALL_RECEIVE_OTHER; break; } } /** * Sets DII request object in the RequestInfoObject. */ protected void setDIIRequest(org.omg.CORBA.Request req) { request = req; } /** * Keeps track of whether initiate was called for a DII request. The ORB * needs to know this so it knows whether to ignore a second call to * initiateClientPIRequest or not. */ protected void setDIIInitiate( boolean diiInitiate ) { this.diiInitiate = diiInitiate; } /** * See comment for setDIIInitiate */ protected boolean isDIIInitiate() { return this.diiInitiate; } /** * The PICurrent stack should only be popped if it was pushed. * This is generally the case. But exceptions which occur * after the stub's entry to _request but before the push * end up in _releaseReply which will try to pop unless told not to. */ protected void setPICurrentPushed( boolean piCurrentPushed ) { this.piCurrentPushed = piCurrentPushed; } protected boolean isPICurrentPushed() { return this.piCurrentPushed; } /** * Overridden from RequestInfoImpl. */ protected void setException( Exception exception ) { super.setException( exception ); // Clear cached values: cachedReceivedException = null; cachedReceivedExceptionId = null; } protected boolean getIsOneWay() { return ! response_expected(); } /** * See description for RequestInfoImpl.checkAccess */ protected void checkAccess( int methodID ) throws BAD_INV_ORDER { // Make sure currentPoint matches the appropriate index in the // validCall table: int validCallIndex = 0; switch( currentExecutionPoint ) { case EXECUTION_POINT_STARTING: switch( startingPointCall ) { case CALL_SEND_REQUEST: validCallIndex = 0; break; case CALL_SEND_POLL: validCallIndex = 1; break; } break; case EXECUTION_POINT_ENDING: switch( endingPointCall ) { case CALL_RECEIVE_REPLY: validCallIndex = 2; break; case CALL_RECEIVE_EXCEPTION: validCallIndex = 3; break; case CALL_RECEIVE_OTHER: validCallIndex = 4; break; } break; } // Check the validCall table: if( !validCall[methodID][validCallIndex] ) { throw stdWrapper.invalidPiCall2() ; } } } // End of file.