jdk8-mips64-public/corba: src/share/classes/com/sun/corba/se/impl/orb/ParserTable.java@e324dfb90c9e (annotated)

src/share/classes/com/sun/corba/se/impl/orb/ParserTable.java@e324dfb90c9e (annotated)

src/share/classes/com/sun/corba/se/impl/orb/ParserTable.java

Wed, 28 Mar 2012 02:50:50 -0700

author: mbankal
date: Wed, 28 Mar 2012 02:50:50 -0700
changeset 371: e324dfb90c9e
parent 158: 91006f157c46
child 473: 5845df371e25
child 475: 39d15bbb5741
permissions: -rw-r--r--

7079902: Refine CORBA data models
Reviewed-by: coffeys

 /*
  * Copyright (c) 2002, 2012, 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.orb ;
 import java.net.URL ;
 import java.net.InetSocketAddress;
 import java.net.Socket ;
 import java.net.ServerSocket ;
 import java.io.IOException ;
 import java.util.HashMap ;
 import java.util.List;
 import java.util.Map ;
 import java.security.AccessController ;
 import java.security.PrivilegedExceptionAction ;
 import java.security.PrivilegedActionException ;
 import org.omg.PortableInterceptor.ORBInitializer ;
 import org.omg.PortableInterceptor.ORBInitInfo ;
 import com.sun.corba.se.pept.broker.Broker;
 import com.sun.corba.se.pept.encoding.InputObject;
 import com.sun.corba.se.pept.encoding.OutputObject;
 import com.sun.corba.se.pept.protocol.MessageMediator;
 import com.sun.corba.se.pept.transport.Acceptor;
 import com.sun.corba.se.pept.transport.Connection;
 import com.sun.corba.se.pept.transport.ContactInfo;
 import com.sun.corba.se.pept.transport.ContactInfoList;
 import com.sun.corba.se.pept.transport.EventHandler;
 import com.sun.corba.se.pept.transport.InboundConnectionCache;
 import com.sun.corba.se.spi.ior.IOR ;
 import com.sun.corba.se.spi.ior.ObjectKey ;
 import com.sun.corba.se.spi.ior.iiop.GIOPVersion ;
 import com.sun.corba.se.spi.logging.CORBALogDomains ;
 import com.sun.corba.se.spi.orb.ORB;
 import com.sun.corba.se.spi.orb.Operation ;
 import com.sun.corba.se.spi.orb.OperationFactory ;
 import com.sun.corba.se.spi.orb.ParserData ;
 import com.sun.corba.se.spi.orb.ParserDataFactory ;
 import com.sun.corba.se.spi.orb.StringPair ;
 import com.sun.corba.se.spi.transport.CorbaContactInfoList;
 import com.sun.corba.se.spi.transport.CorbaContactInfoListFactory;
 import com.sun.corba.se.spi.transport.CorbaTransportManager;
 import com.sun.corba.se.spi.transport.IORToSocketInfo;
 import com.sun.corba.se.spi.transport.ReadTimeouts;
 import com.sun.corba.se.spi.transport.SocketInfo;
 import com.sun.corba.se.spi.transport.IIOPPrimaryToContactInfo;
 import com.sun.corba.se.spi.transport.TransportDefault;
 import com.sun.corba.se.impl.encoding.CodeSetComponentInfo ;
 import com.sun.corba.se.impl.encoding.OSFCodeSetRegistry ;
 import com.sun.corba.se.impl.legacy.connection.USLPort ;
 import com.sun.corba.se.impl.logging.ORBUtilSystemException ;
 import com.sun.corba.se.impl.oa.poa.BadServerIdHandler ;
 import com.sun.corba.se.impl.orbutil.ORBClassLoader ;
 import com.sun.corba.se.impl.orbutil.ORBConstants ;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.KeyAddr ;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.ProfileAddr ;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.ReferenceAddr ;
 import com.sun.corba.se.impl.transport.DefaultIORToSocketInfoImpl;
 import com.sun.corba.se.impl.transport.DefaultSocketFactoryImpl;
 /** Initialize the parser data for the standard ORB parser.  This is used both
  * to implement ORBDataParserImpl and to provide the basic testing framework
  * for ORBDataParserImpl.
  */
 public class ParserTable {
     private static String MY_CLASS_NAME = ParserTable.class.getName() ;
     private static ParserTable myInstance = new ParserTable() ;
     private ORBUtilSystemException wrapper ;
     public static ParserTable get()
     {
         return myInstance ;
     }
     private ParserData[] parserData ;
     public ParserData[] getParserData()
     {
         ParserData[] parserArray = new ParserData[parserData.length];
         System.arraycopy(parserData, 0, parserArray, 0, parserData.length);
         return parserArray;
     }
     private ParserTable() {
         wrapper = ORBUtilSystemException.get( CORBALogDomains.ORB_LIFECYCLE ) ;
         String codeSetTestString =
             OSFCodeSetRegistry.ISO_8859_1_VALUE + "," +
             OSFCodeSetRegistry.UTF_16_VALUE + "," +
             OSFCodeSetRegistry.ISO_646_VALUE ;
         String[] debugTestData = { "subcontract", "poa", "transport" } ;
         USLPort[] USLPorts = { new USLPort( "FOO", 2701 ), new USLPort( "BAR", 3333 ) } ;
         ReadTimeouts readTimeouts =
                TransportDefault.makeReadTimeoutsFactory().create(
                     ORBConstants.TRANSPORT_TCP_INITIAL_TIME_TO_WAIT,
                     ORBConstants.TRANSPORT_TCP_MAX_TIME_TO_WAIT,
                     ORBConstants.TRANSPORT_TCP_GIOP_HEADER_MAX_TIME_TO_WAIT,
                     ORBConstants.TRANSPORT_TCP_TIME_TO_WAIT_BACKOFF_FACTOR);
         ORBInitializer[] TestORBInitializers =
             { null,
               new TestORBInitializer1(),
               new TestORBInitializer2() }  ;
         StringPair[] TestORBInitData = {
             new StringPair( "foo.bar.blech.NonExistent", "dummy" ),
             new StringPair( MY_CLASS_NAME + "$TestORBInitializer1", "dummy" ),
             new StringPair( MY_CLASS_NAME + "$TestORBInitializer2", "dummy" ) } ;
         Acceptor[] TestAcceptors =
             { new TestAcceptor2(),
               new TestAcceptor1(),
               null }  ;
         // REVISIT: The test data gets put into a Properties object where
         // order is not guaranteed.  Thus the above array is in reverse.
         StringPair[] TestAcceptorData = {
             new StringPair( "foo.bar.blech.NonExistent", "dummy" ),
             new StringPair( MY_CLASS_NAME + "$TestAcceptor1", "dummy" ),
             new StringPair( MY_CLASS_NAME + "$TestAcceptor2", "dummy" ) } ;
         StringPair[] TestORBInitRefData =
             { new StringPair( "Foo", "ior:930492049394" ),
               new StringPair( "Bar", "ior:3453465785633576" ) } ;
         URL testServicesURL = null ;
         String testServicesString = "corbaloc::camelot/NameService" ;
         try {
             testServicesURL = new URL( testServicesString )  ;
         } catch (Exception exc) {
         }
         // propertyName,
         // operation,
         // fieldName, defaultValue,
         // testValue, testData (string or Pair[])
         ParserData[] pd = {
             ParserDataFactory.make( ORBConstants.DEBUG_PROPERTY,
                 OperationFactory.listAction( ",", OperationFactory.stringAction()),
                 "debugFlags", new String[0],
                 debugTestData, "subcontract,poa,transport" ),
             ParserDataFactory.make( ORBConstants.INITIAL_HOST_PROPERTY,
                 OperationFactory.stringAction(),
                 "ORBInitialHost", "",
                 "Foo", "Foo" ),
             ParserDataFactory.make( ORBConstants.INITIAL_PORT_PROPERTY,
                 OperationFactory.integerAction(),
                 "ORBInitialPort", new Integer( ORBConstants.DEFAULT_INITIAL_PORT ),
                 new Integer( 27314 ), "27314" ),
             // Where did this come from?
             //ParserDataFactory.make( ORBConstants.INITIAL_PORT_PROPERTY,
                 //OperationFactory.booleanAction(),
                 //"ORBInitialPortInitialized", Boolean.FALSE,
                 //Boolean.TRUE, "27314" ),
             ParserDataFactory.make( ORBConstants.SERVER_HOST_PROPERTY,
                 OperationFactory.stringAction(),
                 "ORBServerHost", "",
                 "camelot", "camelot" ),
             ParserDataFactory.make( ORBConstants.SERVER_PORT_PROPERTY,
                 OperationFactory.integerAction(),
                 "ORBServerPort", new Integer( 0 ),
                 new Integer( 38143 ), "38143" ),
             // NOTE: We are putting SERVER_HOST_NAME configuration info into
             // DataCollectorBase to avoid a security hole.  However, that forces
             // us to also set LISTEN_ON_ALL_INTERFACES at the same time.
             // This all needs to be cleaned up for two reasons: to get configuration
             // out of DataCollectorBase and to correctly support multihoming.
             ParserDataFactory.make( ORBConstants.LISTEN_ON_ALL_INTERFACES,
                 OperationFactory.stringAction(),
                 "listenOnAllInterfaces", ORBConstants.LISTEN_ON_ALL_INTERFACES,
                 "foo", "foo" ),
             ParserDataFactory.make( ORBConstants.ORB_ID_PROPERTY,
                 OperationFactory.stringAction(),
                 "orbId", "",
                 "foo", "foo" ),
             ParserDataFactory.make( ORBConstants.OLD_ORB_ID_PROPERTY,
                 OperationFactory.stringAction(),
                 "orbId", "",
                 "foo", "foo" ),
             ParserDataFactory.make( ORBConstants.ORB_SERVER_ID_PROPERTY,
                 OperationFactory.integerAction(),
                 "persistentServerId", new Integer(-1),
                 new Integer( 1234), "1234" ),
             ParserDataFactory.make(
                 ORBConstants.ORB_SERVER_ID_PROPERTY,
                 OperationFactory.setFlagAction(),
                 "persistentServerIdInitialized", Boolean.FALSE,
                 Boolean.TRUE, "1234" ),
             ParserDataFactory.make(
                 ORBConstants.ORB_SERVER_ID_PROPERTY,
                 OperationFactory.setFlagAction(),
                 "orbServerIdPropertySpecified", Boolean.FALSE,
                 Boolean.TRUE, "1234" ),
             // REVISIT after switch
             // ParserDataFactory.make( ORBConstants.INITIAL_SERVICES_PROPERTY,
                 // OperationFactory.URLAction(),
                 // "servicesURL", null,
                 // testServicesURL, testServicesString ),
             // ParserDataFactory.make( ORBConstants.DEFAULT_INIT_REF_PROPERTY,
                 // OperationFactory.stringAction(),
                 // "defaultInitRef", null,
                 // "Fooref", "Fooref" ),
             ParserDataFactory.make( ORBConstants.HIGH_WATER_MARK_PROPERTY,
                 OperationFactory.integerAction(),
                 "highWaterMark", new Integer( 240 ),
                 new Integer( 3745 ), "3745" ),
             ParserDataFactory.make( ORBConstants.LOW_WATER_MARK_PROPERTY,
                 OperationFactory.integerAction(),
                 "lowWaterMark", new Integer( 100 ),
                 new Integer( 12 ), "12" ),
             ParserDataFactory.make( ORBConstants.NUMBER_TO_RECLAIM_PROPERTY,
                 OperationFactory.integerAction(),
                 "numberToReclaim", new Integer( 5 ),
                 new Integer( 231 ), "231" ),
             ParserDataFactory.make( ORBConstants.GIOP_VERSION,
                 makeGVOperation(),
                 "giopVersion", GIOPVersion.DEFAULT_VERSION,
                 new GIOPVersion( 2, 3 ), "2.3" ),
             ParserDataFactory.make( ORBConstants.GIOP_FRAGMENT_SIZE,
                 makeFSOperation(), "giopFragmentSize",
                 new Integer( ORBConstants.GIOP_DEFAULT_FRAGMENT_SIZE ),
                 new Integer( 65536 ), "65536" ),
             ParserDataFactory.make( ORBConstants.GIOP_BUFFER_SIZE,
                 OperationFactory.integerAction(),
                 "giopBufferSize", new Integer( ORBConstants.GIOP_DEFAULT_BUFFER_SIZE ),
                 new Integer( 234000 ), "234000" ),
             ParserDataFactory.make( ORBConstants.GIOP_11_BUFFMGR,
                 makeBMGROperation(),
                 "giop11BuffMgr", new Integer( ORBConstants.DEFAULT_GIOP_11_BUFFMGR ),
                 new Integer( 1 ), "CLCT" ),
             ParserDataFactory.make( ORBConstants.GIOP_12_BUFFMGR,
                 makeBMGROperation(),
                 "giop12BuffMgr", new Integer( ORBConstants.DEFAULT_GIOP_12_BUFFMGR ),
                 new Integer( 0 ), "GROW" ),
             // Note that the same property is used to set two different
             // fields here.  This requires that both entries use the same test
             // data, or the test will fail.
             ParserDataFactory.make( ORBConstants.GIOP_TARGET_ADDRESSING,
                 OperationFactory.compose( OperationFactory.integerRangeAction( 0, 3 ),
                     OperationFactory.convertIntegerToShort() ),
                 "giopTargetAddressPreference",
                 new Short( ORBConstants.ADDR_DISP_HANDLE_ALL ),
                 new Short( (short)2 ), "2" ),
             ParserDataFactory.make( ORBConstants.GIOP_TARGET_ADDRESSING,
                 makeADOperation(),
                 "giopAddressDisposition", new Short( KeyAddr.value ),
                 new Short( (short)2 ), "2" ),
             ParserDataFactory.make( ORBConstants.ALWAYS_SEND_CODESET_CTX_PROPERTY,
                 OperationFactory.booleanAction(),
                 "alwaysSendCodeSetCtx", Boolean.TRUE,
                 Boolean.FALSE, "false"),
             ParserDataFactory.make( ORBConstants.USE_BOMS,
                 OperationFactory.booleanAction(),
                 "useByteOrderMarkers",
                     Boolean.valueOf( ORBConstants.DEFAULT_USE_BYTE_ORDER_MARKERS ),
                 Boolean.FALSE, "false" ),
             ParserDataFactory.make( ORBConstants.USE_BOMS_IN_ENCAPS,
                 OperationFactory.booleanAction(),
                 "useByteOrderMarkersInEncaps",
                     Boolean.valueOf( ORBConstants.DEFAULT_USE_BYTE_ORDER_MARKERS_IN_ENCAPS ),
                 Boolean.FALSE, "false" ),
             ParserDataFactory.make( ORBConstants.CHAR_CODESETS,
                 makeCSOperation(),
                 "charData", CodeSetComponentInfo.JAVASOFT_DEFAULT_CODESETS.getCharComponent(),
                 CodeSetComponentInfo.createFromString( codeSetTestString ), codeSetTestString ),
             ParserDataFactory.make( ORBConstants.WCHAR_CODESETS,
                 makeCSOperation(),
                 "wcharData", CodeSetComponentInfo.JAVASOFT_DEFAULT_CODESETS.getWCharComponent(),
                 CodeSetComponentInfo.createFromString( codeSetTestString ), codeSetTestString ),
             ParserDataFactory.make( ORBConstants.ALLOW_LOCAL_OPTIMIZATION,
                 OperationFactory.booleanAction(),
                 "allowLocalOptimization", Boolean.FALSE,
                 Boolean.TRUE, "true" ),
             ParserDataFactory.make( ORBConstants.LEGACY_SOCKET_FACTORY_CLASS_PROPERTY,
                 makeLegacySocketFactoryOperation(),
                 // No default - must be set by user if they are using
                 // legacy socket factory.
                 "legacySocketFactory", null,
                 new TestLegacyORBSocketFactory(),
                 MY_CLASS_NAME + "$TestLegacyORBSocketFactory" ),
             ParserDataFactory.make( ORBConstants.SOCKET_FACTORY_CLASS_PROPERTY,
                 makeSocketFactoryOperation(),
                 "socketFactory", new DefaultSocketFactoryImpl(),
                 new TestORBSocketFactory(),
                 MY_CLASS_NAME + "$TestORBSocketFactory" ),
             ParserDataFactory.make( ORBConstants.LISTEN_SOCKET_PROPERTY,
                 makeUSLOperation() ,
                 "userSpecifiedListenPorts", new USLPort[0],
                 USLPorts, "FOO:2701,BAR:3333" ),
             ParserDataFactory.make( ORBConstants.IOR_TO_SOCKET_INFO_CLASS_PROPERTY,
                 makeIORToSocketInfoOperation(),
                 "iorToSocketInfo", new DefaultIORToSocketInfoImpl(),
                 new TestIORToSocketInfo(),
                 MY_CLASS_NAME + "$TestIORToSocketInfo" ),
             ParserDataFactory.make( ORBConstants.IIOP_PRIMARY_TO_CONTACT_INFO_CLASS_PROPERTY,
                 makeIIOPPrimaryToContactInfoOperation(),
                 "iiopPrimaryToContactInfo", null,
                 new TestIIOPPrimaryToContactInfo(),
                 MY_CLASS_NAME + "$TestIIOPPrimaryToContactInfo" ),
             ParserDataFactory.make( ORBConstants.CONTACT_INFO_LIST_FACTORY_CLASS_PROPERTY,
                 makeContactInfoListFactoryOperation(),
                 "corbaContactInfoListFactory", null,
                 new TestContactInfoListFactory(),
                 MY_CLASS_NAME + "$TestContactInfoListFactory" ),
             ParserDataFactory.make( ORBConstants.PERSISTENT_SERVER_PORT_PROPERTY,
                 OperationFactory.integerAction(),
                 "persistentServerPort", new Integer( 0 ),
                 new Integer( 2743 ), "2743" ),
             ParserDataFactory.make( ORBConstants.PERSISTENT_SERVER_PORT_PROPERTY,
                 OperationFactory.setFlagAction(),
                 "persistentPortInitialized", Boolean.FALSE,
                 Boolean.TRUE, "2743" ),
             ParserDataFactory.make( ORBConstants.SERVER_ID_PROPERTY,
                 OperationFactory.integerAction(),
                 "persistentServerId", new Integer( 0 ),
                 new Integer( 294 ), "294" ),
             ParserDataFactory.make( ORBConstants.SERVER_ID_PROPERTY,
                 OperationFactory.setFlagAction(),
                 "persistentServerIdInitialized", Boolean.FALSE,
                 Boolean.TRUE, "294" ),
             ParserDataFactory.make( ORBConstants.SERVER_ID_PROPERTY,
                 OperationFactory.setFlagAction(),
                 "orbServerIdPropertySpecified", Boolean.FALSE,
                 Boolean.TRUE, "294" ),
             ParserDataFactory.make( ORBConstants.ACTIVATED_PROPERTY,
                 OperationFactory.booleanAction(),
                 "serverIsORBActivated", Boolean.FALSE,
                 Boolean.TRUE, "true" ),
             ParserDataFactory.make( ORBConstants.BAD_SERVER_ID_HANDLER_CLASS_PROPERTY,
                 OperationFactory.classAction(),
                 "badServerIdHandlerClass", null,
                 TestBadServerIdHandler.class, MY_CLASS_NAME + "$TestBadServerIdHandler" ),
             ParserDataFactory.make( ORBConstants.PI_ORB_INITIALIZER_CLASS_PREFIX,
                 makeROIOperation(),
                 "orbInitializers", new ORBInitializer[0],
                 TestORBInitializers, TestORBInitData, ORBInitializer.class ),
             ParserDataFactory.make( ORBConstants.ACCEPTOR_CLASS_PREFIX_PROPERTY,
                 makeAcceptorInstantiationOperation(),
                 "acceptors", new Acceptor[0],
                 TestAcceptors, TestAcceptorData, Acceptor.class ),
             //
             // Socket/Channel control
             //
             // Acceptor:
             // useNIOSelector == true
             //   useSelectThreadToWait = true
             //   useWorkerThreadForEvent = false
             // else
             //   useSelectThreadToWait = false
             //   useWorkerThreadForEvent = true
             // Connection:
             // useNIOSelector == true
             //   useSelectThreadToWait = true
             //   useWorkerThreadForEvent = true
             // else
             //   useSelectThreadToWait = false
             //   useWorkerThreadForEvent = true
             ParserDataFactory.make( ORBConstants.ACCEPTOR_SOCKET_TYPE_PROPERTY,
                 OperationFactory.stringAction(),
                 "acceptorSocketType", ORBConstants.SOCKETCHANNEL,
                 "foo", "foo" ),
             ParserDataFactory.make( ORBConstants.USE_NIO_SELECT_TO_WAIT_PROPERTY,
                 OperationFactory.booleanAction(),
                 "acceptorSocketUseSelectThreadToWait", Boolean.TRUE,
                 Boolean.TRUE, "true" ),
             ParserDataFactory.make( ORBConstants.ACCEPTOR_SOCKET_USE_WORKER_THREAD_FOR_EVENT_PROPERTY,
                 OperationFactory.booleanAction(),
                 "acceptorSocketUseWorkerThreadForEvent", Boolean.TRUE,
                 Boolean.TRUE, "true" ),
             ParserDataFactory.make( ORBConstants.CONNECTION_SOCKET_TYPE_PROPERTY,
                 OperationFactory.stringAction(),
                 "connectionSocketType", ORBConstants.SOCKETCHANNEL,
                 "foo", "foo" ),
             ParserDataFactory.make( ORBConstants.USE_NIO_SELECT_TO_WAIT_PROPERTY,
                 OperationFactory.booleanAction(),
                 "connectionSocketUseSelectThreadToWait", Boolean.TRUE,
                 Boolean.TRUE, "true" ),
             ParserDataFactory.make( ORBConstants.CONNECTION_SOCKET_USE_WORKER_THREAD_FOR_EVENT_PROPERTY,
                 OperationFactory.booleanAction(),
                 "connectionSocketUseWorkerThreadForEvent", Boolean.TRUE,
                 Boolean.TRUE, "true" ),
             ParserDataFactory.make( ORBConstants.DISABLE_DIRECT_BYTE_BUFFER_USE_PROPERTY,
                 OperationFactory.booleanAction(),
                 "disableDirectByteBufferUse", Boolean.FALSE,
                 Boolean.TRUE, "true" ),
             ParserDataFactory.make(ORBConstants.TRANSPORT_TCP_READ_TIMEOUTS_PROPERTY,
                 makeTTCPRTOperation(),
                 "readTimeouts",  TransportDefault.makeReadTimeoutsFactory().create(
                     ORBConstants.TRANSPORT_TCP_INITIAL_TIME_TO_WAIT,
                     ORBConstants.TRANSPORT_TCP_MAX_TIME_TO_WAIT,
                     ORBConstants.TRANSPORT_TCP_GIOP_HEADER_MAX_TIME_TO_WAIT,
                     ORBConstants.TRANSPORT_TCP_TIME_TO_WAIT_BACKOFF_FACTOR),
                 readTimeouts, "100:3000:300:20" ),
             ParserDataFactory.make(
                 ORBConstants.ENABLE_JAVA_SERIALIZATION_PROPERTY,
                 OperationFactory.booleanAction(),
                 "enableJavaSerialization", Boolean.FALSE,
                 Boolean.FALSE, "false"),
             ParserDataFactory.make(
                 ORBConstants.USE_REP_ID,
                 OperationFactory.booleanAction(),
                 "useRepId", Boolean.TRUE,
                 Boolean.TRUE, "true"),
             ParserDataFactory.make( ORBConstants.ORB_INIT_REF_PROPERTY,
                 OperationFactory.identityAction(),
                 "orbInitialReferences", new StringPair[0],
                 TestORBInitRefData, TestORBInitRefData, StringPair.class )
         } ;
         parserData = pd ;
     }
     public final class TestBadServerIdHandler implements BadServerIdHandler
     {
         public boolean equals( Object other )
         {
             return other instanceof TestBadServerIdHandler ;
         }
         public void handle( ObjectKey objectKey )
         {
         }
     }
     private Operation makeTTCPRTOperation()
     {
         Operation[] fourIop = { OperationFactory.integerAction(),
                                 OperationFactory.integerAction(),
                                 OperationFactory.integerAction(),
                                 OperationFactory.integerAction() } ;
         Operation op2 = OperationFactory.sequenceAction( ":", fourIop ) ;
         Operation rtOp = new Operation() {
             public Object operate(Object value)
             {
                 Object[] values = (Object[])value ;
                 Integer initialTime = (Integer)(values[0]) ;
                 Integer maxGIOPHdrTime = (Integer)(values[1]) ;
                 Integer maxGIOPBodyTime = (Integer)(values[2]) ;
                 Integer backoffPercent = (Integer)(values[3]) ;
                 return TransportDefault.makeReadTimeoutsFactory().create(
                                                    initialTime.intValue(),
                                                    maxGIOPHdrTime.intValue(),
                                                    maxGIOPBodyTime.intValue(),
                                                    backoffPercent.intValue());
             }
         } ;
         Operation ttcprtOp = OperationFactory.compose(op2, rtOp);
         return ttcprtOp;
     }
     private Operation makeUSLOperation()
     {
         Operation[] siop = { OperationFactory.stringAction(),
             OperationFactory.integerAction() } ;
         Operation op2 = OperationFactory.sequenceAction( ":", siop ) ;
         Operation uslop = new Operation() {
             public Object operate( Object value )
             {
                 Object[] values = (Object[])value ;
                 String type = (String)(values[0]) ;
                 Integer port = (Integer)(values[1]) ;
                 return new USLPort( type, port.intValue() ) ;
             }
         } ;
         Operation op3 = OperationFactory.compose( op2, uslop ) ;
         Operation listenop = OperationFactory.listAction( ",", op3 ) ;
         return listenop ;
     }
     public static final class TestLegacyORBSocketFactory
         implements com.sun.corba.se.spi.legacy.connection.ORBSocketFactory
     {
         public boolean equals( Object other )
         {
             return other instanceof TestLegacyORBSocketFactory ;
         }
         public ServerSocket createServerSocket( String type, int port )
         {
             return null ;
         }
         public SocketInfo getEndPointInfo( org.omg.CORBA.ORB orb,
             IOR ior, SocketInfo socketInfo )
         {
             return null ;
         }
         public Socket createSocket( SocketInfo socketInfo )
         {
             return null ;
         }
     }
     public static final class TestORBSocketFactory
         implements com.sun.corba.se.spi.transport.ORBSocketFactory
     {
         public boolean equals( Object other )
         {
             return other instanceof TestORBSocketFactory ;
         }
         public void setORB(ORB orb)
         {
         }
         public ServerSocket createServerSocket( String type, InetSocketAddress a )
         {
             return null ;
         }
         public Socket createSocket( String type, InetSocketAddress a )
         {
             return null ;
         }
         public void setAcceptedSocketOptions(Acceptor acceptor,
                                              ServerSocket serverSocket,
                                              Socket socket)
         {
         }
     }
     public static final class TestIORToSocketInfo
         implements IORToSocketInfo
     {
         public boolean equals( Object other )
         {
             return other instanceof TestIORToSocketInfo;
         }
         public List getSocketInfo(IOR ior)
         {
             return null;
         }
     }
     public static final class TestIIOPPrimaryToContactInfo
         implements IIOPPrimaryToContactInfo
     {
         public void reset(ContactInfo primary)
         {
         }
         public boolean hasNext(ContactInfo primary,
                                ContactInfo previous,
                                List contactInfos)
         {
             return true;
         }
         public ContactInfo next(ContactInfo primary,
                                 ContactInfo previous,
                                 List contactInfos)
         {
             return null;
         }
     }
     public static final class TestContactInfoListFactory
         implements CorbaContactInfoListFactory
     {
         public boolean equals( Object other )
         {
             return other instanceof TestContactInfoListFactory;
         }
         public void setORB(ORB orb) { }
         public CorbaContactInfoList create( IOR ior ) { return null; }
     }
     private Operation makeMapOperation( final Map map )
     {
         return new Operation() {
             public Object operate( Object value )
             {
                 return map.get( value ) ;
             }
         } ;
     }
     private Operation makeBMGROperation()
     {
         Map map = new HashMap() ;
         map.put( "GROW", new Integer(0) ) ;
         map.put( "CLCT", new Integer(1) ) ;
         map.put( "STRM", new Integer(2) ) ;
         return makeMapOperation( map ) ;
     }
     private Operation makeLegacySocketFactoryOperation()
     {
         Operation sfop = new Operation() {
             public Object operate( Object value )
             {
                 String param = (String)value ;
                 try {
                     Class legacySocketFactoryClass =
                         ORBClassLoader.loadClass(param);
                     // For security reasons avoid creating an instance if
                     // this socket factory class is not one that would fail
                     // the class cast anyway.
                     if (com.sun.corba.se.spi.legacy.connection.ORBSocketFactory.class.isAssignableFrom(legacySocketFactoryClass)) {
                         return legacySocketFactoryClass.newInstance();
                     } else {
                         throw wrapper.illegalSocketFactoryType( legacySocketFactoryClass.toString() ) ;
                     }
                 } catch (Exception ex) {
                     // ClassNotFoundException, IllegalAccessException,
                     // InstantiationException, SecurityException or
                     // ClassCastException
                     throw wrapper.badCustomSocketFactory( ex, param ) ;
                 }
             }
         } ;
         return sfop ;
     }
     private Operation makeSocketFactoryOperation()
     {
         Operation sfop = new Operation() {
             public Object operate( Object value )
             {
                 String param = (String)value ;
                 try {
                     Class socketFactoryClass = ORBClassLoader.loadClass(param);
                     // For security reasons avoid creating an instance if
                     // this socket factory class is not one that would fail
                     // the class cast anyway.
                     if (com.sun.corba.se.spi.transport.ORBSocketFactory.class.isAssignableFrom(socketFactoryClass)) {
                         return socketFactoryClass.newInstance();
                     } else {
                         throw wrapper.illegalSocketFactoryType( socketFactoryClass.toString() ) ;
                     }
                 } catch (Exception ex) {
                     // ClassNotFoundException, IllegalAccessException,
                     // InstantiationException, SecurityException or
                     // ClassCastException
                     throw wrapper.badCustomSocketFactory( ex, param ) ;
                 }
             }
         } ;
         return sfop ;
     }
     private Operation makeIORToSocketInfoOperation()
     {
         Operation op = new Operation() {
             public Object operate( Object value )
             {
                 String param = (String)value ;
                 try {
                     Class iorToSocketInfoClass = ORBClassLoader.loadClass(param);
                     // For security reasons avoid creating an instance if
                     // this socket factory class is not one that would fail
                     // the class cast anyway.
                     if (IORToSocketInfo.class.isAssignableFrom(iorToSocketInfoClass)) {
                         return iorToSocketInfoClass.newInstance();
                     } else {
                         throw wrapper.illegalIorToSocketInfoType( iorToSocketInfoClass.toString() ) ;
                     }
                 } catch (Exception ex) {
                     // ClassNotFoundException, IllegalAccessException,
                     // InstantiationException, SecurityException or
                     // ClassCastException
                     throw wrapper.badCustomIorToSocketInfo( ex, param ) ;
                 }
             }
         } ;
         return op ;
     }
     private Operation makeIIOPPrimaryToContactInfoOperation()
     {
         Operation op = new Operation() {
             public Object operate( Object value )
             {
                 String param = (String)value ;
                 try {
                     Class iiopPrimaryToContactInfoClass = ORBClassLoader.loadClass(param);
                     // For security reasons avoid creating an instance if
                     // this socket factory class is not one that would fail
                     // the class cast anyway.
                     if (IIOPPrimaryToContactInfo.class.isAssignableFrom(iiopPrimaryToContactInfoClass)) {
                         return iiopPrimaryToContactInfoClass.newInstance();
                     } else {
                         throw wrapper.illegalIiopPrimaryToContactInfoType( iiopPrimaryToContactInfoClass.toString() ) ;
                     }
                 } catch (Exception ex) {
                     // ClassNotFoundException, IllegalAccessException,
                     // InstantiationException, SecurityException or
                     // ClassCastException
                     throw wrapper.badCustomIiopPrimaryToContactInfo( ex, param ) ;
                 }
             }
         } ;
         return op ;
     }
     private Operation makeContactInfoListFactoryOperation()
     {
         Operation op = new Operation() {
             public Object operate( Object value )
             {
                 String param = (String)value ;
                 try {
                     Class contactInfoListFactoryClass =
                         ORBClassLoader.loadClass(param);
                     // For security reasons avoid creating an instance if
                     // this socket factory class is not one that would fail
                     // the class cast anyway.
                     if (CorbaContactInfoListFactory.class.isAssignableFrom(
                         contactInfoListFactoryClass)) {
                         return contactInfoListFactoryClass.newInstance();
                     } else {
                         throw wrapper.illegalContactInfoListFactoryType(
                             contactInfoListFactoryClass.toString() ) ;
                     }
                 } catch (Exception ex) {
                     // ClassNotFoundException, IllegalAccessException,
                     // InstantiationException, SecurityException or
                     // ClassCastException
                     throw wrapper.badContactInfoListFactory( ex, param ) ;
                 }
             }
         } ;
         return op ;
     }
     private Operation makeCSOperation()
     {
         Operation csop = new Operation() {
             public Object operate( Object value )
             {
                 String val = (String)value ;
                 return CodeSetComponentInfo.createFromString( val ) ;
             }
         } ;
         return csop ;
     }
     private Operation makeADOperation()
     {
         Operation admap = new Operation() {
             private Integer[] map = {
                 new Integer( KeyAddr.value ),
                 new Integer( ProfileAddr.value ),
                 new Integer( ReferenceAddr.value ),
                 new Integer( KeyAddr.value ) } ;
             public Object operate( Object value )
             {
                 int val = ((Integer)value).intValue() ;
                 return map[val] ;
             }
         } ;
         Operation rangeop = OperationFactory.integerRangeAction( 0, 3 ) ;
         Operation op1 = OperationFactory.compose( rangeop, admap ) ;
         Operation result = OperationFactory.compose( op1, OperationFactory.convertIntegerToShort() ) ;
         return result ;
     }
     private Operation makeFSOperation() {
         Operation fschecker = new Operation() {
             public Object operate( Object value )
             {
                 int giopFragmentSize = ((Integer)value).intValue() ;
                 if (giopFragmentSize < ORBConstants.GIOP_FRAGMENT_MINIMUM_SIZE){
                     throw wrapper.fragmentSizeMinimum( new Integer( giopFragmentSize ),
                         new Integer( ORBConstants.GIOP_FRAGMENT_MINIMUM_SIZE ) ) ;
                 }
                 if (giopFragmentSize % ORBConstants.GIOP_FRAGMENT_DIVISOR != 0)
                     throw wrapper.fragmentSizeDiv( new Integer( giopFragmentSize ),
                             new Integer( ORBConstants.GIOP_FRAGMENT_DIVISOR ) ) ;
                 return value ;
             }
         } ;
         Operation result = OperationFactory.compose( OperationFactory.integerAction(),
             fschecker ) ;
         return result ;
     }
     private Operation makeGVOperation() {
         Operation gvHelper = OperationFactory.listAction( ".",
             OperationFactory.integerAction() ) ;
         Operation gvMain = new Operation() {
             public Object operate( Object value )
             {
                 Object[] nums = (Object[])value ;
                 int major = ((Integer)(nums[0])).intValue() ;
                 int minor = ((Integer)(nums[1])).intValue() ;
                 return new GIOPVersion( major, minor ) ;
             }
         } ;
         Operation result = OperationFactory.compose( gvHelper, gvMain );
         return result ;
     }
     public static final class TestORBInitializer1 extends org.omg.CORBA.LocalObject
         implements ORBInitializer
     {
         public boolean equals( Object other )
         {
             return other instanceof TestORBInitializer1 ;
         }
         public void pre_init( ORBInitInfo info )
         {
         }
         public void post_init( ORBInitInfo info )
         {
         }
     }
     public static final class TestORBInitializer2 extends org.omg.CORBA.LocalObject
         implements ORBInitializer
     {
         public boolean equals( Object other )
         {
             return other instanceof TestORBInitializer2 ;
         }
         public void pre_init( ORBInitInfo info )
         {
         }
         public void post_init( ORBInitInfo info )
         {
         }
     }
     private Operation makeROIOperation() {
         Operation clsop = OperationFactory.classAction() ;
         Operation indexOp = OperationFactory.suffixAction() ;
         Operation op1 = OperationFactory.compose( indexOp, clsop ) ;
         Operation mop = OperationFactory.maskErrorAction( op1 ) ;
         Operation mkinst = new Operation() {
             public Object operate( Object value )
             {
                 final Class initClass = (Class)value ;
                 if (initClass == null)
                     return null ;
                 // For security reasons avoid creating an instance
                 // if this class is one that would fail the class cast
                 // to ORBInitializer anyway.
                 if( org.omg.PortableInterceptor.ORBInitializer.class.isAssignableFrom(
                     initClass ) ) {
                     // Now that we have a class object, instantiate one and
                     // remember it:
                     ORBInitializer initializer = null ;
                     try {
                         initializer = (ORBInitializer)AccessController.doPrivileged(
                             new PrivilegedExceptionAction() {
                                 public Object run()
                                     throws InstantiationException, IllegalAccessException
                                 {
                                     return initClass.newInstance() ;
                                 }
                             }
                         ) ;
                     } catch (PrivilegedActionException exc) {
                         // Unwrap the exception, as we don't care exc here
                         throw wrapper.orbInitializerFailure( exc.getException(),
                             initClass.getName() ) ;
                     } catch (Exception exc) {
                         throw wrapper.orbInitializerFailure( exc, initClass.getName() ) ;
                     }
                     return initializer ;
                 } else {
                     throw wrapper.orbInitializerType( initClass.getName() ) ;
                 }
             }
         } ;
         Operation result = OperationFactory.compose( mop, mkinst ) ;
         return result ;
     }
     public static final class TestAcceptor1
         implements Acceptor
     {
         public boolean equals( Object other )
         {
             return other instanceof TestAcceptor1 ;
         }
         public boolean initialize() { return true; }
         public boolean initialized() { return true; }
         public String getConnectionCacheType() { return "FOO"; }
         public void setConnectionCache(InboundConnectionCache connectionCache){}
         public InboundConnectionCache getConnectionCache() { return null; }
         public boolean shouldRegisterAcceptEvent() { return true; }
         public void setUseSelectThreadForConnections(boolean x) { }
         public boolean shouldUseSelectThreadForConnections() { return true; }
         public void setUseWorkerThreadForConnections(boolean x) { }
         public boolean shouldUseWorkerThreadForConnections() { return true; }
         public void accept() { }
         public void close() { }
         public EventHandler getEventHandler() { return null; }
         public MessageMediator createMessageMediator(
             Broker xbroker, Connection xconnection) { return null; }
         public MessageMediator finishCreatingMessageMediator(
             Broker xbroker, Connection xconnection,
             MessageMediator messageMediator) { return null; }
         public InputObject createInputObject(
             Broker broker, MessageMediator messageMediator) { return null; }
         public OutputObject createOutputObject(
             Broker broker, MessageMediator messageMediator) { return null; }
     }
     public static final class TestAcceptor2
         implements Acceptor
     {
         public boolean equals( Object other )
         {
             return other instanceof TestAcceptor2 ;
         }
         public boolean initialize() { return true; }
         public boolean initialized() { return true; }
         public String getConnectionCacheType() { return "FOO"; }
         public void setConnectionCache(InboundConnectionCache connectionCache){}
         public InboundConnectionCache getConnectionCache() { return null; }
         public boolean shouldRegisterAcceptEvent() { return true; }
         public void setUseSelectThreadForConnections(boolean x) { }
         public boolean shouldUseSelectThreadForConnections() { return true; }
         public void setUseWorkerThreadForConnections(boolean x) { }
         public boolean shouldUseWorkerThreadForConnections() { return true; }
         public void accept() { }
         public void close() { }
         public EventHandler getEventHandler() { return null; }
         public MessageMediator createMessageMediator(
             Broker xbroker, Connection xconnection) { return null; }
         public MessageMediator finishCreatingMessageMediator(
             Broker xbroker, Connection xconnection,
             MessageMediator messageMediator) { return null; }
         public InputObject createInputObject(
             Broker broker, MessageMediator messageMediator) { return null; }
         public OutputObject createOutputObject(
             Broker broker, MessageMediator messageMediator) { return null; }
     }
     // REVISIT - this is a cut and paste modification of makeROIOperation.
     private Operation makeAcceptorInstantiationOperation() {
         Operation clsop = OperationFactory.classAction() ;
         Operation indexOp = OperationFactory.suffixAction() ;
         Operation op1 = OperationFactory.compose( indexOp, clsop ) ;
         Operation mop = OperationFactory.maskErrorAction( op1 ) ;
         Operation mkinst = new Operation() {
             public Object operate( Object value )
             {
                 final Class initClass = (Class)value ;
                 if (initClass == null)
                     return null ;
                 // For security reasons avoid creating an instance
                 // if this class is one that would fail the class cast
                 // to ORBInitializer anyway.
                 if( Acceptor.class.isAssignableFrom( initClass ) ) {
                     // Now that we have a class object, instantiate one and
                     // remember it:
                     Acceptor acceptor = null ;
                     try {
                         acceptor = (Acceptor)AccessController.doPrivileged(
                             new PrivilegedExceptionAction() {
                                 public Object run()
                                     throws InstantiationException, IllegalAccessException
                                 {
                                     return initClass.newInstance() ;
                                 }
                             }
                         ) ;
                     } catch (PrivilegedActionException exc) {
                         // Unwrap the exception, as we don't care exc here
                         throw wrapper.acceptorInstantiationFailure( exc.getException(),
                             initClass.getName() ) ;
                     } catch (Exception exc) {
                         throw wrapper.acceptorInstantiationFailure( exc, initClass.getName() ) ;
                     }
                     return acceptor ;
                 } else {
                     throw wrapper.acceptorInstantiationTypeFailure( initClass.getName() ) ;
                 }
             }
         } ;
         Operation result = OperationFactory.compose( mop, mkinst ) ;
         return result ;
     }
     private Operation makeInitRefOperation() {
         return new Operation() {
             public Object operate( Object value )
             {
                 // Object is String[] of length 2.
                 String[] values = (String[])value ;
                 if (values.length != 2)
                     throw wrapper.orbInitialreferenceSyntax() ;
                 return values[0] + "=" + values[1] ;
             }
         } ;
     }
 }
 // End of file.

Mercurial > jdk8-mips64-public > corba / annotate

src/share/classes/com/sun/corba/se/impl/orb/ParserTable.java@e324dfb90c9e (annotated)

src/share/classes/com/sun/corba/se/impl/orb/ParserTable.java