/*
 * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package com.sun.corba.se.impl.interceptors;

import java.io.IOException ;

import java.lang.reflect.Method ;
import java.lang.reflect.InvocationTargetException ;

import java.util.HashMap ;

import org.omg.PortableInterceptor.ForwardRequest;
import org.omg.PortableInterceptor.InvalidSlot;
import org.omg.PortableInterceptor.RequestInfo;
import org.omg.PortableInterceptor.LOCATION_FORWARD;
import org.omg.IOP.TaggedProfile;
import org.omg.IOP.TaggedComponent;
import org.omg.IOP.ServiceContextHelper;
import org.omg.Messaging.SYNC_WITH_TRANSPORT;
import org.omg.CORBA.ParameterMode;

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.INTERNAL;
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.Policy;
import org.omg.CORBA.SystemException;
import org.omg.CORBA.TypeCode;
import org.omg.CORBA.UNKNOWN;
import org.omg.CORBA.UserException;
import org.omg.CORBA.portable.ApplicationException;
import org.omg.CORBA.portable.Delegate;
import org.omg.CORBA.portable.InputStream;

import org.omg.Dynamic.Parameter;

import com.sun.corba.se.spi.legacy.connection.Connection;

import com.sun.corba.se.spi.legacy.interceptor.RequestInfoExt;

import com.sun.corba.se.spi.ior.IOR;

import com.sun.corba.se.spi.ior.iiop.GIOPVersion;

import com.sun.corba.se.spi.orb.ORB;

import com.sun.corba.se.spi.logging.CORBALogDomains;

import com.sun.corba.se.spi.servicecontext.ServiceContexts;
import com.sun.corba.se.spi.servicecontext.UnknownServiceContext;

import com.sun.corba.se.impl.encoding.CDRInputStream_1_0;
import com.sun.corba.se.impl.encoding.EncapsOutputStream;

import com.sun.corba.se.impl.orbutil.ORBUtility;
import com.sun.corba.se.impl.orbutil.ORBClassLoader;

import com.sun.corba.se.impl.util.RepositoryId;

import com.sun.corba.se.impl.logging.InterceptorsSystemException;
import com.sun.corba.se.impl.logging.OMGSystemException;

/**
 * Implementation of the RequestInfo interface as specified in
 * orbos/99-12-02 section 5.4.1.
 */
public abstract class RequestInfoImpl
    extends LocalObject
    implements RequestInfo, RequestInfoExt
{
    //////////////////////////////////////////////////////////////////////
    //
    // NOTE: IF AN ATTRIBUTE IS ADDED, PLEASE UPDATE RESET();
    //
    //////////////////////////////////////////////////////////////////////

    // The ORB from which to get PICurrent and other info
    protected ORB myORB;
    protected InterceptorsSystemException wrapper ;
    protected OMGSystemException stdWrapper ;

    // The number of interceptors actually invoked for this client request.
    // See setFlowStackIndex for a detailed description.
    protected int flowStackIndex = 0;

    // The type of starting point call to make to the interceptors
    // See ClientRequestInfoImpl and ServerRequestInfoImpl for a list of
    // appropriate constants.
    protected int startingPointCall;

    // The type of intermediate point call to make to the interceptors
    // See ServerRequestInfoImpl for a list of appropriate constants.
    // This does not currently apply to client request interceptors but is
    // here in case intermediate points are introduced in the future.
    protected int intermediatePointCall;

    // The type of ending point call to make to the interceptors
    // See ClientRequestInfoImpl and ServerRequestInfoImpl for a list of
    // appropriate constants.
    protected int endingPointCall;

    // The reply status to return in reply_status.  This is initialized
    // to UNINITIALIZED so that we can tell if this has been set or not.
    protected short replyStatus = UNINITIALIZED;

    // Constant for an uninitizlied reply status.
    protected static final short UNINITIALIZED = -1;

    // Which points we are currently executing (so we can implement the
    // validity table).
    protected int currentExecutionPoint;
    protected static final int EXECUTION_POINT_STARTING = 0;
    protected static final int EXECUTION_POINT_INTERMEDIATE = 1;
    protected static final int EXECUTION_POINT_ENDING = 2;

    // Set to true if all interceptors have had all their points
    // executed.
    protected boolean alreadyExecuted;

    // Sources of request information
    protected Connection     connection;
    protected ServiceContexts serviceContexts;

    // The ForwardRequest object if this request is being forwarded.
    // Either the forwardRequest or the forwardRequestIOR field is set.
    // When set, the other field is set to null initially.  If the other
    // field is queried, it is lazily calculated and cached.  These
    // two attributes are always kept in sync.
    protected ForwardRequest forwardRequest;
    protected IOR forwardRequestIOR;

    // PICurrent's  SlotTable
    protected SlotTable slotTable;

    // The exception to be returned by received_exception and
    // received_exception_id
    protected Exception exception;

    //////////////////////////////////////////////////////////////////////
    //
    // 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() {

        // Please keep these in the same order as declared above.

        flowStackIndex = 0;
        startingPointCall = 0;
        intermediatePointCall = 0;
        endingPointCall = 0;
        // 6763340
        setReplyStatus( UNINITIALIZED ) ;
        currentExecutionPoint = EXECUTION_POINT_STARTING;
        alreadyExecuted = false;
        connection = null;
        serviceContexts = null;
        forwardRequest = null;
        forwardRequestIOR = null;
        exception = null;

        // We don't need to reset the Slots because they are
        // already in the clean state after recieve_<point> interceptor
        // are called.
    }

    /*
     **********************************************************************
     * Access protection
     **********************************************************************/

    // Method IDs for all methods in RequestInfo.  This allows for a
    // convenient O(1) lookup for checkAccess().
    protected static final int MID_REQUEST_ID                   =  0;
    protected static final int MID_OPERATION                    =  1;
    protected static final int MID_ARGUMENTS                    =  2;
    protected static final int MID_EXCEPTIONS                   =  3;
    protected static final int MID_CONTEXTS                     =  4;
    protected static final int MID_OPERATION_CONTEXT            =  5;
    protected static final int MID_RESULT                       =  6;
    protected static final int MID_RESPONSE_EXPECTED            =  7;
    protected static final int MID_SYNC_SCOPE                   =  8;
    protected static final int MID_REPLY_STATUS                 =  9;
    protected static final int MID_FORWARD_REFERENCE            = 10;
    protected static final int MID_GET_SLOT                     = 11;
    protected static final int MID_GET_REQUEST_SERVICE_CONTEXT  = 12;
    protected static final int MID_GET_REPLY_SERVICE_CONTEXT    = 13;
    // The last value from RequestInfo (be sure to update this):
    protected static final int MID_RI_LAST                      = 13;

    /*
     **********************************************************************
     * Public interfaces
     **********************************************************************/

    /**
     * Creates a new RequestInfoImpl object.
     */
    public RequestInfoImpl( ORB myORB ) {
        super();

        this.myORB = myORB;
        wrapper = InterceptorsSystemException.get( myORB,
            CORBALogDomains.RPC_PROTOCOL ) ;
        stdWrapper = OMGSystemException.get( myORB,
            CORBALogDomains.RPC_PROTOCOL ) ;

        // Capture the current TSC and make it the RSC of this request.
        PICurrent current = (PICurrent)(myORB.getPIHandler().getPICurrent());
        slotTable = current.getSlotTable( );
    }

    /**
     * Implementation for request_id() differs for client and server
     * implementations.
     *
     * Uniquely identifies an active request/reply sequence.  Once a
     * request/reply sequence is concluded this ID may be reused.  (this
     * is NOT necessarily the same as the GIOP request_id).
     */
    abstract public int request_id ();

    /**
     * Implementation for operation() differs for client and server
     * implementations.
     *
     * The name of the operation being invoked.
     */
    abstract public String operation ();


    /**
     * This method returns the list of arguments for the operation that was
     * invoked. It raises NO_RESOURCES exception if the operation is not invoked
     * by using DII mechanism.
     */
    abstract public Parameter[] arguments ();

    /**
     * This method returns the list of exceptios  that was raised when the
     * operation was invoked. It raises NO_RESOURCES exception if the operation
     * is not invoked by using DII mechanism.
     */
    abstract public TypeCode[] exceptions ();

    /**
     * This method returns the list of contexts for the DII operation.
     * It raises NO_RESOURCES exception if the operation is not invoked by
     * using DII mechanism.
     */
    abstract public String[] contexts ();

    /**
     * This method returns the list of operation_context for the DII operation.
     * It raises NO_RESOURCES exception if the operation is not invoked by
     * using DII mechanism.
     */
    abstract public String[] operation_context ();

    /**
     * This method returns the result from the invoked DII operation.
     * It raises NO_RESOURCES exception if the operation is not invoked by
     * using DII mechanism.
     */
    abstract public Any result ();

    /**
     * Implementation for response_expected() differs for client and server
     * implementations.
     *
     * Indicates whether a response is expected.  On the client, a reply is
     * not returned when response_expected is false, so receive_reply cannot
     * be called.  receive_other is called unless an exception occurs, in
     * which case receive_exception is called.  On the client, within
     * send_poll, this attribute is true.
     */
    abstract public boolean response_expected ();

    /**
     * Defined in the Messaging specification.  Pertinent only when
     * response_expected is false.  If response_expected is true, the value
     * of sync_scope is undefined.  It defines how far the request shall
     * progress before control is returned to the client.  This attribute may
     * have one of the follwing values:
     * <ul>
     *   <li>Messaging::SYNC_NONE</li>
     *   <li>Messaging::SYNC_WITH_TRANSPORT</li>
     *   <li>Messaging::SYNC_WITH_SERVER</li>
     *   <li>Messaging::SYNC_WITH_TARGET</li>
     * </ul>
     */
    public short sync_scope (){
        checkAccess( MID_SYNC_SCOPE );
        return SYNC_WITH_TRANSPORT.value; // REVISIT - get from MessageMediator
    }

    /**
     * Describes the state of the result of the operation invocation.  Its
     * value can be one of the following:
     * <ul>
     *   <li>PortableInterceptor::SUCCESSFUL</li>
     *   <li>PortableInterceptor::SYSTEM_EXCEPTION</li>
     *   <li>PortableInterceptor::USER_EXCEPTION</li>
     *   <li>PortableInterceptor::LOCATION_FORWARD</li>
     *   <li>PortableInterceptor::TRANSPORT_RETRY</li>
     * </ul>
     */
    public short reply_status (){
        checkAccess( MID_REPLY_STATUS );
        return replyStatus;
    }

    /**
     * Implementation for forward_reference() differs for client and server
     * implementations.
     *
     * If the reply_status attribute is LOCATION_FORWARD
     * then this attribute will contain the object
     * to which the request will be forwarded.  It is indeterminate whether a
     * forwarded request will actually occur.
     */
    abstract public Object forward_reference ();


    /**
     * Returns the data from the given slot of the PortableInterceptor::Current
     * that is in the scope of the request.
     * <p>
     * If the given slot has not been set, then an any containing a type code
     * with a TCKind value of tk_null is returned.
     * <p>
     * If the ID does not define an allocated slot, InvalidSlot is raised.
     */
    public Any get_slot (int id)
        throws InvalidSlot
    {
        // access is currently valid for all states:
        //checkAccess( MID_GET_SLOT );
        // Delegate the call to the slotTable which was set when RequestInfo was
        // created.
        return slotTable.get_slot( id );
    }

    /**
     * Implementation for get_request_service_context() differs for client
     * and server implementations.
     *
     * This operation returns a copy of the service context with the given ID
     * that is associated with the request.  If the request's service context
     * does not contain an etry for that ID, BAD_PARAM with a minor code of
     * TBD_BP is raised.
     */
    abstract public org.omg.IOP.ServiceContext
        get_request_service_context(int id);

    /**
     * Implementation for get_reply_service_context() differs for client
     * and server implementations.
     *
     * This operation returns a copy of the service context with the given ID
     * that is associated with the reply.  IF the request's service context
     * does not contain an entry for that ID, BAD_PARAM with a minor code of
     * TBD_BP is raised.
     */
    abstract public org.omg.IOP.ServiceContext
        get_reply_service_context (int id);


    // 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
    //    in both ClientRequestInfoImpl and ServerRequestInfoImpl.



    /*
     **********************************************************************
     * Proprietary methods
     **********************************************************************/

    /**
     * @return The connection on which the request is made.
     *
     * Note: we store the connection as an internal type but
     * expose it here as an external type.
     */
    public com.sun.corba.se.spi.legacy.connection.Connection connection()
    {
        return connection;
    }

    /*
     **********************************************************************
     * Private utility methods
     **********************************************************************/

    /**
     * Inserts the UserException inside the given ApplicationException
     * into the given Any.  Throws an UNKNOWN with minor code
     * OMGSYstemException.UNKNOWN_USER_EXCEPTION if the Helper class could not be
     * found to insert it with.
     */
    private void insertApplicationException( ApplicationException appException,
                                             Any result )
        throws UNKNOWN
    {
        try {
            // Extract the UserException from the ApplicationException.
            // Look up class name from repository id:
            RepositoryId repId = RepositoryId.cache.getId(
                appException.getId() );
            String className = repId.getClassName();

            // Find the read method on the helper class:
            String helperClassName = className + "Helper";
            Class helperClass = ORBClassLoader.loadClass( helperClassName );
            Class[] readParams = new Class[1];
            readParams[0] = org.omg.CORBA.portable.InputStream.class;
            Method readMethod = helperClass.getMethod( "read", readParams );

            // Invoke the read method, passing in the input stream to
            // retrieve the user exception.  Mark and reset the stream
            // as to not disturb it.
            InputStream ueInputStream = appException.getInputStream();
            ueInputStream.mark( 0 );
            UserException userException = null;
            try {
                java.lang.Object[] readArguments = new java.lang.Object[1];
                readArguments[0] = ueInputStream;
                userException = (UserException)readMethod.invoke(
                    null, readArguments );
            }
            finally {
                try {
                    ueInputStream.reset();
                }
                catch( IOException e ) {
                    throw wrapper.markAndResetFailed( e ) ;
                }
            }

            // Insert this UserException into the provided Any using the
            // helper class.
            insertUserException( userException, result );
        } catch( ClassNotFoundException e ) {
            throw stdWrapper.unknownUserException( CompletionStatus.COMPLETED_MAYBE, e ) ;
        } catch( NoSuchMethodException e ) {
            throw stdWrapper.unknownUserException( CompletionStatus.COMPLETED_MAYBE, e ) ;
        } catch( SecurityException e ) {
            throw stdWrapper.unknownUserException( CompletionStatus.COMPLETED_MAYBE, e ) ;
        } catch( IllegalAccessException e ) {
            throw stdWrapper.unknownUserException( CompletionStatus.COMPLETED_MAYBE, e ) ;
        } catch( IllegalArgumentException e ) {
            throw stdWrapper.unknownUserException( CompletionStatus.COMPLETED_MAYBE, e ) ;
        } catch( InvocationTargetException e ) {
            throw stdWrapper.unknownUserException( CompletionStatus.COMPLETED_MAYBE, e ) ;
        }
    }

    /**
     * Inserts the UserException into the given Any.
     * Throws an UNKNOWN with minor code
     * OMGSYstemException.UNKNOWN_USER_EXCEPTION if the Helper class could not be
     * found to insert it with.
     */
    private void insertUserException( UserException userException, Any result )
        throws UNKNOWN
    {
        try {
            // Insert this UserException into the provided Any using the
            // helper class.
            if( userException != null ) {
                Class exceptionClass = userException.getClass();
                String className = exceptionClass.getName();
                String helperClassName = className + "Helper";
                Class helperClass = ORBClassLoader.loadClass( helperClassName );

                // Find insert( Any, class ) method
                Class[] insertMethodParams = new Class[2];
                insertMethodParams[0] = org.omg.CORBA.Any.class;
                insertMethodParams[1] = exceptionClass;
                Method insertMethod = helperClass.getMethod(
                    "insert", insertMethodParams );

                // Call helper.insert( result, userException ):
                java.lang.Object[] insertMethodArguments =
                    new java.lang.Object[2];
                insertMethodArguments[0] = result;
                insertMethodArguments[1] = userException;
                insertMethod.invoke( null, insertMethodArguments );
            }
        } catch( ClassNotFoundException e ) {
            throw stdWrapper.unknownUserException( CompletionStatus.COMPLETED_MAYBE, e );
        } catch( NoSuchMethodException e ) {
            throw stdWrapper.unknownUserException( CompletionStatus.COMPLETED_MAYBE, e );
        } catch( SecurityException e ) {
            throw stdWrapper.unknownUserException( CompletionStatus.COMPLETED_MAYBE, e );
        } catch( IllegalAccessException e ) {
            throw stdWrapper.unknownUserException( CompletionStatus.COMPLETED_MAYBE, e );
        } catch( IllegalArgumentException e ) {
            throw stdWrapper.unknownUserException( CompletionStatus.COMPLETED_MAYBE, e );
        } catch( InvocationTargetException e ) {
            throw stdWrapper.unknownUserException( CompletionStatus.COMPLETED_MAYBE, e );
        }
    }

    /*
     **********************************************************************
     * Protected utility methods
     **********************************************************************/

    /**
     * Internal utility method to convert an NVList into a PI Parameter[]
     */
    protected Parameter[] nvListToParameterArray( NVList parNVList ) {

        // _REVISIT_ This utility method should probably be doing a deep
        // copy so interceptor can't accidentally change the arguments.

        int count = parNVList.count();
        Parameter[] plist = new Parameter[count];
        try {
            for( int i = 0; i < count; i++ ) {
                Parameter p = new Parameter();
                plist[i] = p;
                NamedValue nv = parNVList.item( i );
                plist[i].argument = nv.value();
                // ParameterMode spec can be found in 99-10-07.pdf
                // Section:10.5.22
                // nv.flags spec can be found in 99-10-07.pdf
                // Section 7.1.1
                // nv.flags has ARG_IN as 1, ARG_OUT as 2 and ARG_INOUT as 3
                // To convert this into enum PARAM_IN, PARAM_OUT and
                // PARAM_INOUT the value is subtracted by 1.
                plist[i].mode = ParameterMode.from_int( nv.flags() - 1 );
            }
        } catch ( Exception e ) {
            throw wrapper.exceptionInArguments( e ) ;
        }

        return plist;
    }

    /**
     * Utility to wrap the given Exception in an Any object and return it.
     * If the exception is a UserException which cannot be inserted into
     * an any, then this returns an Any containing the system exception
     * UNKNOWN.
     */
    protected Any exceptionToAny( Exception exception ){
        Any result = myORB.create_any();

        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.exceptionWasNull2() ;
        } else if( exception instanceof SystemException ) {
            ORBUtility.insertSystemException(
                (SystemException)exception, result );
        } else if( exception instanceof ApplicationException ) {
            // Use the Helper class for this exception to insert it into an
            // Any.
            try {
                // Insert the user exception inside the application exception
                // into the Any result:
                ApplicationException appException =
                    (ApplicationException)exception;
                insertApplicationException( appException, result );
            } catch( UNKNOWN e ) {
                // As per ptc/00-08-06, 21.3.13.4. if we cannot find the
                // appropriate class, then return an any containing UNKNOWN,
                // with a minor code of 1.  This is conveniently the same
                // exception that is returned from the
                // insertApplicationException utility method.
                ORBUtility.insertSystemException( e, result );
            }
        } else if( exception instanceof UserException ) {
            try {
                UserException userException = (UserException)exception;
                insertUserException( userException, result );
            } catch( UNKNOWN e ) {
                ORBUtility.insertSystemException( e, result );
            }
        }


        return result;
    }

    /**
     * Utility method to look up a service context with the given id and
     * convert it to an IOP.ServiceContext.  Uses the given HashMap as
     * a cache.  If not found in cache, the result is inserted in the cache.
     */
    protected org.omg.IOP.ServiceContext
        getServiceContext ( HashMap cachedServiceContexts,
                            ServiceContexts serviceContexts, int id )
    {
        org.omg.IOP.ServiceContext result = null;
        Integer integerId = new Integer( id );

        // Search cache first:
        result = (org.omg.IOP.ServiceContext)
            cachedServiceContexts.get( integerId );

        // null could normally mean that either we cached the value null
        // or it's not in the cache.  However, there is no way for us to
        // cache the value null in the following code.
        if( result == null ) {
            // Not in cache.  Find it and put in cache.
            // Get the desired "core" service context.
            com.sun.corba.se.spi.servicecontext.ServiceContext context =
                serviceContexts.get( id );
            if (context == null)
                throw stdWrapper.invalidServiceContextId() ;

            // Convert the "core" service context to an
            // "IOP" ServiceContext by writing it to a
            // CDROutputStream and reading it back.
            EncapsOutputStream out = new EncapsOutputStream(myORB);

            context.write( out, GIOPVersion.V1_2 );
            InputStream inputStream = out.create_input_stream();
            result = ServiceContextHelper.read( inputStream );

            cachedServiceContexts.put( integerId, result );
        }

        // Good citizen: For increased efficiency, we assume that interceptors
        // will not modify the returned ServiceContext.  Otherwise, we would
        // have to make a deep copy.

        return result;
    }


    /**
     * Utility method to add an IOP.ServiceContext to a core.ServiceContexts
     * object.  If replace is true, any service context with the given id
     * is replaced.
     * <p>
     * Raises BAD_INV_ORDER if replace is false and a service context with
     * the given id already exists.
     * <p>
     * Uses the given HashMap as a cache.  If a service context is placed
     * in the container, it goes in the HashMap as well.
     */
    protected void addServiceContext(
        HashMap cachedServiceContexts,
        ServiceContexts serviceContexts,
        org.omg.IOP.ServiceContext service_context,
        boolean replace )
    {
        int id = 0 ;
        // Convert IOP.service_context to core.ServiceContext:
        EncapsOutputStream outputStream = new EncapsOutputStream(
            myORB );
        InputStream inputStream = null;
        UnknownServiceContext coreServiceContext = null;
        ServiceContextHelper.write( outputStream, service_context );
        inputStream = outputStream.create_input_stream();

        // Constructor expects id to already have been read from stream.
        coreServiceContext = new UnknownServiceContext(
            inputStream.read_long(),
            (org.omg.CORBA_2_3.portable.InputStream)inputStream );

        id = coreServiceContext.getId();

        if (serviceContexts.get(id) != null)
            if (replace)
                serviceContexts.delete( id );
            else
                throw stdWrapper.serviceContextAddFailed( new Integer(id) ) ;

        serviceContexts.put( coreServiceContext );

        // Place IOP.ServiceContext in cache as well:
        cachedServiceContexts.put( new Integer( id ), service_context );
    }

    /**
     * Sets the number of interceptors whose starting interception
     * points were successfully invoked on this client call.  As specified
     * in orbos/99-12-02, section 5.2.1., not all interceptors will
     * be invoked if a ForwardRequest exception or a system exception
     * is raised.  This keeps track of how many were successfully executed
     * so we know not to execute the corresponding ending interception
     * points for the interceptors whose starting interception points
     * were not completed.  This simulates the "Flow Stack Visual Model"
     * presented in section 5.1.3.*/
    protected void setFlowStackIndex(int num ) {
        this.flowStackIndex = num;
    }

    /**
     * Returns the number of interceptors whose starting interception
     * points were actually invoked on this client request.  See
     * setFlowStackIndex for more details.
     */
    protected int getFlowStackIndex() {
        return this.flowStackIndex;
    }

    /**
     * Sets which ending interception point should be called
     * for each interceptor in the virtual flow stack.
     */
    protected void setEndingPointCall( int call ) {
        this.endingPointCall = call;
    }

    /**
     * Retrieves the current ending point call type (see
     * setEndingPointCall for more details).
     */
    protected int getEndingPointCall() {
        return this.endingPointCall;
    }

    /**
     * Sets which intermediate interception point should be called
     * for each interceptor in the virtual flow stack.
     */
    protected void setIntermediatePointCall( int call ) {
        this.intermediatePointCall = call;
    }

    /**
     * Retrieves the current intermediate point call type (see
     * setEndingPointCall for more details).
     */
    protected int getIntermediatePointCall() {
        return this.intermediatePointCall;
    }

    /**
     * Sets which starting interception point should be called
     * for each interceptor in the virtual flow stack.
     */
    protected void setStartingPointCall( int call ) {
        this.startingPointCall = call;
    }

    /**
     * Retrieves the current starting point call type (see
     * setStartingPointCall for more details).
     */
    protected int getStartingPointCall() {
        return this.startingPointCall;
    }

    /**
     * Returns true if all interceptors' starting and ending points
     * have already executed to completion, or false if not yet.
     */
    protected boolean getAlreadyExecuted() {
        return this.alreadyExecuted;
    }

    /**
     * Sets whether all interceotrs' starting and ending points
     * have already been executed to completion.
     */
    protected void setAlreadyExecuted( boolean alreadyExecuted ) {
        this.alreadyExecuted = alreadyExecuted;
    }

    /**
     * Sets the value to be returned by reply_status
     */
    protected void setReplyStatus( short replyStatus ) {
        this.replyStatus = replyStatus;
    }

    /**
     * Gets the current reply_status without doing an access check
     * (available only to package and subclasses)
     */
    protected short getReplyStatus() {
        return this.replyStatus;
    }

    /**
     * Stores the given ForwardRequest object for later analysis.
     * This version supplements setForwardRequest( IOR );
     */
    protected void setForwardRequest( ForwardRequest forwardRequest ) {
        this.forwardRequest = forwardRequest;
        this.forwardRequestIOR = null;
    }

    /**
     * Stores the given IOR for later forward request analysis.
     * This version supplements setForwardRequest( ForwardRequest );
     */
    protected void setForwardRequest( IOR ior ) {
        this.forwardRequestIOR = ior;
        this.forwardRequest = null;
    }

    /**
     * Retrieves the ForwardRequest object as a ForwardRequest exception.
     */
    protected ForwardRequest getForwardRequestException() {
        if( this.forwardRequest == null ) {
            if( this.forwardRequestIOR != null ) {
                // Convert the internal IOR to a forward request exception
                // by creating an object reference.
                org.omg.CORBA.Object obj = iorToObject(this.forwardRequestIOR);
                this.forwardRequest = new ForwardRequest( obj );
            }
        }

        return this.forwardRequest;
    }

    /**
     * Retrieves the IOR of the ForwardRequest exception.
     */
    protected IOR getForwardRequestIOR() {
        if( this.forwardRequestIOR == null ) {
            if( this.forwardRequest != null ) {
                this.forwardRequestIOR = ORBUtility.getIOR(
                    this.forwardRequest.forward ) ;
            }
        }

        return this.forwardRequestIOR;
    }

    /**
     * Sets the exception to be returned by received_exception and
     * received_exception_id.
     */
    protected void setException( Exception exception ) {
        this.exception = exception;
    }

    /**
     * Returns the exception to be returned by received_exception and
     * received_exception_id.
     */
    Exception getException() {
        return this.exception;
    }

    /**
     * Sets the execution point that we are currently executing
     * (starting points, intermediate points, or ending points).
     * This allows us to enforce the validity table.
     */
    protected void setCurrentExecutionPoint( int executionPoint ) {
        this.currentExecutionPoint = executionPoint;
    }

    /**
     * Check whether the caller is allowed to access this method at
     * this particular time.  This is overridden in subclasses to implement
     * the validity table specified in ptc/00-04-05, table 21-1 and 21-2.
     * The currentExecutionPoint attribute is checked, and if access is
     * forbidden at this time, BAD_INV_ORDER is raised with a minor code of
     * TBD_BIO.
     *
     * @param methodID The ID of this method, one of the MID_* constants.
     *     This allows us to easily look up the method access in a table.
     *     Note that method ids may overlap between subclasses.
     */
    protected abstract void checkAccess( int methodID )
        throws BAD_INV_ORDER;

    /**
     * The server side does an explicit set rather than taking the
     * current PICurrent table as is done in the general RequestInfoImpl
     * constructor.
     */
    void setSlotTable(SlotTable slotTable)
    {
        this.slotTable = slotTable;
    }

    protected org.omg.CORBA.Object iorToObject( IOR ior )
    {
        return ORBUtility.makeObjectReference( ior ) ;
    }
}
