Java CORBALogDomains类代码示例

import com.sun.corba.se.spi.logging.CORBALogDomains; //导入依赖的package包/类
public void init(org.omg.CORBA.ORB orb,
                    boolean littleEndian,
                    BufferManagerWrite bufferManager,
                    byte streamFormatVersion,
                    boolean usePooledByteBuffers)
{
    // ORB must not be null.  See CDROutputStream constructor.
    this.orb = (ORB)orb;
    this.wrapper = ORBUtilSystemException.get( this.orb,
        CORBALogDomains.RPC_ENCODING ) ;
    debug = this.orb.transportDebugFlag;

    this.littleEndian = littleEndian;
    this.bufferManagerWrite = bufferManager;
    this.bbwi = new ByteBufferWithInfo(orb, bufferManager, usePooledByteBuffers);
    this.streamFormatVersion = streamFormatVersion;

    createRepositoryIdHandlers();
}
 

import com.sun.corba.se.spi.logging.CORBALogDomains; //导入依赖的package包/类
public CorbaMessageMediator invoke(java.lang.Object servant,
                                   CorbaMessageMediator request,
                                   byte[] objectId,
                                   ObjectAdapter objectAdapter)
{
    ORB orb = (ORB)request.getBroker() ;
    ORBUtilSystemException wrapper = ORBUtilSystemException.get( orb,
        CORBALogDomains.OA_INVOCATION ) ;

    if ((servant == null) || (servant instanceof NullServant)) {
        return request.getProtocolHandler().createSystemExceptionResponse(
            request, wrapper.badSkeleton(), null);
    } else {
        return request.getProtocolHandler().createSystemExceptionResponse(
            request, wrapper.getinterfaceNotImplemented(), null);
    }
}
 

import com.sun.corba.se.spi.logging.CORBALogDomains; //导入依赖的package包/类
public CDROutputStream(ORB orb,
                       GIOPVersion version,
                       byte encodingVersion,
                       boolean littleEndian,
                       BufferManagerWrite bufferManager,
                       byte streamFormatVersion,
                       boolean usePooledByteBuffers)
{
    impl = OutputStreamFactory.newOutputStream(orb, version,
                                               encodingVersion);
    impl.init(orb, littleEndian, bufferManager,
              streamFormatVersion, usePooledByteBuffers);

    impl.setParent(this);
    this.orb = orb ;
    this.wrapper = ORBUtilSystemException.get( orb,
        CORBALogDomains.RPC_ENCODING ) ;
}
 

import com.sun.corba.se.spi.logging.CORBALogDomains; //导入依赖的package包/类
/**
 * Create a naming context servant.
 * Runs the super constructor.
 * @param orb an ORB object.
 * @param objKey as String
 * @param theNameService as NameService
 * @param theServantManagerImpl as ServantManagerImpl
 * @exception java.lang.Exception a Java exception.
 */

public NamingContextImpl(ORB orb, String objKey,
    NameService theNameService, ServantManagerImpl theServantManagerImpl  )
    throws Exception
{
    super();

    this.orb = orb;
    readWrapper = NamingSystemException.get( orb,
        CORBALogDomains.NAMING_READ ) ;
    updateWrapper = NamingSystemException.get( orb,
        CORBALogDomains.NAMING_UPDATE ) ;

    debug = true ; // orb.namingDebugFlag ;
    this.objKey = objKey;
    theNameServiceHandle = theNameService;
    theServantManagerImplHandle = theServantManagerImpl;
    insImpl =
        new com.sun.corba.se.impl.naming.cosnaming.InterOperableNamingImpl();
}
 

import com.sun.corba.se.spi.logging.CORBALogDomains; //导入依赖的package包/类
public SocketFactoryContactInfoImpl(
    ORB orb,
    CorbaContactInfoList contactInfoList,
    IOR effectiveTargetIOR,
    short addressingDisposition,
    SocketInfo cookie)
{
    super(orb, contactInfoList);
    this.effectiveTargetIOR = effectiveTargetIOR;
    this.addressingDisposition = addressingDisposition;

    wrapper = ORBUtilSystemException.get( orb,
        CORBALogDomains.RPC_TRANSPORT ) ;

    socketInfo =
        orb.getORBData().getLegacySocketFactory()
            .getEndPointInfo(orb, effectiveTargetIOR, cookie);

    socketType = socketInfo.getType();
    hostname = socketInfo.getHost();
    port = socketInfo.getPort();
}
 

import com.sun.corba.se.spi.logging.CORBALogDomains; //导入依赖的package包/类
public void init(org.omg.CORBA.ORB orb,
                 ByteBuffer byteBuffer,
                 int bufSize,
                 boolean littleEndian,
                 BufferManagerRead bufferManager) {
    this.orb = (ORB) orb;
    this.bufSize = bufSize;
    this.bufferManager = bufferManager;
    buffer = byteBuffer;
    wrapper =
        ORBUtilSystemException.get((ORB)orb, CORBALogDomains.RPC_ENCODING);

    byte[] buf;
    if (buffer.hasArray()) {
        buf = buffer.array();
    } else {
        buf = new byte[bufSize];
        buffer.get(buf);
    }
    // Note: at this point, the buffer position is zero. The setIndex()
    // method call can be used to set a desired read index.
    bis = new _ByteArrayInputStream(buf);
}
 

import com.sun.corba.se.spi.logging.CORBALogDomains; //导入依赖的package包/类
/**
 * Constructs a new TransientNamingContext object.
 * @param orb an orb object.
 * @param initial the initial naming context.
 * @exception Exception a Java exception thrown of the base class cannot
 * initialize.
 */
public TransientNamingContext(com.sun.corba.se.spi.orb.ORB orb,
    org.omg.CORBA.Object initial,
    POA nsPOA )
    throws java.lang.Exception
{
    super(orb, nsPOA );
    wrapper = NamingSystemException.get( orb, CORBALogDomains.NAMING ) ;

    this.localRoot = initial;
    readLogger = orb.getLogger( CORBALogDomains.NAMING_READ);
    updateLogger = orb.getLogger( CORBALogDomains.NAMING_UPDATE);
    lifecycleLogger = orb.getLogger(
        CORBALogDomains.NAMING_LIFECYCLE);
    lifecycleLogger.fine( "Root TransientNamingContext LIFECYCLE.CREATED" );
}
 

import com.sun.corba.se.spi.logging.CORBALogDomains; //导入依赖的package包/类
/**
 * Create a naming context servant.
 * Runs the super constructor.
 * @param orb an ORB object.
 * @param objKey as String
 * @param TheNameService as NameService
 * @param TheServantManagerImpl as ServantManagerImpl
 * @exception java.lang.Exception a Java exception.
 */

public NamingContextImpl(ORB orb, String objKey,
    NameService theNameService, ServantManagerImpl theServantManagerImpl  )
    throws Exception
{
    super();

    this.orb = orb;
    readWrapper = NamingSystemException.get( orb,
        CORBALogDomains.NAMING_READ ) ;
    updateWrapper = NamingSystemException.get( orb,
        CORBALogDomains.NAMING_UPDATE ) ;

    debug = true ; // orb.namingDebugFlag ;
    this.objKey = objKey;
    theNameServiceHandle = theNameService;
    theServantManagerImplHandle = theServantManagerImpl;
    insImpl =
        new com.sun.corba.se.impl.naming.cosnaming.InterOperableNamingImpl();
}
 

import com.sun.corba.se.spi.logging.CORBALogDomains; //导入依赖的package包/类
/**
 * Creates a new ORBInitInfoImpl object (scoped to package)
 *
 * @param args The arguments passed to ORB_init.
 */
ORBInitInfoImpl( ORB orb, String[] args,
    String orbId, CodecFactory codecFactory )
{
    this.orb = orb;

    wrapper = InterceptorsSystemException.get( orb,
        CORBALogDomains.RPC_PROTOCOL ) ;
    orbutilWrapper = ORBUtilSystemException.get( orb,
        CORBALogDomains.RPC_PROTOCOL ) ;
    omgWrapper = OMGSystemException.get( orb,
        CORBALogDomains.RPC_PROTOCOL ) ;

    this.args = args;
    this.orbId = orbId;
    this.codecFactory = codecFactory;
}
 

import com.sun.corba.se.spi.logging.CORBALogDomains; //导入依赖的package包/类
public void configure( DataCollector collector, ORB orb )
{
    ORB theOrb = orb ;
    wrapper = ORBUtilSystemException.get( orb, CORBALogDomains.ORB_LIFECYCLE ) ;

    initObjectCopiers( theOrb ) ;
    initIORFinders( theOrb ) ;

    theOrb.setClientDelegateFactory(
        // REVISIT: this should be ProtocolDefault.
        TransportDefault.makeClientDelegateFactory( theOrb )) ;

    initializeTransport(theOrb) ;

    initializeNaming( theOrb ) ;
    initServiceContextRegistry( theOrb ) ;
    initRequestDispatcherRegistry( theOrb ) ;
    registerInitialReferences( theOrb ) ;

    persistentServerInitialization( theOrb ) ;

    runUserConfigurators( collector, theOrb ) ;
}
 

import com.sun.corba.se.spi.logging.CORBALogDomains; //导入依赖的package包/类
private CDROutputObject(
    ORB orb, GIOPVersion giopVersion, Message header,
    BufferManagerWrite manager, byte streamFormatVersion,
    CorbaMessageMediator mediator)
{
    super(orb, giopVersion, header.getEncodingVersion(),
          false, manager, streamFormatVersion,
          ((mediator != null && mediator.getConnection() != null) ?
           ((CorbaConnection)mediator.getConnection()).
                 shouldUseDirectByteBuffers() : false));

    this.header = header;
    this.orb = orb;
    this.wrapper = ORBUtilSystemException.get( orb, CORBALogDomains.RPC_ENCODING ) ;
    this.omgWrapper = OMGSystemException.get( orb, CORBALogDomains.RPC_ENCODING ) ;

    getBufferManager().setOutputObject(this);
    this.corbaMessageMediator = mediator;
}
 

import com.sun.corba.se.spi.logging.CORBALogDomains; //导入依赖的package包/类
public static BufferManagerWrite newBufferManagerWrite(
        int strategy, byte encodingVersion, ORB orb) {
    if (encodingVersion != Message.CDR_ENC_VERSION) {
        if (strategy != BufferManagerFactory.GROW) {
            ORBUtilSystemException wrapper =
                ORBUtilSystemException.get((ORB)orb,
                                           CORBALogDomains.RPC_ENCODING);
            throw wrapper.invalidBuffMgrStrategy("newBufferManagerWrite");
        }
        return new BufferManagerWriteGrow(orb);
    }
    switch (strategy) {
        case BufferManagerFactory.GROW:
            return new BufferManagerWriteGrow(orb);
        case BufferManagerFactory.COLLECT:
            return new BufferManagerWriteCollect(orb);
        case BufferManagerFactory.STREAM:
            return new BufferManagerWriteStream(orb);
        default:
            throw new INTERNAL("Unknown buffer manager write strategy: "
                               + strategy);
    }
}
 

import com.sun.corba.se.spi.logging.CORBALogDomains; //导入依赖的package包/类
/**
 * NOTE:  size passed to init means buffer size
 */
public void init(org.omg.CORBA.ORB orb,
                 ByteBuffer byteBuffer,
                 int size,
                 boolean littleEndian,
                 BufferManagerRead bufferManager)
{
    this.orb = (ORB)orb;
    this.wrapper = ORBUtilSystemException.get( (ORB)orb,
        CORBALogDomains.RPC_ENCODING ) ;
    this.omgWrapper = OMGSystemException.get( (ORB)orb,
        CORBALogDomains.RPC_ENCODING ) ;
    this.littleEndian = littleEndian;
    this.bufferManagerRead = bufferManager;
    this.bbwi = new ByteBufferWithInfo(orb,byteBuffer,0);
    this.bbwi.buflen = size;
    this.bbwi.byteBuffer.limit(bbwi.buflen);
    this.markAndResetHandler = bufferManagerRead.getMarkAndResetHandler();

    debug = ((ORB)orb).transportDebugFlag;
}
 

import com.sun.corba.se.spi.logging.CORBALogDomains; //导入依赖的package包/类
RequestMessage_1_1(ORB orb, ServiceContexts _service_contexts,
        int _request_id, boolean _response_expected, byte[] _reserved,
        byte[] _object_key, String _operation,
        Principal _requesting_principal) {
    super(Message.GIOPBigMagic, GIOPVersion.V1_1, FLAG_NO_FRAG_BIG_ENDIAN,
        Message.GIOPRequest, 0);
    this.orb = orb;
    this.wrapper = ORBUtilSystemException.get( orb,
        CORBALogDomains.RPC_PROTOCOL ) ;
    service_contexts = _service_contexts;
    request_id = _request_id;
    response_expected = _response_expected;
    reserved = _reserved;
    object_key = _object_key;
    operation = _operation;
    requesting_principal = _requesting_principal;
}
 

import com.sun.corba.se.spi.logging.CORBALogDomains; //导入依赖的package包/类
/**
 * Creates a new CodecFactory implementation.  Stores the ORB that
 * created this factory, for later use by the Codec.
 */
public CodecFactoryImpl( ORB orb ) {
    this.orb = orb;
    wrapper = ORBUtilSystemException.get(
        (com.sun.corba.se.spi.orb.ORB)orb,
        CORBALogDomains.RPC_PROTOCOL ) ;

    // Precreate a codec for version 1.0 through
    // 1.(MAX_MINOR_VERSION_SUPPORTED).  This can be
    // done since Codecs are immutable in their current implementation.
    // This is an optimization that eliminates the overhead of creating
    // a new Codec each time create_codec is called.
    for( int minor = 0; minor <= MAX_MINOR_VERSION_SUPPORTED; minor++ ) {
        codecs[minor] = new CDREncapsCodec( orb, 1, minor );
    }
}