* Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.

* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*/

* The JavaIDL ORB implementation.

*/

    protected TransportManager transportManager;

    protected LegacyServerSocketManager legacyServerSocketManager;

    private ThreadLocal OAInvocationInfoStack ;

    private ThreadLocal clientInvocationInfoStack ;

    // pure java orb, caching the servant IOR per ORB

    private static IOR codeBaseIOR ;

    // Vector holding deferred Requests

    private Vector            dynamicRequests ;

    private SynchVariable     svResponseReceived ;

    private java.lang.Object runObj = new java.lang.Object();

    private java.lang.Object shutdownObj = new java.lang.Object();

    private java.lang.Object waitForCompletionObj = new java.lang.Object();

    private static final byte STATUS_OPERATING = 1;

    private static final byte STATUS_SHUTTING_DOWN = 2;

    private static final byte STATUS_SHUTDOWN = 3;

    private static final byte STATUS_DESTROYED = 4;

    private byte status = STATUS_OPERATING;

    // XXX Should we move invocation tracking to the first level server dispatcher?

    private java.lang.Object invocationObj = new java.lang.Object();

    private int numInvocations = 0;

    // thread local variable to store a boolean to detect deadlock in

    // ORB.shutdown(true).

    private ThreadLocal isProcessingInvocation = new ThreadLocal () {

        protected java.lang.Object initialValue() {

            return Boolean.FALSE;

        }

    };

    // This map is caching TypeCodes created for a certain class (key)

    // and is used in Util.writeAny()

    private Map typeCodeForClassMap ;

    // Cache to hold ValueFactories (Helper classes) keyed on repository ids

    private Hashtable valueFactoryCache = new Hashtable();

    // thread local variable to store the current ORB version.

    // default ORB version is the version of ORB with correct Rep-id

    // changes

    private ThreadLocal orbVersionThreadLocal ;

    private RequestDispatcherRegistry requestDispatcherRegistry ;

    private CopierManager copierManager ;

    private int transientServerId ;

    private ServiceContextRegistry serviceContextRegistry ;

    // Needed here to implement connect/disconnect

    private TOAFactory toaFactory ;

    // Needed here for set_delegate

    private POAFactory poaFactory ;

    // The interceptor handler, which provides portable interceptor services for

    // subcontracts and object adapters.

    private PIHandler pihandler ;

    private ORBData configData ;

    private BadServerIdHandler badServerIdHandler ;

    private ClientDelegateFactory clientDelegateFactory ;

    private CorbaContactInfoListFactory corbaContactInfoListFactory ;

    // All access to resolver, localResolver, and urlOperation must be protected using

    // resolverLock.  Do not hold the ORBImpl lock while accessing

    // resolver, or deadlocks may occur.

    // Note that we now have separate locks for each resolver type.  This is due

    // to bug 6980681 and 6238477, which was caused by a deadlock while resolving a

    // corbaname: URL that contained a reference to the same ORB as the

    // ORB making the call to string_to_object.  This caused a deadlock between the

    // client thread holding the single lock for access to the urlOperation,

    // and the server thread handling the client is_a request waiting on the

    // same lock to access the localResolver.

    // Used for resolver_initial_references and list_initial_services

    private Resolver resolver ;

    // Used for register_initial_references

    private LocalResolver localResolver ;

    // Converts strings to object references for resolvers and string_to_object

    private Operation urlOperation ;

    private final Object urlOperationLock = new java.lang.Object() ;

    private CorbaServerRequestDispatcher insNamingDelegate ;

    // resolverLock must be used for all access to either resolver or

    // localResolver, since it is possible for the resolver to indirectly

    // refer to the localResolver.  Also used to protect access to

    // insNamingDelegate.

    private final Object resolverLock = new Object() ;

    private TaggedComponentFactoryFinder taggedComponentFactoryFinder ;

    private IdentifiableFactoryFinder taggedProfileFactoryFinder ;

    private IdentifiableFactoryFinder taggedProfileTemplateFactoryFinder ;

    private ObjectKeyFactory objectKeyFactory ;

    private boolean orbOwnsThreadPoolManager = false ;

    private ThreadPoolManager threadpoolMgr;

    private void dprint( String msg )

    {

        ORBUtility.dprint( this, msg ) ;

    }

    ////////////////////////////////////////////////////

    //

    // NOTE:

    //

    // Methods that are synchronized MUST stay synchronized.

    //

    // Methods that are NOT synchronized must stay that way to avoid deadlock.

    //

    //

    // REVISIT:

    //

    // checkShutDownState - lock on different object - and normalize usage.

    // starting/FinishDispatch and Shutdown

    //

    public ORBData getORBData()

    {

        return configData ;

    }

    public PIHandler getPIHandler()

    {

        return pihandler ;

    }

    /**

     * Create a new ORB. Should be followed by the appropriate

     * set_parameters() call.

     */

    public ORBImpl()

    {

        // All initialization is done through set_parameters().

    }

    public ORBVersion getORBVersion()

    {

        synchronized (this) {

                checkShutdownState();

        }

        return (ORBVersion)(orbVersionThreadLocal.get()) ;

    }

    public void setORBVersion(ORBVersion verObj)

    {

        synchronized (this) {

                checkShutdownState();

        }

        orbVersionThreadLocal.set(verObj);

    }

* The following methods are ORB initialization

****************************************************************************/

    // preInit initializes all non-pluggable ORB data that is independent

    // of the property parsing.

    private void preInit( String[] params, Properties props )

    {

        // Before ORBConfiguration we need to set a PINoOpHandlerImpl,

        // because PersisentServer Initialization inside configurator will

        // invoke orb.resolve_initial_references( ) which will result in a

        // check on piHandler to invoke Interceptors. We do not want any

        // Interceptors to be invoked before the complete ORB initialization.

        // piHandler will be replaced by a real PIHandler implementation at the

        // end of this method.

        pihandler = new PINoOpHandlerImpl( );

        // This is the unique id of this server (JVM). Multiple incarnations

        // of this server will get different ids.

        // Compute transientServerId = milliseconds since Jan 1, 1970

        // Note: transientServerId will wrap in about 2^32 / 86400000 = 49.7 days.

        // If two ORBS are started at the same time then there is a possibility

        // of having the same transientServerId. This may result in collision

        // and may be a problem in ior.isLocal() check to see if the object

        // belongs to the current ORB. This problem is taken care of by checking

        // to see if the IOR port matches ORB server port in legacyIsLocalServerPort()

        // method.

        //

        // XXX need to move server ID to a string for CORBA 3.0.  At that point,

        // make this more unique (possibly use java.rmi.server.UID).

        transientServerId = (int)System.currentTimeMillis();

        orbVersionThreadLocal  = new ThreadLocal () {

            protected java.lang.Object initialValue() {

                // set default to version of the ORB with correct Rep-ids

                return ORBVersionFactory.getORBVersion() ;

            }

        };

        requestDispatcherRegistry = new RequestDispatcherRegistryImpl(

            this, ORBConstants.DEFAULT_SCID);

        copierManager = new CopierManagerImpl( this ) ;

        taggedComponentFactoryFinder =

            new TaggedComponentFactoryFinderImpl(this) ;

        taggedProfileFactoryFinder =

            new TaggedProfileFactoryFinderImpl(this) ;

        taggedProfileTemplateFactoryFinder =

            new TaggedProfileTemplateFactoryFinderImpl(this) ;

        dynamicRequests = new Vector();

        svResponseReceived = new SynchVariable();

        OAInvocationInfoStack =

            new ThreadLocal () {

                protected java.lang.Object initialValue()

                {

                    return new StackImpl();

                }

            };

        clientInvocationInfoStack =

            new ThreadLocal() {

                protected java.lang.Object initialValue() {

                    return new StackImpl();

                }

            };

        serviceContextRegistry = new ServiceContextRegistry( this ) ;

    }

    protected void setDebugFlags( String[] args )

    {

        for (int ctr=0; ctr<args.length; ctr++ ) {

            String token = args[ctr] ;

            // If there is a public boolean data member in this class

            // named token + "DebugFlag", set it to true.

            try {

                Field fld = this.getClass().getField( token + "DebugFlag" ) ;

                int mod = fld.getModifiers() ;

                if (Modifier.isPublic( mod ) && !Modifier.isStatic( mod ))

                    if (fld.getType() == boolean.class)

                        fld.setBoolean( this, true ) ;

            } catch (Exception exc) {

                // ignore it XXX log this as info

            }

        }

    }

    // Class that defines a parser that gets the name of the

    // ORBConfigurator class.

        // The default here is the ORBConfiguratorImpl that we define,

        // but this can be replaced.

        public Class configurator = ORBConfiguratorImpl.class ;

        public PropertyParser makeParser()

        {

            PropertyParser parser = new PropertyParser() ;

            parser.add( ORBConstants.SUN_PREFIX + "ORBConfigurator",

                OperationFactory.classAction(), "configurator" ) ;

            return parser ;

        }

    }

    private void postInit( String[] params, DataCollector dataCollector )

    {

        // First, create the standard ORB config data.

        // This must be initialized before the ORBConfigurator

        // is executed.

        configData = new ORBDataParserImpl( this, dataCollector) ;

        // Set the debug flags early so they can be used by other

        // parts of the initialization.

        setDebugFlags( configData.getORBDebugFlags() ) ;

        // REVISIT: this should go away after more transport init cleanup

        // and going to ORT based ORBD.

        getTransportManager();

        getLegacyServerSocketManager();

        // Create a parser to get the configured ORBConfigurator.

        ConfigParser parser = new ConfigParser() ;

        parser.init( dataCollector ) ;

        ORBConfigurator configurator =  null ;

        try {

            configurator =

                (ORBConfigurator)(parser.configurator.newInstance()) ;

        } catch (Exception iexc) {

            throw wrapper.badOrbConfigurator( iexc, parser.configurator.getName() ) ;

        }

        // Finally, run the configurator.  Note that the default implementation allows

        // other configurators with their own parsers to run,

        // using the same DataCollector.

        try {

            configurator.configure( dataCollector, this ) ;

        } catch (Exception exc) {

            throw wrapper.orbConfiguratorError( exc ) ;

        }

        // Last of all, create the PIHandler and run the ORB initializers.

        pihandler = new PIHandlerImpl( this, params) ;

        pihandler.initialize() ;

        // Initialize the thread manager pool and byte buffer pool

        // so they may be initialized & accessed without synchronization

        getThreadPoolManager();

        super.getByteBufferPool();

    }

    private synchronized POAFactory getPOAFactory()

    {

        if (poaFactory == null) {

            poaFactory = (POAFactory)requestDispatcherRegistry.getObjectAdapterFactory(

                ORBConstants.TRANSIENT_SCID ) ;

        }

        return poaFactory ;

    }

    private synchronized TOAFactory getTOAFactory()

    {

        if (toaFactory == null) {

            toaFactory = (TOAFactory)requestDispatcherRegistry.getObjectAdapterFactory(

                ORBConstants.TOA_SCID ) ;

        }

        return toaFactory ;

    }

    public void set_parameters( Properties props )

    {

        synchronized (this) {

                checkShutdownState();

        }

        preInit( null, props ) ;

        DataCollector dataCollector =

            DataCollectorFactory.create( props, getLocalHostName() ) ;

        postInit( null, dataCollector ) ;

    }

    protected void set_parameters(Applet app, Properties props)

    {

        preInit( null, props ) ;

        DataCollector dataCollector =

            DataCollectorFactory.create( app, props, getLocalHostName() ) ;

        postInit( null, dataCollector ) ;

    }

    protected void set_parameters (String[] params, Properties props)

    {

        preInit( params, props ) ;

        DataCollector dataCollector =

            DataCollectorFactory.create( params, props, getLocalHostName() ) ;

        postInit( params, dataCollector ) ;

    }

* The following methods are standard public CORBA ORB APIs

****************************************************************************/

    public synchronized org.omg.CORBA.portable.OutputStream create_output_stream()

    {

        checkShutdownState();

        return sun.corba.OutputStreamFactory.newEncapsOutputStream(this);

    }

    /**

     * Get a Current pseudo-object.

     * The Current interface is used to manage thread-specific

     * information for use by the transactions, security and other

     * services. This method is deprecated,

     * and replaced by ORB.resolve_initial_references("NameOfCurrentObject");

     *

     * @return          a Current pseudo-object.

     * @deprecated

     */

    public synchronized org.omg.CORBA.Current get_current()

    {

        checkShutdownState();

        /* _REVISIT_

           The implementation of get_current is not clear. How would

           ORB know whether the caller wants a Current for transactions

           or security ?? Or is it assumed that there is just one

           implementation for both ? If Current is thread-specific,

           then it should not be instantiated; so where does the

           ORB get a Current ?

           This should probably be deprecated. */

        throw wrapper.genericNoImpl() ;

    }

    /**

     * Create an NVList

     *

     * @param count     size of list to create

     * @result          NVList created

     *

     * @see NVList

     */

    public synchronized NVList create_list(int count)

    {

        checkShutdownState();

        return new NVListImpl(this, count);

    }

    /**

     * Create an NVList corresponding to an OperationDef

     *

     * @param oper      operation def to use to create list

     * @result          NVList created

     *

     * @see NVList

     */

    public synchronized NVList create_operation_list(org.omg.CORBA.Object oper)

    {

        checkShutdownState();

        throw wrapper.genericNoImpl() ;

    }

    /**

     * Create a NamedValue

     *

     * @result          NamedValue created

     */

    public synchronized NamedValue create_named_value(String s, Any any, int flags)

    {

        checkShutdownState();

        return new NamedValueImpl(this, s, any, flags);

    }

    /**

     * Create an ExceptionList

     *

     * @result          ExceptionList created

     */

    public synchronized org.omg.CORBA.ExceptionList create_exception_list()

    {

        checkShutdownState();

        return new ExceptionListImpl();

    }

    /**

     * Create a ContextList

     *

     * @result          ContextList created

     */

    public synchronized org.omg.CORBA.ContextList create_context_list()

    {

        checkShutdownState();

        return new ContextListImpl(this);

    }

    /**

     * Get the default Context object

     *

     * @result          the default Context object

     */

    public synchronized org.omg.CORBA.Context get_default_context()

    {

        checkShutdownState();

        throw wrapper.genericNoImpl() ;

    }

    /**

     * Create an Environment

     *

     * @result          Environment created

     */

    public synchronized org.omg.CORBA.Environment create_environment()

    {

        checkShutdownState();

        return new EnvironmentImpl();

    }

    public synchronized void send_multiple_requests_oneway(Request[] req)

    {

        checkShutdownState();

        // Invoke the send_oneway on each new Request

        for (int i = 0; i < req.length; i++) {

            req[i].send_oneway();

        }

    }

    /**

     * Send multiple dynamic requests asynchronously.

     *

     * @param req         an array of request objects.

     */

    public synchronized void send_multiple_requests_deferred(Request[] req)

    {

        checkShutdownState();

        // add the new Requests to pending dynamic Requests

        for (int i = 0; i < req.length; i++) {

            dynamicRequests.addElement(req[i]);

        }

        // Invoke the send_deferred on each new Request

        for (int i = 0; i < req.length; i++) {

            AsynchInvoke invokeObject = new AsynchInvoke( this,

                (com.sun.corba.se.impl.corba.RequestImpl)req[i], true);

            new Thread(invokeObject).start();

        }

    }

    /**

     * Find out if any of the deferred invocations have a response yet.

     */

    public synchronized boolean poll_next_response()

    {

        checkShutdownState();

        Request currRequest;

        // poll on each pending request

        Enumeration ve = dynamicRequests.elements();

        while (ve.hasMoreElements() == true) {

            currRequest = (Request)ve.nextElement();

            if (currRequest.poll_response() == true) {

                return true;

            }

        }

        return false;

    }

    /**

     * Get the next request that has gotten a response.

     *

     * @result            the next request ready with a response.

     */

    public org.omg.CORBA.Request get_next_response()

        throws org.omg.CORBA.WrongTransaction

    {

        synchronized( this ) {

            checkShutdownState();

        }

        while (true) {

            // check if there already is a response

            synchronized ( dynamicRequests ) {

                Enumeration elems = dynamicRequests.elements();

                while ( elems.hasMoreElements() ) {

                    Request currRequest = (Request)elems.nextElement();

                    if ( currRequest.poll_response() ) {

                        // get the response for this successfully polled Request

                        currRequest.get_response();

                        dynamicRequests.removeElement(currRequest);

                        return currRequest;

                    }

                }

            }

            // wait for a response

            synchronized(this.svResponseReceived) {

                while (!this.svResponseReceived.value()) {

                    try {

                        this.svResponseReceived.wait();

                    } catch(java.lang.InterruptedException ex) {

                        // NO-OP

                    }

                }

                // reinitialize the response flag

                this.svResponseReceived.reset();

            }

        }

    }

    /**

     * Notify response to ORB for get_next_response

     */

    public void notifyORB()

    {

        synchronized (this) {

                checkShutdownState();

        }

        synchronized (this.svResponseReceived) {

            this.svResponseReceived.set();

            this.svResponseReceived.notify();

        }

    }

    /**

     * Convert an object ref to a string.

     * @param obj The object to stringify.

     * @return A stringified object reference.

     */

    public synchronized String object_to_string(org.omg.CORBA.Object obj)

    {

        checkShutdownState();

        // Handle the null objref case

        if (obj == null) {

            IOR nullIOR = IORFactories.makeIOR( this ) ;

            return nullIOR.stringify();

        }

        IOR ior = null ;

        try {

            ior = ORBUtility.connectAndGetIOR( this, obj ) ;

        } catch (BAD_PARAM bp) {

            // Throw MARSHAL instead if this is a LOCAL_OBJECT_NOT_ALLOWED error.

            if (bp.minor == ORBUtilSystemException.LOCAL_OBJECT_NOT_ALLOWED) {

                throw omgWrapper.notAnObjectImpl( bp ) ;

            } else

                // Not a local object problem: just rethrow the exception.

                // Do not wrap and log this, since it was already logged at its

                // point of origin.

                throw bp ;

        }

        return ior.stringify() ;

    }

    /**

     * Convert a stringified object reference to the object it represents.

     * @param str The stringified object reference.

     * @return The unstringified object reference.

     */

    public org.omg.CORBA.Object string_to_object(String str)

    {

        Operation op ;

        synchronized (this) {

            checkShutdownState();

            op = urlOperation ;

        }

        if (str == null)

            throw wrapper.nullParam() ;

        synchronized (urlOperationLock) {

            org.omg.CORBA.Object obj = (org.omg.CORBA.Object)op.operate( str ) ;

            return obj ;

        }

    }

    // pure java orb support, moved this method from FVDCodeBaseImpl.

    // Note that we connect this if we have not already done so.

    public synchronized IOR getFVDCodeBaseIOR()

    {

        checkShutdownState();

        if (codeBaseIOR != null) // i.e. We are already connected to it

            return codeBaseIOR;

        // backward compatability 4365188

        CodeBase cb;

        ValueHandler vh = ORBUtility.createValueHandler();

        cb = (CodeBase)vh.getRunTimeCodeBase();

        return ORBUtility.connectAndGetIOR( this, cb ) ;

    }

    /**

     * Get the TypeCode for a primitive type.

     *

     * @param tcKind    the integer kind for the primitive type

     * @return          the requested TypeCode

     */

    public synchronized TypeCode get_primitive_tc(TCKind tcKind)

    {

        checkShutdownState();

        return get_primitive_tc( tcKind.value() ) ;

    }

    /**

     * Create a TypeCode for a structure.

     *

     * @param id                the logical id for the typecode.

     * @param name      the name for the typecode.

     * @param members   an array describing the members of the TypeCode.

     * @return          the requested TypeCode.

     */

    public synchronized TypeCode create_struct_tc(String id,

                                     String name,

                                     StructMember[] members)

    {

        checkShutdownState();

        return new TypeCodeImpl(this, TCKind._tk_struct, id, name, members);

    }

    /**

     * Create a TypeCode for a union.

     *

     * @param id                the logical id for the typecode.

     * @param name      the name for the typecode.

     * @param discriminator_type

     *                  the type of the union discriminator.

     * @param members   an array describing the members of the TypeCode.

     * @return          the requested TypeCode.

     */

    public synchronized TypeCode create_union_tc(String id,

                                    String name,

                                    TypeCode discriminator_type,

                                    UnionMember[] members)

    {

        checkShutdownState();

        return new TypeCodeImpl(this,

                                TCKind._tk_union,

                                id,

                                name,

                                discriminator_type,

                                members);

    }

    /**

     * Create a TypeCode for an enum.

     *

     * @param id                the logical id for the typecode.

     * @param name      the name for the typecode.

     * @param members   an array describing the members of the TypeCode.

     * @return          the requested TypeCode.

     */

    public synchronized TypeCode create_enum_tc(String id,

                                   String name,

                                   String[] members)

    {

        checkShutdownState();

        return new TypeCodeImpl(this, TCKind._tk_enum, id, name, members);

    }

    /**

     * Create a TypeCode for an alias.

     *

     * @param id                the logical id for the typecode.

     * @param name      the name for the typecode.

     * @param original_type

     *                  the type this is an alias for.

     * @return          the requested TypeCode.

     */

    public synchronized TypeCode create_alias_tc(String id,

                                    String name,

                                    TypeCode original_type)

    {

        checkShutdownState();

        return new TypeCodeImpl(this, TCKind._tk_alias, id, name, original_type);

    }

    /**

     * Create a TypeCode for an exception.

     *

     * @param id                the logical id for the typecode.

     * @param name      the name for the typecode.

     * @param members   an array describing the members of the TypeCode.

     * @return          the requested TypeCode.

     */

    public synchronized TypeCode create_exception_tc(String id,

                                        String name,

                                        StructMember[] members)

    {

        checkShutdownState();

        return new TypeCodeImpl(this, TCKind._tk_except, id, name, members);

    }

    /**

     * Create a TypeCode for an interface.

     *

     * @param id                the logical id for the typecode.

     * @param name      the name for the typecode.

     * @return          the requested TypeCode.

     */

    public synchronized TypeCode create_interface_tc(String id,

                                        String name)

    {

        checkShutdownState();

        return new TypeCodeImpl(this, TCKind._tk_objref, id, name);

    }

    /**

     * Create a TypeCode for a string.

     *

     * @param bound     the bound for the string.

     * @return          the requested TypeCode.

     */

    public synchronized TypeCode create_string_tc(int bound)

    {

        checkShutdownState();

        return new TypeCodeImpl(this, TCKind._tk_string, bound);

    }

    /**

     * Create a TypeCode for a wide string.

     *

     * @param bound     the bound for the string.

     * @return          the requested TypeCode.

     */

    public synchronized TypeCode create_wstring_tc(int bound)

    {

        checkShutdownState();

        return new TypeCodeImpl(this, TCKind._tk_wstring, bound);

    }

    /**

     * Create a TypeCode for a sequence.

     *

     * @param bound     the bound for the sequence.

     * @param element_type

     *                  the type of elements of the sequence.

     * @return          the requested TypeCode.

     */

    public synchronized TypeCode create_sequence_tc(int bound,

                                       TypeCode element_type)

    {

        checkShutdownState();

        return new TypeCodeImpl(this, TCKind._tk_sequence, bound, element_type);

    }

    /**

     * Create a recursive TypeCode in a sequence.

     *

     * @param bound     the bound for the sequence.

     * @param offset    the index to the enclosing TypeCode that is

     *                  being referenced.

     * @return          the requested TypeCode.

     */

    public synchronized TypeCode create_recursive_sequence_tc(int bound,

                                                 int offset)

    {

        checkShutdownState();

        return new TypeCodeImpl(this, TCKind._tk_sequence, bound, offset);

    }

    /**

     * Create a TypeCode for an array.

     *

     * @param length    the length of the array.

     * @param element_type

     *                  the type of elements of the array.

     * @return          the requested TypeCode.

     */

    public synchronized TypeCode create_array_tc(int length,

                                    TypeCode element_type)

    {

        checkShutdownState();

        return new TypeCodeImpl(this, TCKind._tk_array, length, element_type);

    }

    public synchronized org.omg.CORBA.TypeCode create_native_tc(String id,

                                                   String name)

    {

        checkShutdownState();

        return new TypeCodeImpl(this, TCKind._tk_native, id, name);

    }

    public synchronized org.omg.CORBA.TypeCode create_abstract_interface_tc(

                                                               String id,

                                                               String name)

    {

        checkShutdownState();

        return new TypeCodeImpl(this, TCKind._tk_abstract_interface, id, name);

    }

    public synchronized org.omg.CORBA.TypeCode create_fixed_tc(short digits, short scale)

    {

        checkShutdownState();

        return new TypeCodeImpl(this, TCKind._tk_fixed, digits, scale);

    }

    public synchronized org.omg.CORBA.TypeCode create_value_tc(String id,

                                                  String name,

                                                  short type_modifier,

                                                  TypeCode concrete_base,

                                                  ValueMember[] members)

    {

        checkShutdownState();

        return new TypeCodeImpl(this, TCKind._tk_value, id, name,

                                type_modifier, concrete_base, members);

    }

    public synchronized org.omg.CORBA.TypeCode create_recursive_tc(String id) {

        checkShutdownState();

        return new TypeCodeImpl(this, id);

    }

    public synchronized org.omg.CORBA.TypeCode create_value_box_tc(String id,

                                                      String name,

                                                      TypeCode boxed_type)

    {

        checkShutdownState();

        return new TypeCodeImpl(this, TCKind._tk_value_box, id, name,

            boxed_type);

    }

    /**

     * Create a new Any

     *

     * @return          the new Any created.

     */

    public synchronized Any create_any()

    {

        checkShutdownState();

        return new AnyImpl(this);

    }

    // TypeCodeFactory interface methods.

    // Keeping track of type codes by repository id.

    // Keeping a cache of TypeCodes associated with the class

    // they got created from in Util.writeAny().

    public synchronized void setTypeCodeForClass(Class c, TypeCodeImpl tci)

    {

        checkShutdownState();

        if (typeCodeForClassMap == null)

            typeCodeForClassMap = Collections.synchronizedMap(

                new WeakHashMap(64));

        // Store only one TypeCode per class.

        if ( ! typeCodeForClassMap.containsKey(c))

            typeCodeForClassMap.put(c, tci);

    }

    public synchronized TypeCodeImpl getTypeCodeForClass(Class c)

    {

        checkShutdownState();

        if (typeCodeForClassMap == null)

            return null;

        return (TypeCodeImpl)typeCodeForClassMap.get(c);

    }

* The following methods deal with listing and resolving the initial

* (bootstrap) object references such as "NameService".

****************************************************************************/

    /**

     * Get a list of the initially available CORBA services.

     * This does not work unless an ORBInitialHost is specified during

     * initialization (or unless there is an ORB running on the AppletHost)

     * since the localhostname

     * is inaccessible to applets. If a service properties URL was specified,

     * then it is used, otherwise the bootstrapping protocol is used.

     * @return A list of the initial services available.

     */

    public String[] list_initial_services()

    {

        Resolver res ;

        synchronized( this ) {

            checkShutdownState();

            res = resolver ;

        }

        synchronized (resolverLock) {

            java.util.Set keys = res.list() ;

            return (String[])keys.toArray( new String[keys.size()] ) ;

        }

    }

    /**

     * Resolve the stringified reference of one of the initially

     * available CORBA services.

     * @param identifier The stringified object reference of the

     * desired service.

     * @return An object reference for the desired service.

     * @exception InvalidName The supplied identifier is not associated

     * with a known service.

     * @exception SystemException One of a fixed set of Corba system exceptions.

     */

    public org.omg.CORBA.Object resolve_initial_references(

        String identifier) throws InvalidName

    {

        Resolver res ;

        synchronized( this ) {

            checkShutdownState();

            res = resolver ;

        }

        synchronized (resolverLock) {

            org.omg.CORBA.Object result = res.resolve( identifier ) ;

            if (result == null)

                throw new InvalidName() ;

            else

                return result ;

        }

    }

    /**

     * If this operation is called with an id, <code>"Y"</code>, and an

     * object, <code>YY</code>, then a subsequent call to

     * <code>ORB.resolve_initial_references( "Y" )</code> will

     * return object <code>YY</code>.

     *

     * @param id The ID by which the initial reference will be known.

     * @param obj The initial reference itself.

     * @throws InvalidName if this operation is called with an empty string id

     *     or this operation is called with an id that is already registered,

     *     including the default names defined by OMG.

     * @throws BAD_PARAM if the obj parameter is null.

     */

    public void register_initial_reference(

        String id, org.omg.CORBA.Object obj ) throws InvalidName

    {

        CorbaServerRequestDispatcher insnd ;

        synchronized (this) {

            checkShutdownState();

        }

        if ((id == null) || (id.length() == 0))

            throw new InvalidName() ;

        synchronized (this) {

            checkShutdownState();

        }

        synchronized (resolverLock) {

            insnd = insNamingDelegate ;

            java.lang.Object obj2 = localResolver.resolve( id ) ;

            if (obj2 != null)

                throw new InvalidName(id + " already registered") ;

            localResolver.register( id, ClosureFactory.makeConstant( obj )) ;

        }

        synchronized (this) {

            if (StubAdapter.isStub(obj))

                // Make all remote object references available for INS.

                requestDispatcherRegistry.registerServerRequestDispatcher(

                    insnd, id ) ;

        }

    }

* The following methods (introduced in POA / CORBA2.1) deal with

* shutdown / single threading.

****************************************************************************/

    public void run()

    {

        synchronized (this) {

            checkShutdownState();

        }

        synchronized (runObj) {

            try {

                runObj.wait();

            } catch ( InterruptedException ex ) {}

        }

    }

    public void shutdown(boolean wait_for_completion) {

        boolean wait = false;

        synchronized (this) {

            checkShutdownState();

            // This is to avoid deadlock: don't allow a thread that is

            // processing a request to call shutdown( true ), because

            // the shutdown would block waiting for the request to complete,

            // while the request would block waiting for shutdown to complete.

            if (wait_for_completion &&

                isProcessingInvocation.get() == Boolean.TRUE) {

                throw omgWrapper.shutdownWaitForCompletionDeadlock();

            }

            if (status == STATUS_SHUTTING_DOWN) {

                if (wait_for_completion) {

                    wait = true;

                } else {

                    return;

                }

            }

            status = STATUS_SHUTTING_DOWN;

        }

        // Avoid more than one thread performing shutdown at a time.

        synchronized (shutdownObj) {

            // At this point, the ORB status is certainly STATUS_SHUTTING_DOWN.

            // If wait is true, another thread already called shutdown( true ),

            // and so we wait for completion

            if (wait) {

                while (true) {

                    synchronized (this) {

                        if (status == STATUS_SHUTDOWN)

                            break;

                    }

                    try {

                        shutdownObj.wait();

                    } catch (InterruptedException exc) {

                        // NOP: just loop and wait until state is changed

                    }

                }

            } else {

                // perform the actual shutdown

                shutdownServants(wait_for_completion);

                if (wait_for_completion) {

                    synchronized ( waitForCompletionObj ) {

                        while (numInvocations > 0) {

                            try {

                                waitForCompletionObj.wait();

                            } catch (InterruptedException ex) {}